SPLASH Companion 2017
2017 ACM SIGPLAN International Conference on Systems, Programming, Languages, and Applications: Software for Humanity (SPLASH Companion 2017)
Powered by
Conference Publishing Consulting

2017 ACM SIGPLAN International Conference on Systems, Programming, Languages, and Applications: Software for Humanity (SPLASH Companion 2017), October 22–27, 2017, Vancouver, BC, Canada

SPLASH Companion 2017 – Proceedings

Contents - Abstracts - Authors

Frontmatter

Title Page

Welcome from the SPLASH 2017 General Chair
On behalf of the entire SPLASH organizing committee, I am delighted to welcome you to Vancouver BC Canada for SPLASH 2017! This year marks the 8th occurrence of SPLASH, which serves as an umbrella event that embraces all aspects of software construction and delivery. At the center of SPLASH is OOPSLA, a flagship conference of ACM SIGPLAN with a now 32-year history. OOPSLA is a broad conference, covering all aspects and paradigms of programming languages and systems. This year marks the fourth time OOPSLA will be held in Vancouver, which has emerged as a dynamic tech hub on both the Canadian and global scene.
Message from the OOPSLA 2017 Program Chair
On behalf of the program committee, it is my pleasure to present the program of the 2017 ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications!
SPLASH 2017 Organization
Committee listings
Message from the SPLASH 2017 Workshop Chairs
It is our pleasure to welcome you to beautiful Vancouver, British Columbia, Canada, for the 2017 edition of the SPLASH Workshops. Following its long-standing tradition, SPLASH 2017 will host 19 high-quality workshops, allowing their participants to meet and discuss research questions with peers, to mature new and exciting ideas, and to build up communities and start new collaborations. SPLASH workshops complement the main tracks of the conference and provide meetings in a smaller and more specialized setting. Workshops cultivate new ideas and concepts for the future, optionally recorded in formal proceedings. We invite you to explore the workshops program online at https://2017.splashcon.org/track/splash-2017-Workshops
SPLASH 2017 Sponsors and Supporters


Doctoral Symposium

