<Programming'20> Companion
4th International Conference on the Art, Science, and Engineering of Programming (<Programming> 2020 Companion)
Powered by
Conference Publishing Consulting
4th International Conference on the Art, Science, and Engineering of Programming (<Programming> 2020 Companion), March 23–26, 2020, Porto, Portugal

<Programming'20> Companion – Companion Proceedings

 Contents - Abstracts - Authors

Frontmatter

Title Page


Welcome from the Chairs
Welcome to the Companion Proceedings for the 4th International Conference on the Art, Science, and Engineering of Programming, named <Programming> 2020.
The International Conference on the Art, Science, and Engineering of Programming is a new 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.
1st International Workshop on ENgineering Intelligent Applications' Code (ENIAC 2020)
Articial Intelligence is becoming a mainstream concern in everyday softwareconstruction. More and more software companies intend to leverage AI techniquesin their products. However, there is a large gap between Programming/Software En-gineering and Articial Intelligence. “Adding intelligent behaviour” to an extensivemodern software system is therefore currently more a craft than an engineeringdomain.The International Workshop on ENgineering Intelligent Applications’ Code, orENIAC 2020, seeks to solve the problem by providing a forum for researchersand practitioners to share and discuss how software systems with an ArticialIntelligence core should be developed.ENIAC 2020received a total of 5 submissions that went through a rigorous review-ing process. Every submission received at least three reviews by the PC members,and was carefully discussed until a consensus was reached. All decisions were basedsolely on the quality of the submission and on the outcome of the discussion. Theprogram committee accepted the two technical papers included in these proceed-ings, and the one presentation abstract. We hope that the authors of submissionsthat did not make it to the program will benet from the reviewers’ feedback.We would like to thank all authors for the set of high-quality submissions, and theprogram committee for the careful review and discussion.
2nd International Workshop on Interconnecting Code (ICW 2020)
Welcome to the proceedings of the 2nd Interconnecting Code Workshop (ICW’20). ICW’20 was planned to be co-located with <Programming> 2020 in Porto, Portugal, in late March, but was cancelled due to the situation around the COVID-19. The submissions are published none-the-less, after review by the program committee.
Modern computer systems are often loosely coupled compositions of heterogeneous components. An important part of modern programming is the art, science, and engineering of interconnecting disparate code components to offer larger services in a reliable and scalable manner. The goal of our workshop was to facilitate an ongoing discussion, and advance the state of the art of interconnecting code in particular.
We had 4 submissions: 2 short papers, and 2 extended abstracts. We accepted the short papers and 1 extended abstract. All submissions were reviewed by the program committee. Overall, we have seen a continuation of the discussion around polyglot programming in GraalVM, but also how we might go about logic programming in connection with the Swift programming language. Lastly, we got some insights from the German Aerospace Center (DLR) on how they combine tools specific to various engineering disciplines into high-level workflows.
We would like to thank our contributors for agreeing to share their work and insights. We hope that you too will find the proceedings thought-provoking. We encourage you to get in touch with the authors, to exchange further ideas, and advance the state of the art, science, and engineering of interconnecting code.
4th International Workshop on Modern Language Runtimes, Ecosystems, and VMs (MoreVMs 2020)
Welcome to the proceedings of the fourth Workshop on Modern Language Runtimes, Ecosystems, and VMs (MoreVMs’20). MoreVMs aims to bring together industrial and academic programmers to discuss the design, implementation, and usage of modern languages and runtimes. This includes aspects such as reuse of language runtimes, modular implementation, language design, and compilation strategies.
1st International Workshop on New Interfaces for Programming (NIP 2020)
Interfaces for programming have remained mostly unchanged since long time. Usually, software engineers (SE) interact with IDEs through keyboards and mice,and text-based interfaces displayed on computer screens. The field of software visualization (SOFTVIS) investigates the use of visual properties to support software engineering tasks such as programming. More recently, researchers in the field have analyzed the impact of displaying visualizations in virtual and augmented reality (VR/AR). The use of immersive environments have shown not only positive effects on developers’ user experience but also on user performance. The International Workshop on New Interfaces for Programming (NIP) aims at gathering experts from (1) the SE community, (2) the SOFTVIS community,(3) the VR/AR community, and (4) the Arts community in order to breed cross-community new interfaces to support programming tasks. The workshop aims at providing a forum for researchers and practitioners from these mostly disconnected research communities.
4th International Workshop on Programming Technology for the Future Web (ProWeb 2020)
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 off-line functionality—Google Docs being the prototypical example. Long gone are the days that web servers merely had to answer incoming HTTP request 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 4th International Workshop on Programming Technology for the Future Web, or ProWeb20, is a forum for researchers and practitioners to share and discus new technology for programming these and future evolutions of the web.
6th International Workshop on Programming Experience (PX/20)
The Programming Experience (PX) Workshop is about what happens when programmers sit down in front of computers and produce code, especially in an exploratory way. Do they 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? Correctness, performance, standard tools, foundations, and text-as-program are important traditional research areas, but the experience of programming and how to improve and evolve it are the focus of this workshop. In this edition we focused on live, exploratory programming, but also welcomed a wide spectrum of contributions on programming experience.
Convivial Computing Salon (Salon 2020)
In Tools for Conviviality, Ivan Illich criticized the damage to society from technology escalation. The Convivial Computing Salon invited investigations from this perspective on computing technology. As the Call for Papers says: we were promised bicycles for the mind, but we got aircraft carriers instead.
2020 Posters
Welcome to the posters session at <Programming> 2020. Posters are an integral part of the conference and aim at showcasing very recent or ongoing work, clarifying problem statements, vetting solutions, or identifying evaluation methods in an interactive way. They are an excellent opportunity for authors to receive feedback from the <Programming> community and encourage one-to-one and small group discussions on a technical topic.

 Info
