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

5th International Conference on the Art, Science, and Engineering of Programming (<Programming> 2021 Companion), March 22–26, 2021, Virtual, UK

<Programming> 2021 Companion – Companion Proceedings

Contents - Abstracts - Authors


Title Page

Welcome from the Chairs
Welcome to the Companion Proceedings for the 5th International Conference on the Art, Science, and Engineering of Programming, named ‹Programming› 2021.
The International Conference on the Art, Science, and Engineering of Programming is a conference focused on programming topics including the experience of programming. We have named it ‹Programming› for short. ‹Programming› seeks for papers that advance knowledge of programming on any relevant topic, including programming practice and experience.

5th International Workshop on Programming Technology for the Future Web (ProWeb 2021)
Full-fledged web applications have become ubiquitous on desktop and mobile devices alike. Whereas "responsive" web applications already offered a more desktop-like experience, there is an increasing demand for "rich" web applications (RIAs) that offer collaborative and even offline functionality---Google Docs being the prototypical example. Long gone are the days when web servers merely had to answer incoming HTTP requests with a block of static HTML. Today's servers react to a continuous stream of events coming from JavaScript applications that have been pushed to clients. As a result, application logic and data is increasingly distributed. Traditional dichotomies such as "client vs. server" and "offline vs. online" are fading.
The ProWeb workshop series is a forum for researchers and practitioners to share and discuss new technology for programming these and future evolutions of the web. It was our pleasure to host the 5th edition, ProWeb21, alongside ‹Programming› 2021. Due to the continued disruption due to the COVID-19 pandemic, the workshop was held online.

7th International Workshop on Programming Experience (PX/21)
Some programming feels fun, other programming feels annoying. Why? For a while now the study of programming has forced improvements to be described through the Fordist lens of usability and productivity, where the thing that matters is how much software can get built, how quickly. But along the way, something has gone missing. What makes programmers feel the way they do when they’re programming? It’s not usually fun to spend an age doing something that could have been done easily, so efficiency and usability still matter, but they’re not the end of the story. Some environments, activities, contexts, languages, infrastructures make programming feel alive, others feel like working in a bureaucracy. This is not purely technologically determined, writing Lisp to do your taxes probably still isn’t fun, but it’s also not technologically neutral, writing XML to produce performance art is still likely to be . Whilst we can probably mostly agree about what isn’t fun, what is remains more personal and without a space within the academy to describe it. In its past editions, PX set its focus on questions like: Do programmers create text that is transformed into running behavior (the old way), or do they operate on behavior directly (“liveness”); are they exploring the live domain to understand the true nature of the requirements; are they like authors creating new worlds; does visualization matter; is the experience immediate, immersive, vivid and continuous; do fluency, literacy, and learning matter; do they build tools, meta-tools; are they creating languages to express new concepts quickly and easily; and curiously, is joy relevant to the experience? In this PX, we expand its focus to also cover the experience that programmers have. What makes it and what breaks it? For whom? What can we build to share the joy of programming with others?

4th Raincode Labs Compiler Coding Dojo (CoCoDo 2021)
CoCoDo — the Raincode Labs Compiler Coding Dojo — was founded in 2017, not as a workshop or a mini-conference, but intentionally as a coding dojo. The intent is that participants enjoy an entire day of hands-on programming, instead of preparing a paper beforehand and giving a presentation about it on the day of the event. The topic of CoCoDo is compiler construction: arguably the oldest branch of computer science, which has been accumulating useful techniques since at least the 1950s. Compiler construction comprises, but is not limited to, lexical analysis, syntactic analysis, preprocessing, context handling, code generation, code optimisation, virtual machines, interpreters, smell detection, clone management, portability, migration, refactoring, domain-specific language design, linking and loading, assembling and disassembling, generics and reflection, and so much more.

ProWeb 2021

