Onward! 2021
2021 ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software (Onward! 2021)
Powered by
Conference Publishing Consulting

2021 ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software (Onward! 2021), October 20–22, 2021, Chicago, IL, USA

Onward! 2021 – Proceedings

Contents - Abstracts - Authors


Title Page

Welcome to Onward! 2021
Onward! is a premier multidisciplinary conference focused on everything to do with programming and software, including processes, methods, languages, communities, and applications. Onward! is more radical, more visionary, and more open than other conferences to ideas that are well-argued but not yet proven. We welcome different ways of thinking about, approaching, and reporting on programming language and software engineering research. Onward! 2021 is part of SPLASH 2021, taking place on October 17-22, 2021

Onward! 2021 Organization
Committee Listings


Dala: A Simple Capability-Based Dynamic Language Design for Data Race-Freedom
Kiko Fernandez-Reyes ORCID logo, Isaac Oscar Gariano ORCID logo, James NobleORCID logo, Erin Greenwood-Thessman, Michael Homer ORCID logo, and Tobias Wrigstad ORCID logo
(Uppsala University, Sweden; Victoria University of Wellington, New Zealand)
Dynamic languages like Erlang, Clojure, JavaScript, and E adopted data-race freedom by design. To enforce data-race freedom, these languages either deep copy objects during actor (thread) communication or proxy back to their owning thread. We present Dala, a simple programming model that ensures data-race freedom while supporting efficient inter-thread communication. Dala is a dynamic, concurrent, capability-based language that relies on three core capabilities: immutable values can be shared freely; isolated mutable objects can be transferred between threads but not aliased; local objects can be aliased within their owning thread but not dereferenced by other threads. Objects with capabilities can co-exist with unsafe objects, that are unchecked and may suffer data races, without compromising the safety of safe objects. We present a formal model of Dala, prove data race-freedom and state and prove a dynamic gradual guarantee. These theorems guarantee data race-freedom when using safe capabilities and show that the addition of capabilities is semantics preserving modulo permission and cast errors.

Publisher's Version
Programming with Neural Surrogates of Programs
Alex RendaORCID logo, Yi DingORCID logo, and Michael CarbinORCID logo
(Massachusetts Institute of Technology, USA)
Surrogates, models that mimic the behavior of programs, form the basis of a variety of development workflows. We study three surrogate-based design patterns, evaluating each in case studies on a large-scale CPU simulator.
With surrogate compilation, programmers develop a surrogate that mimics the behavior of a program to deploy to end-users in place of the original program. Surrogate compilation accelerates the CPU simulator under study by 1.6×. With surrogate adaptation, programmers develop a surrogate of a program then retrain that surrogate on a different task. Surrogate adaptation decreases the simulator’s error by up to 50%. With surrogate optimization, programmers develop a surrogate of a program, optimize input parameters of the surrogate, then plug the optimized input parameters back into the original program. Surrogate optimization finds simulation parameters that decrease the simulator’s error by 5% compared to the error induced by expert-set parameters.
In this paper we formalize this taxonomy of surrogate-based design patterns. We further describe the programming methodology common to all three design patterns. Our work builds a foundation for the emerging class of workflows based on programming with surrogates of programs.

Publisher's Version
Natural Language-Guided Programming
Geert Heyman ORCID logo, Rafael Huysegems ORCID logo, Pascal Justen, and Tom Van Cutsem ORCID logo
(Nokia Bell Labs, Belgium)
In today’s software world with its cornucopia of reusable software libraries, when a programmer is faced with a programming task that they suspect can be completed through the use of a library, they often look for code examples using a search engine and then manually adapt found examples to their specific context of use. We put forward a vision based on a new breed of developer tools that have the potential to largely automate this process. The key idea is to adapt code autocompletion tools such that they take into account not only the developer’s already-written code but also the intent of the task the developer is trying to achieve next, formulated in plain natural language. We call this practice of enriching the code with natural language intent to facilitate its completion natural language-guided programming.
To show that this idea is feasible we design, implement and benchmark a tool that solves this problem in the context of a specific domain (data science) and a specific programming language (Python). Central to the tool is the use of language models trained on a large corpus of documented code. Our initial experiments confirm the feasibility of the idea but also make it clear that we have only scratched the surface of what may become possible in the future. We end the paper with a comprehensive research agenda to stimulate additional research in the budding area of natural language-guided programming.