2020 Student Research Competition
Preface to the 2020 Student Research Competition

1st International Workshop on ENgineering Intelligent Applications' Code (ENIAC 2020)

Three Trillion Lines: Infrastructure for Mining GitHub in the Classroom
Toni Mattis, Patrick Rein, and Robert Hirschfeld
(HPI, Germany)
The increasing interest in collaborative software development on platforms like GitHub has led to the availability of large amounts of data about development activities. The GHTorrent project has recorded a significant proportion of GitHub’s public event stream and hosts the currently largest public dataset of meta-data about open-source development. We describe our infrastructure that makes this data locally available to researchers and students, examples for research activities carried out on this infrastructure, and what we learned from building the system. We identify a need for domain-specific tools, especially databases, that can deal with large-scale code repositories and associated meta-data and outline open challenges to use them more effectively for research and machine learning settings.

 Publisher's Version
Achieving Guidance in Applied Machine Learning through Software Engineering Techniques
Lars Reimann and Günter Kniesel-Wünsche
(University of Bonn, Germany)
Development of machine learning (ML) applications is hard. Producing successful applications requires, among others, being deeply familiar with a variety of complex and quickly evolving application programming interfaces (APIs). It is therefore critical to understand what prevents developers from learning these APIs, using them properly at development time, and understanding what went wrong when it comes to debugging. We look at the (lack of) guidance that currently used development environments and ML APIs provide to developers of ML applications, contrast these with software engineering best practices, and identify gaps in the current state of the art. We show that current ML tools fall short of fulfilling some basic software engineering gold standards and point out ways in which software engineering concepts, tools and techniques need to be extended and adapted to match the special needs of ML application development. Our findings point out ample opportunities for research on ML-specific software engineering.

 Publisher's Version

2nd International Workshop on Interconnecting Code (ICW 2020)

LogicKit: Bringing Logic Programming to Swift
Dimitri Racordon and Didier Buchs
(University of Geneva, Switzerland)
A new trend in programming languages is to merge multiple paradigms, rather than focusing on one as it was customary in the past. Most modern languages provide native support for imperative and functional programming, object-orientation and even concurrency. The typical mechanism used to blend heterogeneous language concepts is to rely on functions. Functions are a very well understood, usually offer an excellent abstraction over diverging models of computation, but are unsuitable to interface logic programming, unfortunately. Embedding a full logic programming language into a host is also unsatisfactory, as it impedes the ability to make data flow from one paradigm to the other.
As an answer to these issues, we propose LogicKit, a library that aims to bridge the gap between logic programming and other traditional paradigms. LogicKit is a Prolog-inspired language that blends seamlessly into Swift. Predicates are first-class objects in the host language and data can flow in and out of a logic program, without the need for any data serialization/parsing. Our framework is distributed in the form of a Swift library that can be imported in any Swift project effortlessly. We elaborate on our motivation for developing LogicKit and present the library by the means of examples.

 Publisher's Version
Supporting the Composition of Domain-Specific Software via Task-Specific Roles
Brigitte Boden, Robert Mischke, Alexander Weinert, and Andreas Schreiber
(DLR, Germany)
Nowadays, complex technical systems are frequently developed by composing discipline-specific tools into an automated high-level workflow. Constructing, executing, and maintaining this workflow together with the infrastructure supporting it involves several distinct roles. We argue that awareness of these roles and providing explicit software support for them accelerates these processes and enables fast iteration on the design of the workflow itself.

 Publisher's Version Info
User-Defined Interface Mappings for the GraalVM
Alexander Riese, Fabio Niephaus, Tim Felgentreff, and Robert Hirschfeld
(HPI, Germany; Oracle Labs, Germany)
To improve programming productivity, the right tools are crucial. This starts with the choice of the programming language, which often predetermines the libraries and frameworks one can use. Polyglot runtime environments, such as GraalVM, provide mechanisms for exchanging objects and sending messages across language boundaries, which allow developers to combine different languages, libraries, and frameworks with each other. However, polyglot application developers are obligated to properly use the right interfaces for accessing their data and objects from different languages.
To reduce the mental complexity for developers and let them focus on the business logic, we introduce user-defined interface mappings - an approach for adapting cross-language messages at run-time to match an expected interface. Thereby, the translation strategies are defined in an exchangeable and easy-to-edit configuration file. Thus, different stakeholders ranging from library and framework developers up to application developers can use and extend these mappings for their needs.

 Publisher's Version

4th International Workshop on Modern Language Runtimes, Ecosystems, and VMs (MoreVMs 2020)

Enhancement of OpenJDK Biased Locking for Infrequent Lock Contention
Ting Wang, Michihiro Horie, Kazunori Ogata, Hao Chen Gui, Xiao Ping Guo, and Yang Liu
(IBM, China; IBM, Japan)
Java has a built-in synchronization mechanism and there are many research works to optimize the mechanism by reducing use of costly operations, such as OS monitors and atomic operations. OpenJDK implements biased locking to eliminate all synchronization-related atomic operations for uncontended locks. However, atomic operations are still observed in Hadoop map tasks even though a map task is single-threaded. This paper presents a scenario where a map task causes infrequent lock contentions and an enhancement to help biased locking work better in such situation. Our enhancement includes a new mechanism to profile lock usages, new transitions to enforce those high profiled locks to continue benefit from biased locking, and a mechanism to bypass lock state transition during deoptimization. It accelerated TPC-DS queries execution by 5% on average. We also verified it reduced lock-related atomic operations by up to 50% for map task.

 Publisher's Version