How to Make Tasks Faster: Revealing the Complex Interactions of Tasks in the Memory System
Germán Ceballos
(Uppsala University, Sweden)
New programming models have been introduced to aid the programmer dealing with the complexity of large-scale systems, simplifying the coding process and making applications more scalable regardless. Task-based programming is one example that became popular recently. At the same time, understanding performance of multicore systems is crucial for getting faster execution times and to optimize efficiency, but it is becoming harder due to the increased complexity of hardware architectures, and the interplay between the scheduling of tasks and caches. In this work, we develop models to understand how scheduling affects the performance of tasks due to memory behavior in the task-based context, and for that, we study cache sharing both in temporal and spatial ways. In temporal cache sharing, the effect of data reused over time by the tasks executed is modeled to predict different scenarios resulting in a tool called StatTask. In spatial cache sharing, the effect of tasks fighting for the cache at a given point in time through their execution is quantified and used to model their behavior on arbitrary cache sizes. We also present a new methodology called TaskInsight that can explain performance differences across different schedules for the same application. Finally, we explain how these methods set up a unique and solid platform to reveal insight into how to improve the performance of the execution of large-scale task-based applications.
Publisher's Version Article Search
Combining Visual and Textual Languages for Dyslexia
Luis F. González
(Universidad Politécnica de Madrid, Spain; Politecnico Colombiano Jaime Isaza Cadavid, Colombia)
This paper describes the research of a Software, Systems and Computing PhD thesis conducted at the Universidad Politécnica de Madrid. The aim of this research is threefold: i) design a model to promote interaction between programmers with and without dyslexia during software development as part of a team, ii) overcome the obstacles facing dyslexic programmers when they are writing a program, and iii) increase software development performance and efficiency levels when one of the programmers has symptoms of dyslexia.
Publisher's Version Article Search
Genetic Improvement in Code Interpreters and Compilers
Oliver Krauss
(JKU Linz, Austria; University of Applied Sciences Upper Austria at Hagenberg, Austria)
Modern compilers provide code optimizations before and during run-time, thus moving required domain knowledge about the compilation process away from the developer and speeding up resulting software. These optimizations are often based on formal proof, or alternatively have recovery paths as backup. Genetic improvement (GI), a field of science utilizing genetic programming, a stochastic optimization technique, has been previously utilized to fix bugs in software and improve non-functional software requirements. This work proposes to research the applicability of GI in an offline phase directly at the interpreter or compiler level. The primary goal is to reformulate existing source code in such a way that existing optimizations can be applied in order to increase performance even further and requiring even less domain knowledge from the developer about a programming language and/or compiler. From these reformulations, patterns can be identified that allow code restructuring without the overhead GI poses.
Publisher's Version Article Search
Simulation-Based Code Duplication for Enhancing Compiler Optimizations
David Leopoldseder
(JKU Linz, Austria)
The scope of compiler optimizations is often limited by control flow, which prohibits optimizations across basic block boundaries. Code duplication can solve this problem by extending basic block sizes, thus enabling subsequent optimizations. However, duplicating code for every optimization opportunity may lead to excessive code growth. Therefore, a holistic approach is required that is capable of finding optimization opportunities and classifying their impact. This paper presents a novel approach to determine which code should be duplicated in order to improve peak performance. The approach analyzes duplication candidates for subsequent optimizations opportunities. It does so by simulating a duplication and analyzing its impact on other optimizations. This allows a compiler to weight up multiple success metrics in order to choose those duplications with the maximum optimization potential. We further show how to map code duplication opportunities to an optimization cost model that allows us to maximize performance while minimizing code size increase.
Publisher's Version Article Search
Advanced Debugging Techniques to Identify Concurrency Bugs in Actor-based Programs
Carmen Torres Lopez
(Vrije Universiteit Brussel, Belgium)
Actor-based programs are not exempt from concurrency bugs. Inspiring contributions for debugging actor-based programs have been developed, however there is no approach that reliably identifies the root cause of complex concurrency bugs. Solving this problem can result in a reduction of the debugging time that programmers spend when developing concurrent applications. I propose a debugging approach based on the combination of offline debugging techniques that aim to help developers in the process of finding the root cause of concurrency bugs. I plan to evaluate this proposal through user studies and performance evaluation.
Publisher's Version Article Search

Student Research Competition

Graduate Students

Framework Support for Usability Evaluation of Domain-Specific Languages
Ankica Barišić
(Nova University of Lisbon, Portugal)
In this paper we propose a conceptual framework that supports the iterative development process of DSLs concerning the issue of their Usability evaluation. A multiple-case studies were conducted in order validate the proposed method.
Publisher's Version Article Search Video
What Merge Tool Should I Use?
Guilherme Cavalcanti
(Federal University of Pernambuco, Brazil)
While unstructured merge tools try to automatically resolve merge conflicts via textual similarity, semistructured and structured merge tools try to go further by exploiting the syntactic structure and semantics of the involved artefacts. Previous studies compare these merge approaches with respect to the number of reported conflicts, showing, for most projects and merge situations, a reduction in favor of semistructured and structured merge. However, these studies do not investigate whether this reduction actually leads to integration effort reduction (Productivity) without negative impact on the correctness of the merging process (Quality). To analyze this, and to better understand how these tools could be improved, we propose empirical studies to identify spurious conflicts (false positives) reported by one approach but not by the other, and interference reported as conflict by one approach but missed by the other (false negatives).
Publisher's Version Article Search
Understanding the Interplay between Task Scheduling, Memory and Performance
Germán Ceballos, Erik Hagersten, and David Black-Schaffer
(Uppsala University, Sweden)

New programming models have been introduced to aid the programmer dealing with the complexity of large-scale systems, simplifying the coding process and making applications more scalable. Task-based programming is one example that became popular recently. At the same time, understanding performance of multicore systems is key for getting faster execution times and optimize workloads, but it is becoming harder due to the increased complexity of hardware and the runtime systems.

