<Programming> 2022 Companion
6th International Conference on the Art, Science, and Engineering of Programming (<Programming> 2022 Companion)
Powered by
Conference Publishing Consulting

6th International Conference on the Art, Science, and Engineering of Programming (<Programming> 2022 Companion), March 21–25, 2022, Porto, Portugal

<Programming> 2022 Companion – Companion Proceedings

Contents - Abstracts - Authors

Frontmatter

Title Page


Message from the Chairs


Committees


Sponsors



MoreVMs

Interpreter Register Autolocalisation: Improving the Performance of Efficient Interpreters
Guillermo PolitoORCID logo, Nahuel Palumbo, Soufyane Labsari, Stéphane Ducasse, and Pablo Tesone
(University of Lille, France; Inria, France)
Language interpreters are generally slower than (JIT) compiled implementations because they trade off simplicity for performance and portability. They are nevertheless still important in modern Virtual Machines (VMs): e.g., not all code is hot and arrives to later compilation stages.
We propose to study more in depth the idea of interpreter registers: interpreter variables that are critical to the efficient execution of the interpreter loop. We present an automatic interpreter transformation for bytecode interpreters written in C called autolocalization. Autolocalisation makes interpreter registers local to the interpreter loop with the objective of keeping them in registers and makes those values available for other routines in the VM runtime automatically when required.
We build autolocalisation in Slang, Pharo’s VM generator framework, and evaluate the performance of several benchmarks on different configurations localising IP, SP, FP and their combinations. We show that the C compiler does not make this optimization automatically, and that this transformation yields improvements of up to 1.92x on x86-64. Moreover, we show that the performance of our automatic approach is comparable to the previously approach handwritten in the Pharo VM while making it easier to read, modify and debug.

Article Search
Toward Just-in-Time and Language-Agnostic Mutation Testing
Stefan Reschke ORCID logo, Toni Mattis ORCID logo, Fabio NiephausORCID logo, and Robert HirschfeldORCID logo
(University of Potsdam, Germany)
Mutation Testing is a popular approach to determine the quality of a suite of unit tests. It is based on the idea that introducing faults into a system under test (SUT) should cause tests to fail, otherwise, the test suite might be of insufficient quality. In the language of mutation testing, such a fault is referred to as “mutation”, and an instance of the SUT’s code that contains the mutation is referred to as “mutant”. Mutation testing is computationally expensive and time-consuming. Reasons for this include, for example, a high number of mutations to consider, interrelations between these mutations, and mutant-associated costs such as the cost of mutant creation or the cost of checking whether any tests fail in response. Furthermore, implementing a reliable tool for automatic mutation testing is a significant effort for any language. As a result, mutation testing is only available for some languages.
Present mutation tools often rely on modifying code or binary executables. We refer to this as “ahead-of-time” mutation testing. Oftentimes, they neither take dynamic information that is only available at run-time into account nor alter program behavior at run-time. However, mutating via the latter could save costs on mutant creation: If the corresponding module of code is compiled, only the mutated section of code needs to be recompiled. Run-time information (like previous execution results selected by an initial test run) could help to determine the utility of a mutant. Skipping mutants of low utility could have an impact on mutation testing efficiency. We refer to this approach as just-in-time mutation testing.
In this paper, we provide a proof of concept for just-in-time and language-agnostic mutation testing. We present preliminary results of a feasibility study that explores the implementation of just-in-time mutation testing based on Truffle’s instrumentation API. Based on these results, future research can evaluate the implications of just-in-time and language-agnostic mutation testing.

Article Search

PX/22

Programming in an fMRI Scanner: A Report from the Field
Steven Tanimoto, Rob Thompson, Todd Richards, Cheri Yates, and Virginia Berninger
(University of Washington, USA; Colorado School of Mines, USA; Seattle Childrens Hospital, USA)
A preliminary study is reported in which six human subjects were scanned while performing a simple form of computer programming. Functional magnetic resonance imaging typically precludes the use of ordinary computing equipment due to safety concerns when items with metallic parts are in the scanning room. We used a special visual programming environment, ``Kokopelli's World,'' for which an optics-only trackball was sufficient. This research methodology is described. Aspects of the experience of programming, by one of the authors, in the fMRI scanner are reported. An analysis of the data from the scanning is presented, and brain areas where activity for coding exceeded activity for a control task were identified and are presented here. These observations suggest hypotheses and directions for future research. One hypothesis is that particular aspects of programming are inherently and measurably pleasurable.

Article Search
Calling Cards: Concrete Visual End-User Programming
Michael Homer ORCID logo
(Victoria University of Wellington, New Zealand)
Creating a program that performs even a simple task and shows the result is unapproachable to most people, and even trained programmers face a burden to create a new program. In this paper, we introduce a prototype system and model for live visual dataflow programming where intermediate steps are visible and all components are tangible and manifest. Our system aims to allow a user to dive in and immediately have a working program that can be incrementally extended.