Profiling Streams on the Java Virtual Machine
Edgar Eduardo Rosales Rosero, Andrea Rosà, and Walter Binder
(USI Lugano, Switzerland)
The java.util.stream framework is becoming a popular option among developers that target the Java Virtual Machine (JVM) to implement map-reduce-like transformations on collections. A key feature of the streams framework is enabling parallelizing a computation as easy as calling a single method. Still, developers should test whether parallelizing a stream may results in performance, liveness or safety hazards. While such issues are mainly observable at runtime, there is a lack of tools capturing information that enable understanding the dynamic behavior of a stream application. In this extended abstract, we devise a profiler focused on characterizing dynamic attributes of a stream application running on a single JVM in a shared-memory multicore. Our tool aims at collecting runtime information and key metrics to support analysis of sequential and parallel stream processing, towards helping developers make better decisions to efficiently and safely use the streams framework.

 Publisher's Version
Running Parallel Bytecode Interpreters on Heterogeneous Hardware
Juan Fumero, Athanasios Stratikopoulos, and Christos Kotselidis
(University of Manchester, UK)
Since the early conception of managed runtime systems with tiered JIT compilation, several research attempts have been made to accelerate the bytecode execution. In this paper, we extend prior attempts by performing an initial analysis of whether heterogeneous hardware accelerators in the form of Graphics Processing Units (GPUs) and Field Programmable Gate Arrays (FPGAS) can help towards achieving higher performance during the bytecode interpreter mode. To answer this question, we implemented a simple parallel Java bytecode interpreter written in OpenCL and executed it across a plethora of devices, including GPUs and FPGAs. Our preliminary evaluation shows that under specific workloads, hardware acceleration can yield up to 17x better performance compared to traditional optimized interpreters running on Intel CPUs and up to 214x compared to ARM CPUs.

 Publisher's Version Video
Superoptimization of WebAssembly Bytecode
Javier Cabrera Arteaga, Shrinish Donde, Jian Gu, Orestis Floros, Lucas Satabin, Benoit Baudry, and Martin Monperrus
(KTH, Sweden; Mobimeo, Germany)
Motivated by the fast adoption of WebAssembly, we propose the first functional pipeline to support the superoptimization of WebAssembly bytecode. Our pipeline works over LLVM and Souper. We evaluate our superoptimization pipeline with 12 programs from the Rosetta code project. Our pipeline improves the code section size of 8 out of 12 programs. We discuss the challenges faced in superoptimization of WebAssembly with two case studies.

 Publisher's Version
Toward Presizing and Pretransitioning Strategies for GraalPython
Johannes Henning, Tim Felgentreff, Fabio Niephaus, and Robert Hirschfeld
(HPI, Germany; Oracle Labs, Germany)
Presizing and pretransitioning are run-time optimizations that reduce reallocations of lists. These two optimizations have previously been implemented (together with pretenuring) using Mementos in the V8 Javascript engine. The design of Mementos, however, relies on the support of the garbage collector (GC) of the V8 runtime system.
In contrast to V8, dynamic language runtimes written for the GraalVM do not have access to the GC. Thus, the prior work cannot be applied directly. Instead, an alternative implementation approach without reliance on the GC is needed and poses different challenges.
In this paper we explore and analyze an approach for implementing these two optimizations in the context of GraalVM, using the Python implementation for GraalVM as an example. We substantiate these thoughts with rough performance numbers taken from our prototype on which we tested different presizing strategies.

 Publisher's Version
Towards Dynamic SQL Compilation in Apache Spark
Filippo Schiavio, Daniele Bonetta, and Walter Binder
(USI Lugano, Switzerland; Oracle Labs, USA)
Big-data systems have gained significant momentum, and Apache Spark is becoming a de-facto standard for modern data analytics. Spark relies on code generation to optimize the execution performance of SQL queries on a variety of data sources. Despite its already efficient runtime, Spark's code generation suffers from significant runtime overheads related to data de-serialization during query execution. Such performance penalty can be significant, especially when applications operate on human-readable data formats such as CSV or JSON.

 Publisher's Version

1st International Workshop on New Interfaces for Programming (NIP 2020)

Assessing Textual Source Code Comparison: Split or Unified?
Alejandra Cossio Chavalier, Juan Pablo Sandoval Alcocer, and Alexandre Bergel
(Universidad Católica Boliviana, Bolivia; University of Chile, Chile)
Evaluating source code differences is an important task in software engineering. Unified and split are two popular textual representations supported by clients for source code management. Whether these representations differ in supporting source code commit assessment is still unknown, despite its ubiquity in software production environments.
This paper performs a controlled experiment to test the causality between the textual representation of source code differences and the performance in term of commit evaluation. Our experiment shows that no significant difference was measured. We therefore conclude that both unified and split equally support the source code commit assessment for the tasks we considered.

 Publisher's Version