To address this, we present TaskInsight, a technique to characterize the memory behavior of different task schedulers through the analysis of data reuse. TaskInsight provides high-level information that can be correlated with tasks’ performance variation over time to understand data reuse through the caches due to scheduling choices. This allows to identify which scheduling decisions affected performance, when were they taken, and why the performance changed, both in single and multi-threaded executions.

We demonstrate how TaskInsight can diagnose cases where poor scheduling caused over 60% difference on average (and up to 7x slowdowns) due to changes in the tasks’ data reuse through the caches.


Publisher's Version Article Search
Automatic Testing of Interactive JavaScript Debuggers
Daniel Lehmann
(TU Darmstadt, Germany)
When debugging programs, we often assume the debugger itself is correct. However, when it is not, it becomes hard to find bugs or lets developers search for bugs that are not even present. We thus propose a new approach to automatic testing of debuggers, inspired by differential testing of compilers. Our approach generates debugger actions to exercise the debugger and records a trace during the debugging session. By comparing traces of different debuggers against each other, we find deviating behavior and bugs. We evaluate our approach on the JavaScript debuggers of Firefox and Chromium and find 16 previously unreported bugs, four of which are already confirmed and fixed.
Publisher's Version Article Search
Computer-Assisted Specification of Asynchronous Interfaces with Non-deterministic Behavior
Nicholas V. Lewchenko
(University of Colorado at Boulder, USA)

The Android Framework is designed around components with asynchronous interfaces, in which inputs and outputs are not directly coupled. Precisely specifying behavior of this sort is a slow, error-prone process, and thus documentation and testing for such components is usually incomplete. I have participated over the last year in a collaborative research project seeking to solve this problem by automating the generation and verification of these specifications via active learning on a live Android system. Part of my work has been the extension of our automation technique to Android Framework components with non-deterministic behavior that prevents direct application of active learning algorithms. To this end, I have applied our learning engine in the form of a specification assistant which mixes automation and manual guidance to learn non-deterministic interfaces with as little user intervention as possible.


Publisher's Version Article Search
Verifying the Proxy Design Pattern using Object Propositions
Ligia Nistor
(Carnegie Mellon University, USA)
In this extended abstract we explore the expressiveness and modularity of our recently published object propositions methodology by applying it to verify properties about programs that use the proxy design pattern. Our instance of the proxy pattern implements a general proxy-real object system that is routinely used in industry and the verification of which is challenging.
Publisher's Version Article Search

Undergraduate Students

ZenSheet Studio: A Spreadsheet-Inspired Environment for Reactive Computing
Monica Figuera
(Simón Bolívar University, Venezuela)
Widely criticized as error-prone, causing millions of dollars in losses, spreadsheets continue to be extremely popular, decades after their introduction. The ZenSheet project aims to turn spreadsheets into modern and robust computing environments, with minimal impact on the learning curve. This paper focuses on ZenSheet Studio: a web client that delivers a generalized spreadsheet computing experience.
Publisher's Version Article Search Info
How to Efficiently Process 2100 List Variations
Lukas Lazarek
(University of Massachusetts at Lowell, USA)
Variational execution offers an avenue of efficiently analyzing configurable systems, but data structures like lists require special consideration. We implement automatic substitution of a more efficient list representation in a variational execution framework and evaluate its performance in micro-benchmarks. The results suggest that the substitution may offer substantial performance improvements to programs involving highly variational lists.
Publisher's Version Article Search
How Are Programming Questions from Women Received on Stack Overflow? A Case Study of Peer Parity
Savannah Morgan
(Centre College, USA)

Stack Overflow is a useful Q&A online community for programmers. However, it has not been as popular among programmers who are women. Prior studies have shown low participation of women programmers on Stack Overflow, but have not demonstrated how the presence of their peers may promote activity. In this work, we understand how the presence of women, through peer parity, can encourage women to participate more on Stack Overflow. We extracted 3,2209,817 posts from the most recent Stack Overflow data dump. By modifying a popular gender computing tool, we took the first names of online users and identified the gender of 2,502,438 users from the 5,987,284 list of current users. We randomly selected peer parity and non peer parity questions asked by women and identify differences in participation on those posts. We found that women become more active after they have taken part in a peer parity post. With further analysis of peer parity through eye tracking and tone detection tools we can determine ways to foster a more welcoming community that would encourage women to participate.