Rec.HTML: Declarative HTML
Bob Reynders and Kwanghoon Choi
(Chonnam National University, South Korea)
Interactive user experiences on the web are becoming the norm. Client-side programs are becoming more complicated and have to deal with event handling, reading HTML document state and updating the interface. In this paper we propose a declarative language that supports these three facets of client-side browser development declaratively and provides a programming model where complex interfaces can be written using simple programming techniques such as records, functions and recursion.

Publisher's Version
Oron: Towards a Dynamic Analysis Instrumentation Platform for AssemblyScript
Aäron Munsters, Angel Luis Scull Pupo, Jim Bauwens ORCID logo, and Elisa Gonzalez Boix ORCID logo
(Vrije Universiteit Brussel, Belgium)
The dynamic nature of JavaScript may lead to challenges and issues regarding efficiency and security. Analysis tools can help developers tackle some of these issues. In the context of web applications, dynamic analyses are best suited for handling those dynamic features but may affect the programs execution performance. In a first experiment, we attempted to improve the performance of the Aran dynamic analysis platform for JavaScript by utilizing WebAssembly. The extension caused extra performance hits due to context switches between JavaScript and WebAssembly. Because these context switches are inevitable, we decided to refit our work for the analysis of AssemblyScript, a variant of TypeScript which compiles to WebAssembly (and therefore excluding context switches). In this work, we explore this approach in the form of a new source code instrumentation platform named Oron, which allows for the instrumentation of AssemblyScript code. The presented platform is evaluated and shows promising improvements which provide a solid basis for efficient dynamic analysis of AssemblyScript applications.

Publisher's Version


Exploring Modal Locking in Window Manipulation: Why Programmers Should Stash, Duplicate, Split, and Link Composite Views
Marcel TaeumelORCID logo and Robert HirschfeldORCID logo
(HPI, Germany; University of Potsdam, Germany)
Window manipulation plays a vital role in multi-tool user interaction, especially for programmers exploring software artifacts, gathering information for better understanding. However, today's window managers offer only limited means to organize screen contents, which increases cognitive efforts for both tool builders and users. Builders must account for live integration of composite views; users might have to work around disruptive mode errors when actual tasks conflict with a tool's design. We follow a pattern-finding approach and present four new verbs for direct window manipulation, which we consolidated from existing tools and systems. If window managers would offer to stash, duplicate, split, and link views, we believe that programmers could better maintain flow during exploration activities.

Publisher's Version
Improving on the Experience of Hand-Assembling Programs for Application-Specific Architectures
Ian Piumarta
(Kyoto University of Advanced Science, Japan)
Creating an application-specific processor is an effective and popular way to solve many problems in embedded hardware design using FPGAs, ASICs, or custom silicon. Programming these processors is complicated by the lack of toolchain support for creating the necessary binary code as part of hardware design, implementation, and evaluation. Hardware developers who cannot create their own ad-hoc assembler are left to hand-assemble their code into binary instructions which is both painful and error prone. We present a tool that supports the rapid creation of assemblers for application-specific processors. A single language is used to specify both instruction formats as collections of bit fields and the instantiation of those formats into sequences of binary instructions as a single, homogeneous activity that is designed to be as familiar and accessible to hardware designers as possible. The output from the tool can be used directly by hardware synthesis tools to initialise the program memory of an application-specific processor.

Publisher's Version
Javardeye: Gaze Input for Cursor Control in a Structured Editor
André L. Santos ORCID logo
(ISCTE-IUL, Portugal)
Programmers spend a considerable time jumping through editing positions in the source code, often requiring the use of the mouse and/or arrow keys to position the cursor at the desired editing position. We developed Javardeye, a prototype code editor for Java integrated with eye tracking technology for controlling the editing cursor. Our implementation is based on a structured editor, leveraging on its particular characteristics, and augmenting it with a secondary--latent cursor--controlled by eye gaze. This paper describes the main design decisions and tradeoffs of our approach.