Towards Requirements Engineering with Immersive Augmented Reality
Nitish Patkar, Leonel Merino, and Oscar Nierstrasz
(University of Bern, Switzerland; University of Stuttgart, Germany)
Often, requirements engineering (RE) activities demand project stakeholders to communicate and collaborate with each other towards building a common software product vision. We conjecture that augmented reality (AR) can be a good fit to support such communication and collaboration. In this vision paper, we report on state-of-the-art research at the intersection of AR and RE. We found that requirements elicitation and analysis have been supported by the ability of AR to provision on-the-fly information such as augmented prototypes. We discuss and map the existing challenges in RE to the aspects of AR that can boost the productivity and user experience of existing RE techniques. Finally, we elaborate on various envisioned usage scenarios in which we highlight concrete benefits and challenges of adopting immersive AR to assist project stakeholders in RE activities.

 Publisher's Version
Towards Visualization of Evolution of Component-Based Software Architectures in VR
Elke Franziska Heidmann, Annika Meinecke, Lynn von Kurnatowski, and Andreas Schreiber
(DLR, Germany)
To understand the development history of complex software architectures, software visualizations are very useful. They show dependencies and contexts in which design decisions were made, supporting programmers in understanding systems and helping them to recognize disadvantageous design decisions. IslandViz visualizes OSGi-based software architectures in Virtual Reality using an island metaphor; for now, the history of an architecture is not taken into account. We show how IslandViz can be extended to include changes on package and compilation unit level by changing the layout of islands. For this purpose we adapt the Enhanced Hexagon Tiling Algorithm and create growth corridors for each region of an island. As a result, island regions can change along with their respective packages without the possibility of being enclosed by other regions.

 Publisher's Version
Towards Efficient Interdisciplinary Authoring of Industrial Augmented Reality Applications
Ingo Börsting and Volker Gruhn
(University of Duisburg-Essen, Germany)
The application of Augmented Reality (AR) supports process optimization in various areas. The beneficial characteristics are particularly evident in the industrial context, where AR can lead to an efficiency increase in the entire product life cycle. However, developing AR applications results in a challenging process, characterized by a role shift based on complex interaction modeling. We present an approach for efficient interdisciplinary authoring of industrial AR applications. Interaction Stories are introduced to enable UI designers and domain experts to create interaction concepts and participate in the development process. A concept for interdisciplinary collaboration enables the constant exchange between actors of different competence levels. The simplification of interaction modeling and the interdisciplinary collaboration are designed to assemble actors to enable an efficient iterative AR development process.

 Publisher's Version
Program Comprehension for Live Algorithmic Design in Virtual Reality
Renata Castelo-Branco, António Leitão, and Catarina Brás
(INESC-ID, Portugal; Instituto Superior Técnico, Portugal; University of Lisbon, Portugal)
Algorithmic Design (AD) is a design approach based on the development of computer programs to describe architectural models. The programs’ outputs are digital architectural 3D models, which are visual by nature and, therefore, benefit from immersive visualization. Live Coding in Virtual Reality (LCVR) is a methodology for the interactive development of AD programs while immersed in Virtual Reality (VR), favoring a more intuitive development process for architectural designs. However, complex buildings tend to require complex AD programs and, despite the added visual aid, as programs grow in complexity, it becomes harder to understand which parts of the program were responsible for which parts of the model. Moreover, LCVR introduces a new level of complexity: interaction with both model and program in VR. This research proposes to ease the programming task for architects who wish to code their models in VR, by supporting program comprehension in the LCVR workflow with traceability and refactoring mechanisms. These features will help users interact with their designs from within the virtual environment.

 Publisher's Version

4th International Workshop on Programming Technology for the Future Web (ProWeb 2020)

Evolution of the WebDSL Runtime: Reliability Engineering of the WebDSL Web Programming Language
Danny M. Groenewegen, Elmer van Chastelet, and Eelco Visser
(Delft University of Technology, Netherlands)
Web applications are ideal for implementing information systems; they can organize and persist the data in a database, do not require installation on client machines, and can be instantly updated everywhere. However, web programming is complex due to its heterogeneous nature, causing web frameworks to suffer from insufficient or leaky abstraction, weak static consistency checking, and security features that are not enforced. We developed the WebDSL web programming language, which supports direct expression of intent, strong static consistency checking, linguistic abstractions for web programming concerns, and automatically enforces security features for web applications. We have used WebDSL for over 10 years to create information systems for academic workflows with thousands of users. Based on our experiences with these applications, we improved the WebDSL compiler and runtime to increase robustness, performance, and security of applications. In this experience report, we reflect on the lessons learned and improvements made to the language runtime.

 Publisher's Version
Synthesizing User Interfaces using Functional Reactive Web Abstractions
Adam Granicz, Jozsef Uri, and Andras Janko
(IntelliFactory, Hungary)
In this paper, we describe a novel approach to synthesizing web user interfaces (UI) from declarative specifications given in a domain-specific language (DSL) that can later be read and written by natural language processing (NLP) techniques via human language interaction. We make use of F#'s metaprogramming capabilities and our reactive forms library developed for WebSharper. Our ultimate goal is to enable end users to describe entire web application UIs and carry on a conversation with our system, describing incremental changes to apply on an ongoing specification.

 Publisher's Version

6th International Workshop on Programming Experience (PX/20)

