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

2020 ACM SIGPLAN International Conference on Systems, Programming, Languages, and Applications: Software for Humanity (SPLASH Companion 2020), November 15–20, 2020, Virtual, USA

SPLASH Companion 2020 – Preliminary Table of Contents

Contents - Abstracts - Authors


Title Page

Message from the Chairs



Doctoral Symposium

Machine Learning to Ease Understanding of Data Driven Compiler Optimizations
Raphael Mosaner
(JKU Linz, Austria)
Optimizing compilers use - often hand-crafted - heuristics to control optimizations such as inlining or loop unrolling. These heuristics are based on data such as size and structure of the parts to be optimized. A compilation, however, produces much more (platform specific) data that one could use as a basis for an optimization decision. We thus propose the use of machine learning (ML) to derive better optimization decisions from this wealth of data and to tackle the shortcomings of hand-crafted heuristics. Ultimately, we want to shed light on the quality and performance of optimizations by using empirical data with automated feedback and updates in a production compiler.

Article Search
Gradual Value-Dependent Information Flow Control
Eduardo Geraldo
(NOVA-LINCS, Portugal; Nova University of Lisbon, Portugal)
Data confidentiality is critical but cumbersome to ensure. To help in the task, we propose a gradual, value-dependent approach to information flow control targeting a small imperative language similar to existing low-level languages. With a hybrid approach, we seek to lessen the flaws of standalone static and dynamic analyses and heighten their advantages.

Article Search

Student Research Competition

SOAR: Synthesis for Open-Source API Refactoring
Aidan Z. H. Yang
(Queen's University, Canada)
The manual refactoring between APIs is a tedious and error prone task. We introduce Synthesis for Open-Source API Refactoring (SOAR), a novel technique that requires no training data to achieve API migration and refactoring. SOAR relies only on the documentation that is readily available at the release of the library to learn API representations and mapping between libraries. Using program synthesis, SOAR automatically computes the correct configuration of arguments to the APIs and any glue code that is required to invoke those APIs.

Article Search
SASIL: A Domain-Specific Language for Simulating Declarative Specifications of Scheduling Systems
Gahwon Lee
(University of Texas at Austin, USA)
SASIL is a domain-specific language to describe and execute the specification of scheduling systems. The language interpreter operates on time-dependent behaviors and reactive events to simulate the described system. Furthermore, the interpreter is capable of selecting the appropriate actions needed to automatically schedule necessary components of the system to resolve requests. The DSL was tested by implementing an elevator control system, which is defined as a series of button requests and the requirements needed to complete each request. A multi-elevator system described using the language allowed the interpreter to complete requests 1.04 times faster on average than the traditional elevator algorithm.

Article Search
Psamathe: A DSL for Safe Blockchain Assets
Reed Oei
(University of Illinois at Urbana-Champaign, USA)
Blockchains host smart contracts for voting, tokens, and other purposes. Vulnerabilities in contracts are common, often leading to the loss of money. Psamathe is a new language we are designing around a new flow abstraction, reducing asset bugs and making contracts more concise than in existing languages. We present an overview of Psamathe, and discuss two example contracts in Psamathe and Solidity.

Article Search
Detecting Performance Patterns with Deep Learning
Sophia Kolak
(Columbia University, USA)
Performance has a major impact on the overall quality of software projects. Performance bugs---bugs that substantially decrease run-time---have long been studied in software engineering, and yet they remain incredibly difficult for developers to handle. Because these bugs do not cause fail-stop errors, they are both harder to discover and to fix. As a result, techniques to help programmers detect and reason about performance are needed for managing performance bugs. Here we propose a static, probabilistic analysis technique to provide developers with useful information about potential performance bugs at the statement level. Using Leetcode samples scraped from real algorithms challenges, we use DeepWalk to embed data dependency graphs in Euclidean space. We then show how these graph embeddings can be used to detect which statements in code are likely to contribute to performance bugs.

Article Search
Consolidation: A Technique for Improving Permissiveness of Human-Machine Interfaces
Sang Heon Choi
(Rose-Hulman Institute of Technology, USA)
Erroneous software systems have led to accidents in the past []. To prevent accidents, software must be tested rigorously before deployment. However, the environment that the software operates in can deviate beyond the test cases that developers evaluated the system for. An inflexible system cannot account for environmental deviations, so the goal of our research project is to improve the flexibility of software systems. Our research falls under the umbrella of formal methods. Finite state automata can be used to model the discrete actions and states that a software system can be in. We introduce consolidation, a technique that maximises permissiveness (number of paths a user can use to execute actions) while still keeping the user safe. We plan to eventually incorporate consolidation into an automated system repair tool that improves permissiveness of software systems.

Article Search
Evaluating Importance of Edge Types when Using Graph Neural Network for Predicting Return Types of Python Functions
Vitaly Romanov
(Innopolis University, Russia)
The static prediction of types for dynamic programming languages is a challenging and important problem. Some success for Python was demonstrated by analyzing docstrings, still, a large portion of code comes without thorough documentation. To target this problem in this work we attempt to predict return type annotations for Python functions by looking at function usage patterns. We analyzed a collection of Python packages and created a graph that captures global relationships between source code elements such as imports, calls, and definitions. Moreover, we train embeddings for functions and evaluate how the performance of predicting return types is affected by removing one of the relationship types from the dataset.

Article Search
A Software Library Model for the Internet of Things
Ian C. McCormack
(University of Wisconsin-Eau Claire, USA)
Heterogeneity, resource constraints, and scalability are obstacles to making the IoT approachable for non-specialist programmers. To be successful and appealing in these environments, library systems must be as space-efficient and flexible as possible without fundamentally changing the process of creating and maintaining shared software. Existing library frameworks emphasize some but not all of these attributes and rely on a monolithic model that preserves mutable state. We propose a finer-grained approach to software libraries that allows developers to use multiple components of a library concurrently at disjoint versions. This model defines a library as a set of independent functions with immutable global state to avoid problems with distributed mutable state in dataflow environments. Library code is stored in a data dependency graph, which is traversed to produce a minimal copy of the library containing only what is necessary for a program. This design addresses the constraints of distributed systems and allows developers to quickly customize dependencies for their unique deployment situations.

Article Search
Design and Implementation of a Gradual Verifier
Mona Zhang and Jacob Gorenburg
(Columbia University, USA; Haverford College, USA)
Static program verification requires a large number of user-provided specifications, resulting in a significant upfront verification cost. One method for reducing this burden is gradual verification, a novel approach that enables developers to deal with the cost of verification incrementally — statically where possible and dynamically where necessary. In this paper, we discuss our work designing and implementing the static portion of a gradual verification tool.

Article Search

proc time: 2.14