Publisher's Version Video
Studying Programmer Behaviour at Scale: A Case Study using Amazon Mechanical Turk
Jason T. Jacques and Per Ola Kristensson
(University of Cambridge, UK)
Developing and maintaining a correct and consistent model of how code will be executed is an ongoing challenge for software developers. However, validating the tools and techniques we develop to aid programmers can be a challenge plagued by small sample sizes, high costs, or poor generalisability. This paper serves as a case study using a web-based crowdsourcing approach to study programmer behaviour at scale. We demonstrate this method to create controlled coding experiments at modest cost, highlight the efficacy of this approach with objective validation, and comment on notable findings from our prototype experiment into one of the most ubiquitous, yet understudied, features of modern software development environments: syntax highlighting.

Publisher's Version
Towards End-User Web Scraping for Customization
Kapaya Katongo, Geoffrey LittORCID logo, and Daniel Jackson
(Massachusetts Institute of Technology, USA)
Websites are malleable: users can run code in the browser to customize them. However, this malleability is typically only accessible to programmers with knowledge of HTML and Javascript. Previously, we developed a tool called Wildcard which empowers end-users to customize websites through a spreadsheet-like table interface without doing traditional programming. However, there is a limit to end-user agency with Wildcard, because programmers need to first create site-specific adapters mapping website data to the table interface. This means that end-users can only customize a website if a programmer has written an adapter for it, and cannot extend or repair existing adapters. In this paper, we extend Wildcard with a new system for end-user web scraping for customization. It enables end-users to create, extend and repair adapters, by performing concrete demonstrations of how the website user interface maps to a data table. We describe three design principles that guided our system's development and are applicable to other end-user web scraping and customization systems: (a) users should be able to scrape data and use it in a single, unified environment, (b) users should be able to extend and repair the programs that scrape data via demonstration and (c) users should receive live feedback during their demonstrations. We have successfully used our system to create, extend and repair adapters by demonstration on a variety of websites and we provide example usage scenarios that showcase each of our design principles. Our ultimate goal is to empower end-users to customize websites in the course of their daily use in an intuitive and flexible way, and thus making the web more malleable for all of its users.

Publisher's Version Info
Toward Exploratory Understanding of Software using Test Suites
Dominik Meier ORCID logo, Toni Mattis ORCID logo, and Robert HirschfeldORCID logo
(HPI, Germany; University of Potsdam, Germany)
Changing software without correctly understanding it often leads to confusion, as developers do not understand how the change corresponds to the new observed behaviour of the system. Today, many software systems are equipped with a test suite. Test suites document code and give feedback on changed program behaviour. We explored ways to use test suites for software comprehension and implemented a tool that provides additional visualisation and gives immediate feedback on software changes. Information about changes in the software and their implications to the test suite are collected using mutation testing. The tool uses this information to present relevant test cases for developers, and additionally prioritise test executions for immediate feedback. Our research indicates that entropy metrics can find test cases that are relevant for a specific context in the source code. Additionally, simple test case prioritisation strategies can already lead to a significant decrease in feedback time. Based on our case study we argue that test suites are not only useful for regression testing but can be used to generate meaningful information for software comprehension activities.

Publisher's Version Video

CoCoDo 2021

From ASTs to Machine Code with LLVM
Dimitri Racordon ORCID logo
(University of Geneva, Switzerland)
A compiler is a program that translates source code written in a particular language into another language. Internally, the whole process is typically split into multiple stages that handle one particular aspect of this translation. One of these consists of translating the high-level representation of the program, typically an abstract syntax tree, into a simpler form that is suitable for analysis, optimizations, and code generation. This tutorial paper focuses on this process, and uses LLVM to compile programs into optimized machine code. LLVM is a language-agnostic compiler toolchain that handles program optimization and code generation. It is based on its own internal representation, called LLVM IR, which is then transformed into machine code.
We give a brief introduction to LLVM IR, and describe a few patterns to translate high-level language constructs expressed as abstract syntax trees. We implement these patterns in a compiler for a toy programming language, named Cocodol, which supports dynamic typing, unbounded loops, and higher-order functions.

Publisher's Version

proc time: 2.86