Multiagent Live Programming Systems: Models and Prospects for Critical Applications
Steven L. Tanimoto
(University of Washington, USA)
Live programming constitutes a human-computer symbiosis in which a human creative activity and a continuous computer execution influence each other. Usually, there is a medium of expression called "code" that the human(s) use to express desired behavior on the part of the computer, and the computer provides its feedback in the form of textual, graphical, audio, or other output. The most popular domain for live programming has been music synthesis ("live coding"), but the key features of live programming suggest it can play an important role in other applications, even process control or emergency management.
This paper breaks down live programming systems in terms of agents, both human and computational, their roles, and representations they typically create and act upon. It then comments on how multi-agent live programming systems could add new flexibility to information systems such as those that manage critical infrastructure or emergency response activity, such as during a COVID-19 type of pandemic or after a major earthquake.

 Publisher's Version
MATLAB Doesn't Love Me: An Essay
Tijs van der Storm and Geor Bakker
(CWI, Netherlands; University of Groningen, Netherlands; Amsterdam University Medical Centres, Netherlands; Sosei Heptares, UK)
Programming is everywhere, and is becoming an increasingly essential component of knowledge work outside the realms of traditional software development. Examples include data journalism, scientific computing, machine control, machine learning, financial management, and others. A key aspect of this trend is that users have to use programming tools, but typically lack programming education, let alone a computer science background. In this short paper we revisit potential assumptions and preconceptions underlying traditional programming system design, from the perspective of practicing scientists using tools like MATLAB, R, Bash, Python, C++, and others. Specifically, we aim to peel off some ingrained assumptions that have informed programming language and system design for decades. Without giving a lot of answers, we hope some of our contrarian observations may turn out to be controversial, and stimulate a meaningful discussion towards a better programmer experience in the domain of science.

 Publisher's Version
Towards a Pattern Language for Interactive Coding Tutorials
Tao Dong and Gale Yang
(Google, USA)
Online, text-based coding tutorials are popular among programming learners. Though they are relatively easy to create, it's challenging to ensure their pedagogical effectiveness. Computer Science Education researchers have advocated for interactive tutorials, because they provide learners with opportunities to practice and receive feedback while completing a tutorial. Nonetheless, little guidance exists on how to best leverage interactivity in tutorials. We set out to develop a pattern language for interactive tutorials to fill this gap. Through a human-centered design process, we created and evolved three instructional patterns and their supporting interaction components in a tutorial on asynchronous programming. We describe the preliminary results of our work towards this pattern language in this paper.

 Publisher's Version
Polyglot Code Finder
Jan Ehmueller, Alexander Riese, Hendrik Tjabben, Fabio Niephaus, and Robert Hirschfeld
(HPI, Germany)
With the increasing complexity of software, it becomes even more important to build on the work of others. At the same time, websites, such as Stack Overflow or GitHub, are used by millions of developers to host their code, which could potentially be reused.
The process of finding the right code, however, is often time-consuming. In addition, the right solution may be written in a programming language that does not fit the developer's requirements. Current approaches to automate code search allow users to search for code based on keywords and transformation rules, but they are limited to one programming language.
Our approach enables developers to find code for reuse written in different languages, which is especially useful when building polyglot applications. In addition to conventional search filters, users can filter code by providing example input and expected output. Based on our approach, we have implemented a tool prototype in GraalSqueak. We evaluate both approach and prototype with an experience report.

 Publisher's Version
Visual Design for a Tree-Oriented Projectional Editor
Tom Beckmann, Stefan Ramson, Patrick Rein, and Robert Hirschfeld
(HPI, Germany)
Projectional editors show promise for a variety of use cases, for example in language composition and domain specific projections. To allow efficient interactions within a projectional editor, it is necessary for the editor to clearly communicate the structure of the program to the user, such that it is clear what editing operations are supported for a given element. Making the abstract syntax tree visible within the editor may provide this clarity, however, it generally also results in considerably increased space usage, potentially also impacting usability. We present an early prototype of a tree-oriented projectional editor for Squeak/Smalltalk that tries to minimize space usage while retaining a clear visualization of the tree structure, balancing the two problems. We describe and discuss our design prototype and do a preliminary evaluation through individual account of experience working with the editor on various projects.

 Publisher's Version
Javardise: A Structured Code Editor for Programming Pedagogy in Java
André L. Santos
(University Institute of Lisbon, Portugal)
The syntax of a programming language is the textual form - that conforms to a grammar - to express instructions of a programming model. The key idea of structured code editors is to constrain editing to syntactically valid program code, that is, the modifications ensure that the source code always conforms to the grammar. Syntax is considered an entry barrier when learning how to program. In this work we rehash the concept of structured code editors targeting programming education. We present Javardise, a structured editor for a subset of the Java language, and discuss its features in the light of programming pedagogy.

 Publisher's Version

Convivial Computing Salon (Salon 2020)

Wildcard: Spreadsheet-Driven Customization of Web Applications
Geoffrey Litt and Daniel Jackson
(Massachusetts Institute of Technology, USA)
Many Web applications do not meet the precise needs of their users. Browser extensions offer a way to customize web applications, but most people do not have the programming skills to implement their own extensions.
In this paper, we present spreadsheet-driven customization, a technique that enables end users to customize software without doing any traditional programming. The idea is to augment an application’s UI with a spreadsheet that is synchronized with the application’s data. When the user manipulates the spreadsheet, the underlying data is modified and the changes are propagated to the UI, and vice versa.
We have implemented this technique in a prototype browser extension called Wildcard. Through concrete examples, we demonstrate that Wildcard can support useful customizations—ranging from sorting lists of search results to showing related data from web APIs—on top of existing websites. We also present the design principles underlying our prototype.
Customization can lead to dramatically better experiences with software. We think that spreadsheet-driven customization offers a promising new approach to unlocking this benefit for all users, not just programmers.

 Publisher's Version Info
