Onward! '21: "Kotlin Coroutines: Design ..."
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.
@InProceedings{Onward!21p68,
author = {Roman Elizarov and Mikhail Belyaev and Marat Akhin and Ilmir Usmanov},
title = {Kotlin Coroutines: Design and Implementation},
booktitle = {Proc.\ Onward!},
publisher = {ACM},
pages = {68--84},
doi = {10.1145/3486607.3486751},
year = {2021},
}
Publisher's Version
Onward! '21: "Towards Self-Adaptable Languages ..."
Towards Self-Adaptable Languages
Gwendal Jouneaux, Olivier Barais, Benoit Combemale, and Gunter Mussbacher
(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.
@InProceedings{Onward!21p97,
author = {Gwendal Jouneaux and Olivier Barais and Benoit Combemale and Gunter Mussbacher},
title = {Towards Self-Adaptable Languages},
booktitle = {Proc.\ Onward!},
publisher = {ACM},
pages = {97--113},
doi = {10.1145/3486607.3486753},
year = {2021},
}
Publisher's Version
Onward! '21: "SkyQuery: An Aerial Drone ..."
SkyQuery: An Aerial Drone Video Sensing Platform
Favyen Bastani, Songtao He, Ziwen Jiang, Osbert Bastani, 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.
@InProceedings{Onward!21p56,
author = {Favyen Bastani and Songtao He and Ziwen Jiang and Osbert Bastani and Sam Madden},
title = {SkyQuery: An Aerial Drone Video Sensing Platform},
booktitle = {Proc.\ Onward!},
publisher = {ACM},
pages = {56--67},
doi = {10.1145/3486607.3486750},
year = {2021},
}
Publisher's Version
Info
Onward! '21: "SkyQuery: An Aerial Drone ..."
SkyQuery: An Aerial Drone Video Sensing Platform
Favyen Bastani, Songtao He, Ziwen Jiang, Osbert Bastani, 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.
@InProceedings{Onward!21p56,
author = {Favyen Bastani and Songtao He and Ziwen Jiang and Osbert Bastani and Sam Madden},
title = {SkyQuery: An Aerial Drone Video Sensing Platform},
booktitle = {Proc.\ Onward!},
publisher = {ACM},
pages = {56--67},
doi = {10.1145/3486607.3486750},
year = {2021},
}
Publisher's Version
Info
Onward! '21: "Kotlin Coroutines: Design ..."
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.
@InProceedings{Onward!21p68,
author = {Roman Elizarov and Mikhail Belyaev and Marat Akhin and Ilmir Usmanov},
title = {Kotlin Coroutines: Design and Implementation},
booktitle = {Proc.\ Onward!},
publisher = {ACM},
pages = {68--84},
doi = {10.1145/3486607.3486751},
year = {2021},
}
Publisher's Version
Onward! '21: "Programming with Neural Surrogates ..."
Programming with Neural Surrogates of Programs
Alex Renda, Yi Ding, and Michael Carbin
(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.
@InProceedings{Onward!21p18,
author = {Alex Renda and Yi Ding and Michael Carbin},
title = {Programming with Neural Surrogates of Programs},
booktitle = {Proc.\ Onward!},
publisher = {ACM},
pages = {18--38},
doi = {10.1145/3486607.3486748},
year = {2021},
}
Publisher's Version
Onward! '21: "Towards Self-Adaptable Languages ..."
Towards Self-Adaptable Languages
Gwendal Jouneaux, Olivier Barais, Benoit Combemale, and Gunter Mussbacher
(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.
@InProceedings{Onward!21p97,
author = {Gwendal Jouneaux and Olivier Barais and Benoit Combemale and Gunter Mussbacher},
title = {Towards Self-Adaptable Languages},
booktitle = {Proc.\ Onward!},
publisher = {ACM},
pages = {97--113},
doi = {10.1145/3486607.3486753},
year = {2021},
}
Publisher's Version
Onward! '21: "Motivating Complexity Understanding ..."
Motivating Complexity Understanding by Profiling Energy Usage
Joshua B. Gross, 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.
@InProceedings{Onward!21p85,
author = {Joshua B. Gross and Daniel Jacoby and Kevin Coogan and Aaron Helman},
title = {Motivating Complexity Understanding by Profiling Energy Usage},
booktitle = {Proc.\ Onward!},
publisher = {ACM},
pages = {85--96},
doi = {10.1145/3486607.3486752},
year = {2021},
}
Publisher's Version
Onward! '21: "Programming with Neural Surrogates ..."
Programming with Neural Surrogates of Programs
Alex Renda, Yi Ding, and Michael Carbin
(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.
@InProceedings{Onward!21p18,
author = {Alex Renda and Yi Ding and Michael Carbin},
title = {Programming with Neural Surrogates of Programs},
booktitle = {Proc.\ Onward!},
publisher = {ACM},
pages = {18--38},
doi = {10.1145/3486607.3486748},
year = {2021},
}
Publisher's Version
Onward! '21: "Kotlin Coroutines: Design ..."
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.
@InProceedings{Onward!21p68,
author = {Roman Elizarov and Mikhail Belyaev and Marat Akhin and Ilmir Usmanov},
title = {Kotlin Coroutines: Design and Implementation},
booktitle = {Proc.\ Onward!},
publisher = {ACM},
pages = {68--84},
doi = {10.1145/3486607.3486751},
year = {2021},
}
Publisher's Version
Onward! '21: "Dala: A Simple Capability-Based ..."
Dala: A Simple Capability-Based Dynamic Language Design for Data Race-Freedom
Kiko Fernandez-Reyes, Isaac Oscar Gariano, James Noble, Erin Greenwood-Thessman, Michael Homer, and Tobias Wrigstad
(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.
@InProceedings{Onward!21p1,
author = {Kiko Fernandez-Reyes and Isaac Oscar Gariano and James Noble and Erin Greenwood-Thessman and Michael Homer and Tobias Wrigstad},
title = {Dala: A Simple Capability-Based Dynamic Language Design for Data Race-Freedom},
booktitle = {Proc.\ Onward!},
publisher = {ACM},
pages = {1--17},
doi = {10.1145/3486607.3486747},
year = {2021},
}
Publisher's Version
Onward! '21: "Dala: A Simple Capability-Based ..."
Dala: A Simple Capability-Based Dynamic Language Design for Data Race-Freedom
Kiko Fernandez-Reyes, Isaac Oscar Gariano, James Noble, Erin Greenwood-Thessman, Michael Homer, and Tobias Wrigstad
(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.
@InProceedings{Onward!21p1,
author = {Kiko Fernandez-Reyes and Isaac Oscar Gariano and James Noble and Erin Greenwood-Thessman and Michael Homer and Tobias Wrigstad},
title = {Dala: A Simple Capability-Based Dynamic Language Design for Data Race-Freedom},
booktitle = {Proc.\ Onward!},
publisher = {ACM},
pages = {1--17},
doi = {10.1145/3486607.3486747},
year = {2021},
}
Publisher's Version
Onward! '21: "Dala: A Simple Capability-Based ..."
Dala: A Simple Capability-Based Dynamic Language Design for Data Race-Freedom
Kiko Fernandez-Reyes, Isaac Oscar Gariano, James Noble, Erin Greenwood-Thessman, Michael Homer, and Tobias Wrigstad
(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.
@InProceedings{Onward!21p1,
author = {Kiko Fernandez-Reyes and Isaac Oscar Gariano and James Noble and Erin Greenwood-Thessman and Michael Homer and Tobias Wrigstad},
title = {Dala: A Simple Capability-Based Dynamic Language Design for Data Race-Freedom},
booktitle = {Proc.\ Onward!},
publisher = {ACM},
pages = {1--17},
doi = {10.1145/3486607.3486747},
year = {2021},
}
Publisher's Version
Onward! '21: "Let a Thousand Flowers Bloom: ..."
Let a Thousand Flowers Bloom: On the Uses of Diversity in Software Testing
Alex Groce
(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.”
@InProceedings{Onward!21p136,
author = {Alex Groce},
title = {Let a Thousand Flowers Bloom: On the Uses of Diversity in Software Testing},
booktitle = {Proc.\ Onward!},
publisher = {ACM},
pages = {136--144},
doi = {10.1145/3486607.3486772},
year = {2021},
}
Publisher's Version
Onward! '21: "Motivating Complexity Understanding ..."
Motivating Complexity Understanding by Profiling Energy Usage
Joshua B. Gross, 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.
@InProceedings{Onward!21p85,
author = {Joshua B. Gross and Daniel Jacoby and Kevin Coogan and Aaron Helman},
title = {Motivating Complexity Understanding by Profiling Energy Usage},
booktitle = {Proc.\ Onward!},
publisher = {ACM},
pages = {85--96},
doi = {10.1145/3486607.3486752},
year = {2021},
}
Publisher's Version
Onward! '21: "Motivating Complexity Understanding ..."
Motivating Complexity Understanding by Profiling Energy Usage
Joshua B. Gross, 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.
@InProceedings{Onward!21p85,
author = {Joshua B. Gross and Daniel Jacoby and Kevin Coogan and Aaron Helman},
title = {Motivating Complexity Understanding by Profiling Energy Usage},
booktitle = {Proc.\ Onward!},
publisher = {ACM},
pages = {85--96},
doi = {10.1145/3486607.3486752},
year = {2021},
}
Publisher's Version
Onward! '21: "SkyQuery: An Aerial Drone ..."
SkyQuery: An Aerial Drone Video Sensing Platform
Favyen Bastani, Songtao He, Ziwen Jiang, Osbert Bastani, 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.
@InProceedings{Onward!21p56,
author = {Favyen Bastani and Songtao He and Ziwen Jiang and Osbert Bastani and Sam Madden},
title = {SkyQuery: An Aerial Drone Video Sensing Platform},
booktitle = {Proc.\ Onward!},
publisher = {ACM},
pages = {56--67},
doi = {10.1145/3486607.3486750},
year = {2021},
}
Publisher's Version
Info
Onward! '21: "Natural Language-Guided Programming ..."
Natural Language-Guided Programming
Geert Heyman, Rafael Huysegems, Pascal Justen, and Tom Van Cutsem
(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.
@InProceedings{Onward!21p39,
author = {Geert Heyman and Rafael Huysegems and Pascal Justen and Tom Van Cutsem},
title = {Natural Language-Guided Programming},
booktitle = {Proc.\ Onward!},
publisher = {ACM},
pages = {39--55},
doi = {10.1145/3486607.3486749},
year = {2021},
}
Publisher's Version
Info
Onward! '21: "Dala: A Simple Capability-Based ..."
Dala: A Simple Capability-Based Dynamic Language Design for Data Race-Freedom
Kiko Fernandez-Reyes, Isaac Oscar Gariano, James Noble, Erin Greenwood-Thessman, Michael Homer, and Tobias Wrigstad
(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.
@InProceedings{Onward!21p1,
author = {Kiko Fernandez-Reyes and Isaac Oscar Gariano and James Noble and Erin Greenwood-Thessman and Michael Homer and Tobias Wrigstad},
title = {Dala: A Simple Capability-Based Dynamic Language Design for Data Race-Freedom},
booktitle = {Proc.\ Onward!},
publisher = {ACM},
pages = {1--17},
doi = {10.1145/3486607.3486747},
year = {2021},
}
Publisher's Version
Onward! '21: "Natural Language-Guided Programming ..."
Natural Language-Guided Programming
Geert Heyman, Rafael Huysegems, Pascal Justen, and Tom Van Cutsem
(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.
@InProceedings{Onward!21p39,
author = {Geert Heyman and Rafael Huysegems and Pascal Justen and Tom Van Cutsem},
title = {Natural Language-Guided Programming},
booktitle = {Proc.\ Onward!},
publisher = {ACM},
pages = {39--55},
doi = {10.1145/3486607.3486749},
year = {2021},
}
Publisher's Version
Info
Onward! '21: "Motivating Complexity Understanding ..."
Motivating Complexity Understanding by Profiling Energy Usage
Joshua B. Gross, 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.
@InProceedings{Onward!21p85,
author = {Joshua B. Gross and Daniel Jacoby and Kevin Coogan and Aaron Helman},
title = {Motivating Complexity Understanding by Profiling Energy Usage},
booktitle = {Proc.\ Onward!},
publisher = {ACM},
pages = {85--96},
doi = {10.1145/3486607.3486752},
year = {2021},
}
Publisher's Version
Onward! '21: "SkyQuery: An Aerial Drone ..."
SkyQuery: An Aerial Drone Video Sensing Platform
Favyen Bastani, Songtao He, Ziwen Jiang, Osbert Bastani, 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.
@InProceedings{Onward!21p56,
author = {Favyen Bastani and Songtao He and Ziwen Jiang and Osbert Bastani and Sam Madden},
title = {SkyQuery: An Aerial Drone Video Sensing Platform},
booktitle = {Proc.\ Onward!},
publisher = {ACM},
pages = {56--67},
doi = {10.1145/3486607.3486750},
year = {2021},
}
Publisher's Version
Info
Onward! '21: "Towards Self-Adaptable Languages ..."
Towards Self-Adaptable Languages
Gwendal Jouneaux, Olivier Barais, Benoit Combemale, and Gunter Mussbacher
(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.
@InProceedings{Onward!21p97,
author = {Gwendal Jouneaux and Olivier Barais and Benoit Combemale and Gunter Mussbacher},
title = {Towards Self-Adaptable Languages},
booktitle = {Proc.\ Onward!},
publisher = {ACM},
pages = {97--113},
doi = {10.1145/3486607.3486753},
year = {2021},
}
Publisher's Version
Onward! '21: "Natural Language-Guided Programming ..."
Natural Language-Guided Programming
Geert Heyman, Rafael Huysegems, Pascal Justen, and Tom Van Cutsem
(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.
@InProceedings{Onward!21p39,
author = {Geert Heyman and Rafael Huysegems and Pascal Justen and Tom Van Cutsem},
title = {Natural Language-Guided Programming},
booktitle = {Proc.\ Onward!},
publisher = {ACM},
pages = {39--55},
doi = {10.1145/3486607.3486749},
year = {2021},
}
Publisher's Version
Info
Onward! '21: "SkyQuery: An Aerial Drone ..."
SkyQuery: An Aerial Drone Video Sensing Platform
Favyen Bastani, Songtao He, Ziwen Jiang, Osbert Bastani, 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.
@InProceedings{Onward!21p56,
author = {Favyen Bastani and Songtao He and Ziwen Jiang and Osbert Bastani and Sam Madden},
title = {SkyQuery: An Aerial Drone Video Sensing Platform},
booktitle = {Proc.\ Onward!},
publisher = {ACM},
pages = {56--67},
doi = {10.1145/3486607.3486750},
year = {2021},
}
Publisher's Version
Info
Onward! '21: "Towards Self-Adaptable Languages ..."
Towards Self-Adaptable Languages
Gwendal Jouneaux, Olivier Barais, Benoit Combemale, and Gunter Mussbacher
(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.
@InProceedings{Onward!21p97,
author = {Gwendal Jouneaux and Olivier Barais and Benoit Combemale and Gunter Mussbacher},
title = {Towards Self-Adaptable Languages},
booktitle = {Proc.\ Onward!},
publisher = {ACM},
pages = {97--113},
doi = {10.1145/3486607.3486753},
year = {2021},
}
Publisher's Version
Onward! '21: "Dala: A Simple Capability-Based ..."
Dala: A Simple Capability-Based Dynamic Language Design for Data Race-Freedom
Kiko Fernandez-Reyes, Isaac Oscar Gariano, James Noble, Erin Greenwood-Thessman, Michael Homer, and Tobias Wrigstad
(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.
@InProceedings{Onward!21p1,
author = {Kiko Fernandez-Reyes and Isaac Oscar Gariano and James Noble and Erin Greenwood-Thessman and Michael Homer and Tobias Wrigstad},
title = {Dala: A Simple Capability-Based Dynamic Language Design for Data Race-Freedom},
booktitle = {Proc.\ Onward!},
publisher = {ACM},
pages = {1--17},
doi = {10.1145/3486607.3486747},
year = {2021},
}
Publisher's Version
Onward! '21: "Programming as Architecture, ..."
Programming as Architecture, Design, and Urban Planning
Tomas Petricek
(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?
@InProceedings{Onward!21p114,
author = {Tomas Petricek},
title = {Programming as Architecture, Design, and Urban Planning},
booktitle = {Proc.\ Onward!},
publisher = {ACM},
pages = {114--124},
doi = {10.1145/3486607.3486770},
year = {2021},
}
Publisher's Version
Onward! '21: "Programming with Neural Surrogates ..."
Programming with Neural Surrogates of Programs
Alex Renda, Yi Ding, and Michael Carbin
(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.
@InProceedings{Onward!21p18,
author = {Alex Renda and Yi Ding and Michael Carbin},
title = {Programming with Neural Surrogates of Programs},
booktitle = {Proc.\ Onward!},
publisher = {ACM},
pages = {18--38},
doi = {10.1145/3486607.3486748},
year = {2021},
}
Publisher's Version
Onward! '21: "Angelic and Demonic Visitation: ..."
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.
@InProceedings{Onward!21p145,
author = {Leila Salem},
title = {Angelic and Demonic Visitation: School Memories},
booktitle = {Proc.\ Onward!},
publisher = {ACM},
pages = {145--148},
doi = {10.1145/3486607.3486773},
year = {2021},
}
Publisher's Version
Onward! '21: "The Kingdoms of Objects and ..."
The Kingdoms of Objects and Values
Friedrich Steimann
(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)
@InProceedings{Onward!21p125,
author = {Friedrich Steimann},
title = {The Kingdoms of Objects and Values},
booktitle = {Proc.\ Onward!},
publisher = {ACM},
pages = {125--135},
doi = {10.1145/3486607.3486771},
year = {2021},
}
Publisher's Version
Onward! '21: "Kotlin Coroutines: Design ..."
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.
@InProceedings{Onward!21p68,
author = {Roman Elizarov and Mikhail Belyaev and Marat Akhin and Ilmir Usmanov},
title = {Kotlin Coroutines: Design and Implementation},
booktitle = {Proc.\ Onward!},
publisher = {ACM},
pages = {68--84},
doi = {10.1145/3486607.3486751},
year = {2021},
}
Publisher's Version
Onward! '21: "Natural Language-Guided Programming ..."
Natural Language-Guided Programming
Geert Heyman, Rafael Huysegems, Pascal Justen, and Tom Van Cutsem
(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.
@InProceedings{Onward!21p39,
author = {Geert Heyman and Rafael Huysegems and Pascal Justen and Tom Van Cutsem},
title = {Natural Language-Guided Programming},
booktitle = {Proc.\ Onward!},
publisher = {ACM},
pages = {39--55},
doi = {10.1145/3486607.3486749},
year = {2021},
}
Publisher's Version
Info
Onward! '21: "Dala: A Simple Capability-Based ..."
Dala: A Simple Capability-Based Dynamic Language Design for Data Race-Freedom
Kiko Fernandez-Reyes, Isaac Oscar Gariano, James Noble, Erin Greenwood-Thessman, Michael Homer, and Tobias Wrigstad
(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.
@InProceedings{Onward!21p1,
author = {Kiko Fernandez-Reyes and Isaac Oscar Gariano and James Noble and Erin Greenwood-Thessman and Michael Homer and Tobias Wrigstad},
title = {Dala: A Simple Capability-Based Dynamic Language Design for Data Race-Freedom},
booktitle = {Proc.\ Onward!},
publisher = {ACM},
pages = {1--17},
doi = {10.1145/3486607.3486747},
year = {2021},
}
Publisher's Version