Publisher's Version Info
SkyQuery: An Aerial Drone Video Sensing Platform
Favyen BastaniORCID logo, Songtao He, Ziwen Jiang, Osbert BastaniORCID logo, and Sam Madden
(Massachusetts Institute of Technology, USA; University of Pennsylvania, USA)
Video-based sensing from aerial drones, especially small multirotor drones, can provide rich data for numerous applications, including traffic analysis (computing traffic flow volumes), precision agriculture (periodically evaluating plant health), and wildlife population management (estimating population sizes). However, aerial drone video sensing applications must handle a surprisingly wide range of tasks: video frames must be aligned so that we can equate coordinates of objects that appear in different frames, video data must be analyzed to extract application-specific insights, and drone routes must be computed that maximize the value of newly captured video. To address these challenges, we built SkyQuery, a novel aerial drone video sensing platform that provides an expressive, high-level programming language to make it straightforward for users to develop complex long-running sensing applications. SkyQuery combines novel methods for fast video frame alignment and detection of small objects in top-down aerial drone video to efficiently execute applications with diverse video analysis workflows and data distributions, thereby allowing application developers to focus on the unique qualities of their particular application rather than general video processing, data analysis, and drone routing tasks. We conduct diverse case studies using SkyQuery in parking monitoring, pedestrian activity mapping, and traffic hazard detection scenarios to demonstrate the generalizability and effectiveness of our system.

Publisher's Version Info
Kotlin Coroutines: Design and Implementation
Roman Elizarov, Mikhail Belyaev, Marat Akhin, and Ilmir Usmanov
(JetBrains, Russia; JetBrains Research, Russia; St. Petersburg Polytechnic University, Russia; JetBrains, Germany)
Asynchronous programming is having its “renaissance” moment in recent years. Created in the 1980s, it was in use for quite some time, but with the advent of multi-core processors, it has been sidestepped by multi-threaded programming, which was ‍(for a long time) the de facto standard of performing concurrent computations. However, since the 2000s, more and more programming languages have begun to include the support for asynchronous programming, some built around asynchronicity from the start, others including it later in their evolution.
In this paper, we explore the design and implementation of asynchronous programming in Kotlin, a multiplatform programming language from JetBrains, which uses coroutines for asynchronicity. Kotlin provides a compact built-in API for coroutine support, thus giving a lot of implementation freedom to the developer; this flexibility allows to transparently support different flavours of asynchronous programming within the same language.
We overview existing approaches to asynchronous programming, zoom in and talk about coroutines in detail, and describe how they are used in Kotlin as the basis for asynchronous computations. Along the way, we show the flexibility of Kotlin coroutines, highlight several existing problems with asynchronicity, how they are fixed or worked-around in Kotlin, and also mention future directions asynchronous programming might explore.

Publisher's Version
Motivating Complexity Understanding by Profiling Energy Usage
Joshua B. Gross ORCID logo, Daniel Jacoby, Kevin Coogan, and Aaron Helman
(California State University at Monterey Bay, USA; Hampton University, USA)
Computer science and software engineering students are typically taught to evaluate resource use in terms of time complexity. Developers use asymptotic analysis to compare algorithms by calculating how time grows as a function of input size. However, two factors have limited traditional models of complexity as pedagogical tools. First, modern systems are so fast that even relatively inefficient algorithms can quickly process large sets of data. Second, analysis is not universally engaging; only some students care about efficiency for the sake of efficiency. Our project proposes using measurements of energy consumption and the concomitant environmental impact to better engage students with efficiency and its implications.
Since current students have a strong level of concern about environmental consequences, we believe energy usage data will be more concrete and motivating than differences in time and will deepen the appreciation students have for computational complexity by using real-world measurements and by tying energy usage to climate change. We also believe that these future software engineers will be better equipped to contribute to the field by understanding the broader impact of software choices and resource usage. This approach is meant to augment and give meaning to traditional measurements of computational complexity, rather than supplant them.