Towards a Dynamic Multiscale Personal Information Space: Beyond Application and Document Centered Views of Information
Amy Rae Fox, Philip Guo, Clemens Nylandsted Klokmose, Peter Dalsgaard, Arvind Satyanarayan, Haijun Xia, and James D. Hollan
(University of California at San Diego, USA; Aarhus University, Denmark; Massachusetts Institute of Technology, USA)
The historical moment when a person worked in front of a single computer has passed. Computers are now ubiquitous and embedded in virtually every new device and system, connecting our personal and professional activities to ever-expanding information resources with previously unimaginable computational power. Yet with all the increases in capacity, speed, and connectivity, our experiences too often remain difficult, awkward, and frustrating. Even after six decades of design evolution there is little of the naturalness and contextual sensitivity required for convivial interaction with computer-mediated information.
We envision a future in which the existing world of documents and applications is linked to a multiscale personalized information space in which dynamic visual entities behave in accordance with cognitively motivated rules sensitive to tasks, personal and group interaction histories, and context. The heart of the project is to rethink the nature of computer-mediated information as a basis to begin to fully realize the potential of computers to assist information-based activities. This requires challenging fundamental presuppositions that have led to today’s walled gardens and information silos. Our goal is to catalyze an international research community to rethink the nature of information as a basis for radically advancing the human-centered design of information-based work and helping to ensure the future is one of convivial, effective, and humane systems. In this paper, we propose a new view of information systems, discuss cognitive requirements for a human-centered information space, and sketch a research agenda and approach.

 Publisher's Version Video Info
Convivial Design Heuristics for Software Systems
Stephen Kell
(University of Kent, UK)
Illich's notion of conviviality centres on the balance between individual freedom to act and collective freedom from domination. This balance, or tension, is present in the design of most user-facing computer systems, and especially in the design of programming systems. Software lore has arisen with at best a skewed perspective on such issues, having developed from an industrial viewpoint.
In this paper I survey some tentative design principles, extracted from examples of research work or (more often) systems used in practice, which (sometimes by accident) do show some regard for conviviality. Although preliminary, my hope is that these principles may yet develop into a collection of design hints at least equal, and largely countervailing, to the less conviviality-prone ideas circulating in today's software folklore. Relevant topics include language design, information hiding, language virtual machines, portability, classical logic, and layered system design. I also briefly consider the intertwined social and political constructs, such as copyleft, ownership and community responsibility, asking how to evolve or generalise these towards convivial ends.

 Publisher's Version
Rethinking Programming “Environment”: Technical and Social Environment Design toward Convivial Computing
Jun Kato and Keisuke Shimakage
(AIST, Japan; OTON GLASS, Japan)
Computers have become ubiquitous in our life and work, and the way that they are built and used needs to be fundamentally improved. Most of the prior effort has been aimed at improving the programming experience for people with specific technical backgrounds (e.g., programmers, end-users, data scientists). In contrast, throughout this paper, we discuss how to make programming activities more inclusive and collaborative, involving people with diverse technical backgrounds. We rethink the programming environment from both technical and social perspectives.
First, we briefly introduce our previous technical effort in which the programming environment is shared between the developers and users of programs, eliminating the distinction between programming and runtime environments and fostering communication between them. Second, we introduce our social effort to support people who are visually impaired in implementing customized smart glasses that read words with a camera and speakers. We design their programming environment to consist of a softwarehardware toolkit and engineers with domain expertise called “evangelists.”
Learning from these experiences, we discuss several perspectives on convivial computing. To conclude, we argue that both technical innovations made on user interfaces for programming and understanding on the socio-technical aspect of domain-specific applications are critical for the future of programming environments, and accordingly, convivial computing.

 Publisher's Version Video Info
Spreadsheets as Notational Environment for Paper Weaving
Jonathan Skjøtt
(Takram, UK)
This work explores how spreadsheets can serve as the foundation for the creation of a hybrid design medium for paper weaving. The case for using spreadsheets as a model for the development of environments for designing paper weaving patterns is made. Firstly, because both spreadsheets as well as the woven form of paper weaving designs have cells as their elementary substrate. Secondly, because it allows for exploration of the design space. And thirdly, as it enables use by end-users with varying levels of experience. An environment, VisiWeave, implementing the points mentioned is presented and explored.

 Publisher's Version
Can Programmers Escape the Gentle Tyranny of call/return?
Marcel Weiher
(HPI, Germany)
Although the call/return architectural style has served as the foundation of much of computing since its existence, it no longer matches a large proportion, probably the majority, of the programs or systems created today.
However, our programming languages, be they imperative, functional or object-oriented, support call/return variants as their primary or only abstraction mechanism. This mismatch between system structure and our means of expressing those systems can be overcome, but only with massive ("aircraft carrier") engineering effort that is beyond most casual developers.
In order to overcome this fundamental architectural mismatch and make software constructions easier for professionals and accessible for novices, we need to support other architectural styles on an equal footing with call/return in our programming languages.
This paper presents one approach to multi-architectural programming as well as progress with this approach.

 Publisher's Version Info