Article Search
A Live Environment to Improve the Refactoring Experience
Sara Fernandes ORCID logo, Ademar Aguiar ORCID logo, and André Restivo ORCID logo
(University of Porto, Portugal)
Refactoring helps improve the design of software systems, making them more understandable, readable, maintainable, cleaner, and self-explanatory. Many refactoring tools allow developers to select and execute the best refactorings for their code. However, most of them lack quick and continuous feedback, support, and guidance, leading to a poor refactoring experience. To fill this gap, we are researching ways to increase liveness in refactoring. Live Refactoring consists of continuously knowing, in real-time, what and why to refactor. To explore the concept of Live Refactoring and its main components --- recommendation, visualization, and application, we prototyped a Live Refactoring Environment focused on the Extract Method refactoring. With it, developers can receive recommendations about the best refactoring options and have support to apply them automatically. This work helped us reinforce the hypothesis that early and continuous refactoring feedback helps to shorten the time needed to create high-quality systems.

Article Search
Toward Understanding Task Complexity in Maintenance-Based Studies of Programming Tools
Patrick Rein ORCID logo, Tom Beckmann ORCID logo, Toni Mattis ORCID logo, and Robert HirschfeldORCID logo
(HPI, Germany)
Researchers conducting studies on programming tools often make use of maintenance tasks. The complexity of these tasks can influence the behavior of participants significantly. At the same time, the complexity of tasks is difficult to pinpoint due to the many sources of complexity for maintenance tasks. As a result, researchers may struggle to deliberately decide in which regard their tasks should be complex and in which regard they should be simple. To help researchers make more deliberate decisions about the complexity of their tasks, we discuss different factors of task complexity. We draw these factors from previous user studies on programming tools as well as from a task complexity model from ergonomics research that we apply to maintenance tasks. In the end, task complexity might always be too complex to be fully controlled. Nevertheless, we hope that our discussion helps other researchers to decide in which dimensions their tasks are complex and in which dimensions they want to keep them simple.

Article Search
An Experiment in Live Collaborative Programming on the Croquet Shared Experience Platform
Yoshiki OhshimaORCID logo, Aran Lunzer ORCID logo, Jenn Evans ORCID logo, Vanessa Freudenberg ORCID logo, Brian Upton ORCID logo, and David A. Smith ORCID logo
(Croquet Corporation, Japan; Croquet Corporation, UK; Croquet Corporation, Canada; Croquet Corporation, Germany; Croquet Corporation, USA)
This paper describes our experiences in building a live collaborative programming environment on top of the JavaScript version of the Croquet shared experience platform.
Croquet provides a clean substrate for building real-time collaborative applications. We created an application framework that supports live programming, and used that framework to build the Greenlight collaborative application, then in turn, modified it to do live programming experiments. The environment allows multiple users to modify the running application from within, with changes taking effect immediately.
The experiment was inspired by earlier work including Douglas Engelbart’s oN-Line System (NLS) and the Kansas system in Self. Analogically, the system is like the Smalltalk environment made collaborative.
In this paper we explain the Croquet architecture, its library and framework, and the Greenlight application used to make the live programming environment.
The standard version of Greenlight is available at https://croquet.io/greenlight, and the modified demo system is available at https://croquet.io/scripting.

Article Search
CodeMap: A Graphical Note-Taking Tool Cooperating with an Integrated Development Environment
Rikito Taniguchi and Hidehiko Masuhara
(Tokyo Institute of Technology, Japan)


Article Search
Example Mining: Assisting Example Creation to Enhance Code Comprehension
Eva Krebs ORCID logo, Patrick Rein ORCID logo, and Robert HirschfeldORCID logo
(HPI, Germany)
Programmers often use examples with concrete values to better understand code. Code by itself is abstract, which empowers it to be used for a variety of uses, but can be difficult to grasp by developers. Babylonian Programming addresses this by allowing programmers to concretize their code by defining and visualizing examples directly in the code itself while editing.
Currently, Babylonian Programming implementations such as Babylonian/S require programmers to define examples manually. For examples containing small objects this is straightforward, however when creating large or complex objects it is not. Sometimes, workarounds such as copying existing code pieces or trying to recreate existing objects are used to reuse information already present in the system, but these workarounds can be error-prone and also time-consuming.
In this paper, we propose Example Mining to address this issue by providing techniques and integrated tools to mine examples from existing sources similar to concepts from run-time tracing and test case extraction. Example mining introduces concepts to mine examples from tests, debugging sessions, and traces of actual usage of the system under development. All tools were implemented for Babylonian/S in Squeak/Smalltalk.
We demonstrate the usefulness of the tools through walkthroughs. Our tools provide examples for many methods immediately and automatically. As a consequence, programmers have more immediate access to dynamic feedback on their abstract code, making code comprehension and debugging more effective.

Article Search

Papers

Title
All Authors
(Affiliations)


Article Search
Creating New Programming Experiences Inspired by Boxer to Develop Computationally Literate Society
Mark Guzdial
(University of Michigan)


Article Search
Some Humbling Lessons from a Reconstructible Computational Medium
Flávio S. Azevedo
(University of Texas at Austin)


Article Search
Automatic Programming and Education
Clayton Lewis
(University of Colorado Boulder)


Article Search
On the Generality of Boxer Principles of Spatial Metaphor and Naive Realism
Jeremy Roschelle
(Digital Promise)


Article Search
Boxer: A Teacher’s Experience
Henri Picciotto
(MathEducation.page)


Article Search

proc time: 4.66