Publisher's Version
Towards Self-Adaptable Languages
Gwendal JouneauxORCID logo, Olivier Barais ORCID logo, Benoit Combemale ORCID logo, and Gunter Mussbacher ORCID logo
(University of Rennes, France; Inria, France; IRISA, France; McGill University, Canada)
Over recent years, self-adaptation has become a concern for many software systems that have to operate in complex and changing environments. At the core of self-adaptation, there is a feedback loop and associated trade-off reasoning to decide on the best course of action. However, existing software languages do not abstract the development and execution of such feedback loops for self-adaptable systems. Developers have to fall back to ad-hoc solutions to implement self-adaptable systems, often with wide-ranging design implications (e.g., explicit MAPE-K loop). Furthermore, existing software languages do not capitalize on monitored usage data of a language and its modeling environment. This hinders the continuous and automatic evolution of a software language based on feedback loops from the modeling environment and runtime software system. To address the aforementioned issues, this paper introduces the concept of Self-Adaptable Language (SAL) to abstract the feedback loops at both system and language levels. We propose L-MODA (Language, Models, and Data) as a conceptual reference framework that characterizes the possible feedback loops abstracted into a SAL. To demonstrate SALs, we present emerging results on the abstraction of the system feedback loop into the language semantics. We report on the concept of Self-Adaptable Virtual Machines as an example of semantic adaptation in a language interpreter and present a roadmap for SALs.

Publisher's Version


Programming as Architecture, Design, and Urban Planning
Tomas Petricek ORCID logo
(University of Kent, UK)
Our thinking about software is shaped by basic assumptions and metaphors that we rarely question. Computer science has the term science in its very name; we think of programming languages as formal mathematical objects and we hope to make better software by treating it as an engineering discipline. Those perspectives enabled a wide range of useful developments, but I believe they have outlived their usefulness. We need new ways of thinking about software that are able to cope with ill-defined problems and the increasing complexity of software. In this essay, I draw a parallel between the world of software and the world of architecture, design and urban planning. I hope to convince the reader that this is a well-justified parallel and I point to a number of discussions in architecture, design and urban planning from which the software world could learn. What kind of software may we be able to build if we think of programming as a design problem and aim to create navigable and habitable software for all its users?

Publisher's Version
The Kingdoms of Objects and Values
Friedrich Steimann ORCID logo
(Fernuniversität in Hagen, Germany)
THE purpose of the following paper is to consider whether there is a fundamental division of the [data] with which [programming] is concerned into two classes, [objects] and [values], or whether there is any method of overcoming this dualism. My own opinion is that the dualism is ultimate; on the other hand, many [colleagues] with whom, in the main, I am in close agreement, hold that it is not ultimate.
(paraphrased after Bertrand Russell)

Publisher's Version
Let a Thousand Flowers Bloom: On the Uses of Diversity in Software Testing
Alex GroceORCID logo
(Northern Arizona University, USA)
Software testing is hard, and a testing problem is composed of many sub-problems with different, often conflicting, solutions. Like many real-world problems, it admits no single optimal solution, but requires dexterity, and the opportunistic combination of many partial solutions. Exploration and experiment, even by practitioners, are important in real-world critical testing efforts. An important set of research results in the field endorse and codify the value of diversity in test generation. However, our current approaches to evaluating research results arguably cut against this fundamental reality: while effective testing may need true diversity, combining many partial answers, the iron logic of the research results section often imposes a totalizing vision where authors must at least pretend to present a monolithic, unitary solution, a new “king of the hill.”

Publisher's Version
Angelic and Demonic Visitation: School Memories
Leila Salem
(University of Toronto, Canada)
The whole activity of programming can be thought of as a process of time reusability. This essay considers how computing education can transform these errors into shared learning journeys by refining the relationship between programmer and user. It is also an interpretation of Ralph-Johan Back’s Changing data representation in the refinement calculus.

Publisher's Version

proc time: 3.8