Bicycles for the Mind Have to Be See-Through
Kartik Agaram
This paper describes ongoing research on building software to be comprehensible to its users so that they can tailor it to their needs in the field. Our test-bed is a computing stack called Mu that deemphasizes a clean interface in favor of a few global implementation properties: small implementation size, few distinct notations, parsimonious dependencies, a simple dependency graph that avoids cycles, and early warning on breaking changes. Assuming a 32-bit x86 processor and (for now) a basic third-party Unix-like kernel, Mu builds up from raw machine code to a memory-safe but less expressive language than C.
Our approach to keeping software comprehensible is to reduce information hiding and abstraction, and instead encourage curiosity about internals. Our hypothesis is that abstractions help insiders who understand a project but hinder newcomers who understand only that project's domain. Where recent efforts to create "bicycles for the mind" have tended to focus on reducing learning time and effort, we explore organizing the curriculum to be incrementally useful, providing an hour of actionable value for an hour (or three) of study. The hope is that rewarding curiosity will stimulate curiosity in a virtuous cycle, so that more people are motivated to study and reflect on the difference between good vs bad design and good vs bad architecture, even as the study takes place over a lifetime of specialization in other domains. Spreading expertise in design is essential to the creation of a better society of more empowered citizens. Software tools have a role to play in this process, both by exemplifying good design and by providing visceral illustrations of the consequences of design choices.

 Publisher's Version Info
Escaping the Prison of Style
Antranig Basman and Philip Tchernavskij
(Raising the Floor, UK; OCAD University, Canada)
We seek support for our notion of authorially open programming practices through a critical reading of the notion of "style" in our dominant programming cultures. We argue that this popular notion of programming style is inescapably infused with values which diverge from those of its supposed analogues in areas such as literary and artistic expression. By examining the discourse around and technical distinctions between programming styles, we reveal their fundamentally different nature in structuring dialogues between the writers of computational artefacts and those who experience them. Programming styles are predominantly discussed in inward-facing terms, i.e. with regard only to the experience of programmers with privileged access to the source code. Regardless of their chosen style, programs consist of "imprisoned expressions", built of design elements cut off from access to the program which executes in the world. We construct a miniature integration language, still bounded within the space of existing programming language styles, to solve an open authorship problem, and observe that the increased open ownership of expressions has come at a significant usability cost. We fail to escape the prison, and reflect that our own dialogue remains predominantly inward-facing, due to the lack of proper materials and vocabulary to put communities into correspondence. We look forward to more convivial venues and idioms for expressing computational artefacts, with more equal relationships between the ecologies of construction and ecologies of use.

 Publisher's Version
What It Takes to Create with Domain-Appropriate Tools: Reflections on Implementing the “Id” System
Joel Jakubovic
(University of Kent, UK)
There is a One-Size-Fits-All quality to languages, APIs and even programming itself. Whether you're making a mobile game or a scientific simulation, you will be using a text-based language with similar devices for structuring your code. This is a source of artificial difficulty in creating, understanding, and modifying software systems. No matter the domain, the author's design needs encoding into a form that does not resemble it.
This paper describes a vision where software can be built in a programming environment that is closer to the domain of the software itself. By doing so, users of the system can use familiar abstractions and tools for adapting it. A step towards this vision is presented: a Web version of a minimal OOP system, developed as an executable version of the diagrams of its design, in a substrate meant to facilitate this. The experience of creating such a substrate is analysed, and I suggest deficiencies in programming environments that stand in the way of making this practice commonplace, as well as ways to fill in these gaps.

 Publisher's Version
Chatting with Glue: Cognitive Tools for Augmented Conversation
Max Krieger
(Carnegie Mellon University, USA)
Conversation is a creative process. When we converse, we engage rich networks of meaning, forming conceptual connections within and among ourselves. To prevent these connections from fading, we take notes or work together through other external media. Sufficiently rich conversation is a multimedia activity.
The recording media we use for conversations (audio, video, text) are immutable, linear, and one-dimensional. As conversation has become computationally-mediated, it has inherited the limitations of these recording media. Both recording and chat media coerce conversation into a structure that contradicts how its content came about in the first place.
I propose tools for a more principled chat that embraces the capabilities of our minds and the computational medium. These tools augment conversation, remote or in-person, into a creative activity for knowledge-making.

 Publisher's Version Info

2020 Posters

Helping Software Developers through Live Software Metrics Visualization
Sara Fernandes, André Restivo, Hugo Sereno Ferreira, and Ademar Aguiar
(University of Porto, Portugal; LIACC, Portugal; INESC TEC, Portugal)
With the increasing complexity of software systems, software developers would benefit from instant and continuous feedback about the system they are maintaining and evolving. Despite existing several solutions providing feedback and suggesting improvements, many tools require explicit invocations, leading developers to miss some improvement opportunities, such as important refactorings, due to the loss of their train of thought. Therefore, to address these limitations, we developed a Visual Studio Code plugin providing real-time feedback --- and also information about each commit made to the version control system. This tool is also capable of recommending two types of refactorings. To validate this approach, we did a preliminary controlled experiment using hypothesis-tests to check specific results. However, in this initial stage, we didn't have enough data to confirm our research questions, and we weren't able yet to confirm the main hypothesis.

 Publisher's Version
Overviewing the Liveness of Refactoring for Energy Efficiency
Emanuel Moreira, Filipe F. Correia, and João Bispo
(University of Porto, Portugal; INESC TEC, Portugal)
Mobile device users have been growing in the last years but the limited battery life of these devices is considered one of the major issues amongst users and programmers. Therefore, there is a need to guide developers in developing mobile applications in the most energy efficient way. One of the ways to improve this is to provide live feedback about the energy efficiency of a program while it's being programmed. We have analyzed and compared a total of 16 different tools and presented a list of 15 code smells and respective refactorings. From the analyzed tools, Leafactor is the closest to a valid solution to our problem because it's the only energy-aware tool with the highest liveness level. However, in order to be executed the programmer needs to trigger it on the IDE by selecting the file, instead of automatically being executed without the programmer being noticed and refactor his inefficient code.

 Publisher's Version