Publisher's Version Article Search
Devirtualization in LLVM
Piotr Padlewski
(University of Warsaw, Poland)
Devirtualization is an optimization changing indirect (virtual) calls to direct calls. It improves performance by allowing extra inlining and removal of redundant loads. This paper presents a novel way of handling C++ devirtualization in LLVM by unifying virtual table loads across calls using different SSA values to represent different dynamic types.
Publisher's Version Article Search
Principles, Patterns, and Techniques for Designing and Implementing Practical Fluent Interfaces in Java
Haochen Xie
(Nagoya University, Japan)

In this research, the author sought a meta-theory that establishes essential concepts and fundamental techniques in helping programmers design and implement practical fluent interfaces in the Java language. An anatomy of the conceptual establishment of fluent interfaces is established and presented. Six primitives, roles that a key method could play are also identified. The author also coined the term transition choreography and attributed it as the core of the design theory for practical fluent interfaces in Java. Results in this research may apply as well in languages other than Java.


Publisher's Version Article Search Info
Abstracting Resource Effects
Valerie Zhao
(Wellesley College, USA)
In developing secure programs, reasoning about effects on resources can be hindered by obscure changes in program state. Effect systems mitigate this difficulty by describing these changes, but may require large amounts of low-level effect annotations, and create obstacles for reasoning. To reduce overhead, we propose an effect system, with a focus on system resources, that supports effect abstraction. It is being implemented in Wyvern, a capability-safe language.
Publisher's Version Article Search

Posters

SmartJS: Dynamic and Self-Adaptable Runtime Middleware for Next-Generation IoT Systems
Julien Gascon-Samson, Mohammad Rafiuzzaman, and Karthik Pattabiraman
(University of British Columbia, Canada)

The Internet of Things (IoT) has gained wide popularity both in the academic and industrial contexts. However, IoT-based systems exhibit many important challenges across many dimensions. In this work, we propose SmartJS, a rich Javascript-based middleware platform and runtime environment that abstracts the complexity of the various IoT platforms by providing a high-level framework for IoT system developers. SmartJS abstracts large-scale distributed system considerations, such as scheduling, monitoring and self-adaptation, and proposes a rich inter-device Javascript-based code migration framework. Finally, it provides debugging and monitoring techniques to analyze performance and observe system-wide security properties.


Publisher's Version Article Search
Incremental Parametric Syntax for Multi-Language Transformation
James Koppel and Armando Solar-Lezama
(Massachusetts Institute of Technology, USA)

We present a new approach for building source-to-source transformations that can run on multiple programming languages, based on a new way of representing programs called incremental parametric syntax. We implement this approach in our Cubix system, and construct incremental parametric syntaxes for C, Java, JavaScript, Lua, and Python, demonstrating three multi-language program transformations that can run on all of them. Our evaluation shows that (1) once a transformation is written, relatively little work is required to configure it for a new language (2) transformations built this way output readable code which preserve the structure of the original, according to participants in our human study, and (3) despite dealing with many languages, our transformations can still handle language corner-cases, and pass 90% of compiler test suites.


Publisher's Version Article Search
QuixBugs: A Multi-Lingual Program Repair Benchmark Set Based on the Quixey Challenge
Derrick Lin, James Koppel, Angela Chen, and Armando Solar-Lezama
(Massachusetts Institute of Technology, USA; Google, USA)
Recent years have seen an explosion of work in automated program repair. While previous work has focused exclusively on tools for single languages, recent work in multi-language transformation has opened the door for multi-language program repair tools. Evaluating the performance of such a tool requires having a benchmark set of similar buggy programs in different languages. We present QuixBugs, consisting of 40 programs translated to both Python and Java, each with a bug on a single line. The QuixBugs benchmark suite is based on problems from the Quixey Challenge, where programmers were given a short buggy program and 1 minute to fix the bug.
Publisher's Version Article Search

proc time: 0.29