2020 Student Research Competition

Towards Language-Parametric Refactorings
Philippe D. Misteli
(Delft University of Technology, Netherlands)
A software refactoring is a program transformation that improves the structure of the code, while preserving its behavior. Most modern IDEs offer a number of automated refactorings as editor services. However, correctly implementing refactorings is notoriously complex, and these state-of-the-art implementations are known to be faulty and too restrictive.
Spoofax is a language workbench that allows language engineers to define languages through declarative specifications. When developing a new programming language, it is both difficult and time-consuming to implement automated refactoring transformations. The goal of this work is to implement sound language-parametric refactorings, which rely on an abstract program model built from the declarative specification of a language's static semantics.

 Publisher's Version
Efficient Editing in a Tree-Oriented Projectional Editor
Tom Beckmann
(HPI, Germany)
In contrast to text editors, using projectional editors typically requires users to learn a new editing metaphor. In text-oriented projectional editors, rules may be used to give users the impression of working in a regular text editor. As such, the editing metaphor appears clear to the user, but if the implemented rules do not suffice, users may be confused why certain actions do not work. Block-oriented projectional editors, where the editing metaphors are typically clearer, often present challenges in editing efficiency, as code takes up more space and editing is perceived to be slower. We present a block-oriented projectional editor that tries to address the issues of editing efficiency and space usage. Through a reusable set of commands for tree modifications, a space-efficient AST visualization, and context-aware input we allow users to edit as fast or faster than in a text editor. We provide a first evaluation by comparing the number of keystrokes required to carry out common edit operations.

 Publisher's Version
ReAD: Representational Algorithmic Design
Renata Castelo-Branco
(INESC-ID, Portugal; University of Lisbon, Portugal)
Algorithmic Design (AD) is a novel approach to architectural design based on the creation of form through algorithms. The inherent flexibility of AD encourages the exploration of a wider design space, the automation of design tasks, and design optimization, considerably reducing project costs. Nevertheless, current AD uses representation methods that radically differ from those used in architectural practice. This creates a barrier to the adoption of AD, thus, limiting the potential benefits. We propose to address this problem by coupling AD with complementary representation methods that are adequate for designing complex architectural projects and by supporting their synchronization in a dedicated design tool.

 Publisher's Version
A Formalism to Model Higher-Order Function
Damien Morard
(University of Geneva, Switzerland)
Recent years have seen a significant renewed interest into functional programming. This approach focuses on a more declarative style of programming, as opposed to the imperative view, which focuses on describing computation steps. Therefore, it sits at a higher abstraction level, particularly useful to describe complex modular applications, such as mobile and web user interfaces. Unfortunately, existing formalisms, tools and techniques to model computer systems are ill-suited to describe highly-functional applications.
In a effort to tackle this issue, we propose a new formalism, based on high-level Petri nets, that allows to manipulate functions as first-class objects, directly within the model. We present our motivation, introduce our formalism by the means of examples and discuss potential ways to carry out software verification.

 Publisher's Version
An Annotation System for Specifying Aliasing Invariants on Object Fields
Aurélien Coet
(University of Geneva, Switzerland)
Aliasing is an essential concept in programming languages, used to represent self-referential structures and share data between components. Unfortunately, it is also a common source of software bugs that are often hard to find and fix. In response, a plethora of methods have been proposed to tame aliasing. They usually rely on uniqueness and/or immutability to establish strong safety guarantees, but are often too restrictive to write common idioms, as they generally enforce a single-writer policy. This paper suggests to relax this constraint by focusing on the specific parts of an object representation for which aliasing should be controlled, otherwise allowing unrestricted mutations of its fields.

 Publisher's Version
Pattern-Match-Oriented Proof Writing Language
Satoshi Egi
(University of Tokyo, Japan)
This paper demonstrates how pattern matching for non-free data types can make proofs intuitive.

 Publisher's Version
An Experimental Audio-Tactile Interface for Sculpting Digital Resonance Models using Modelling Clay
Jack Armitage
(Queen Mary University of London, UK)
Programming interfaces are still monopolised by the typewriter and paper emulator display. This makes programming exclusionary towards anyone for whom such interfaces are unpleasant, unnatural or unusable. Further, this monopoly excludes every other human faculty that might be used to express unexpressed programs through unimagined means. To destablise this status quo, alternative programming models have been sought which are more amenable to a wider range of interfaces. We believe a complimentary approach to be broadening the search for programming interfaces by excluding the need for an explicit programming model at first. We present an experimental audio-tactile interface for sculpting digital resonance models using clay, along with preliminary reflections from a study with 34 musicians, luthiers and other craftspeople. We reflect on how tracing the emergence of tacit and embodied knowledge about an unfamiliar, implicit programming interface could inspire different ideas about programming models and other aspects of programming systems.

 Publisher's Version
N-gram Models for Code Completion in Pharo
Myroslava Romaniuk
(Ukrainian Catholic University, Ukraine)
In this paper, I present applying statistical language models to improve code completion in Pharo. In particular, the goal is to use n-gram models for sorting the completion candidates and, in such a way, increase the relevancy of the suggested completions.

 Publisher's Version

proc time: 11