<Programming'20> Companion Companion '20: "Bicycles for the Mind Have ..."
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.
@InProceedings{<Programming'20> Companion20p173,
author = {Kartik Agaram},
title = {Bicycles for the Mind Have to Be See-Through},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {173--186},
doi = {10.1145/3397537.3397547},
year = {2020},
}
Publisher's Version
Info
<Programming'20> Companion Companion '20: "Helping Software Developers ..."
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.
@InProceedings{<Programming'20> Companion20p209,
author = {Sara Fernandes and André Restivo and Hugo Sereno Ferreira and Ademar Aguiar},
title = {Helping Software Developers through Live Software Metrics Visualization},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {209--210},
doi = {10.1145/3397537.3397539},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Assessing Textual Source Code ..."
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.
@InProceedings{<Programming'20> Companion20p50,
author = {Alejandra Cossio Chavalier and Juan Pablo Sandoval Alcocer and Alexandre Bergel},
title = {Assessing Textual Source Code Comparison: Split or Unified?},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {50--54},
doi = {10.1145/3397537.3398471},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "An Experimental Audio-Tactile ..."
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.
@InProceedings{<Programming'20> Companion20p225,
author = {Jack Armitage},
title = {An Experimental Audio-Tactile Interface for Sculpting Digital Resonance Models using Modelling Clay},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {225--226},
doi = {10.1145/3397537.3398482},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "MATLAB Doesn't Love Me: ..."
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.
@InProceedings{<Programming'20> Companion20p97,
author = {Tijs van der Storm and Geor Bakker},
title = {MATLAB Doesn't Love Me: An Essay},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {97--101},
doi = {10.1145/3397537.3397557},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Escaping the Prison of Style ..."
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.
@InProceedings{<Programming'20> Companion20p187,
author = {Antranig Basman and Philip Tchernavskij},
title = {Escaping the Prison of Style},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {187--196},
doi = {10.1145/3397537.3397548},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Superoptimization of WebAssembly ..."
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.
@InProceedings{<Programming'20> Companion20p36,
author = {Javier Cabrera Arteaga and Shrinish Donde and Jian Gu and Orestis Floros and Lucas Satabin and Benoit Baudry and Martin Monperrus},
title = {Superoptimization of WebAssembly Bytecode},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {36--40},
doi = {10.1145/3397537.3397567},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Visual Design for a Tree-Oriented ..."
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.
@InProceedings{<Programming'20> Companion20p113,
author = {Tom Beckmann and Stefan Ramson and Patrick Rein and Robert Hirschfeld},
title = {Visual Design for a Tree-Oriented Projectional Editor},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {113--119},
doi = {10.1145/3397537.3397560},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Efficient Editing in a Tree-Oriented ..."
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.
@InProceedings{<Programming'20> Companion20p215,
author = {Tom Beckmann},
title = {Efficient Editing in a Tree-Oriented Projectional Editor},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {215--216},
doi = {10.1145/3397537.3398477},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Assessing Textual Source Code ..."
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.
@InProceedings{<Programming'20> Companion20p50,
author = {Alejandra Cossio Chavalier and Juan Pablo Sandoval Alcocer and Alexandre Bergel},
title = {Assessing Textual Source Code Comparison: Split or Unified?},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {50--54},
doi = {10.1145/3397537.3398471},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Towards Dynamic SQL Compilation ..."
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.
@InProceedings{<Programming'20> Companion20p46,
author = {Filippo Schiavio and Daniele Bonetta and Walter Binder},
title = {Towards Dynamic SQL Compilation in Apache Spark},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {46--49},
doi = {10.1145/3397537.3397566},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Profiling Streams on the Java ..."
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.
@InProceedings{<Programming'20> Companion20p27,
author = {Edgar Eduardo Rosales Rosero and Andrea Rosà and Walter Binder},
title = {Profiling Streams on the Java Virtual Machine},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {27--30},
doi = {10.1145/3397537.3397565},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Overviewing the Liveness of ..."
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.
@InProceedings{<Programming'20> Companion20p211,
author = {Emanuel Moreira and Filipe F. Correia and João Bispo},
title = {Overviewing the Liveness of Refactoring for Energy Efficiency},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {211--212},
doi = {10.1145/3397537.3397538},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Supporting the Composition ..."
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.
@InProceedings{<Programming'20> Companion20p17,
author = {Brigitte Boden and Robert Mischke and Alexander Weinert and Andreas Schreiber},
title = {Supporting the Composition of Domain-Specific Software via Task-Specific Roles},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {17--18},
doi = {10.1145/3397537.3399576},
year = {2020},
}
Publisher's Version
Info
<Programming'20> Companion Companion '20: "Towards Dynamic SQL Compilation ..."
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.
@InProceedings{<Programming'20> Companion20p46,
author = {Filippo Schiavio and Daniele Bonetta and Walter Binder},
title = {Towards Dynamic SQL Compilation in Apache Spark},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {46--49},
doi = {10.1145/3397537.3397566},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Towards Efficient Interdisciplinary ..."
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.
@InProceedings{<Programming'20> Companion20p65,
author = {Ingo Börsting and Volker Gruhn},
title = {Towards Efficient Interdisciplinary Authoring of Industrial Augmented Reality Applications},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {65--68},
doi = {10.1145/3397537.3398474},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Program Comprehension for ..."
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.
@InProceedings{<Programming'20> Companion20p69,
author = {Renata Castelo-Branco and António Leitão and Catarina Brás},
title = {Program Comprehension for Live Algorithmic Design in Virtual Reality},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {69--76},
doi = {10.1145/3397537.3398475},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "LogicKit: Bringing Logic Programming ..."
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.
@InProceedings{<Programming'20> Companion20p13,
author = {Dimitri Racordon and Didier Buchs},
title = {LogicKit: Bringing Logic Programming to Swift},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {13--16},
doi = {10.1145/3397537.3399575},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Superoptimization of WebAssembly ..."
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.
@InProceedings{<Programming'20> Companion20p36,
author = {Javier Cabrera Arteaga and Shrinish Donde and Jian Gu and Orestis Floros and Lucas Satabin and Benoit Baudry and Martin Monperrus},
title = {Superoptimization of WebAssembly Bytecode},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {36--40},
doi = {10.1145/3397537.3397567},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Program Comprehension for ..."
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.
@InProceedings{<Programming'20> Companion20p69,
author = {Renata Castelo-Branco and António Leitão and Catarina Brás},
title = {Program Comprehension for Live Algorithmic Design in Virtual Reality},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {69--76},
doi = {10.1145/3397537.3398475},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "ReAD: Representational Algorithmic ..."
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.
@InProceedings{<Programming'20> Companion20p217,
author = {Renata Castelo-Branco},
title = {ReAD: Representational Algorithmic Design},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {217--218},
doi = {10.1145/3397537.3398478},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Evolution of the WebDSL Runtime: ..."
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.
@InProceedings{<Programming'20> Companion20p77,
author = {Danny M. Groenewegen and Elmer van Chastelet and Eelco Visser},
title = {Evolution of the WebDSL Runtime: Reliability Engineering of the WebDSL Web Programming Language},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {77--83},
doi = {10.1145/3397537.3397553},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Assessing Textual Source Code ..."
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.
@InProceedings{<Programming'20> Companion20p50,
author = {Alejandra Cossio Chavalier and Juan Pablo Sandoval Alcocer and Alexandre Bergel},
title = {Assessing Textual Source Code Comparison: Split or Unified?},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {50--54},
doi = {10.1145/3397537.3398471},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "An Annotation System for Specifying ..."
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.
@InProceedings{<Programming'20> Companion20p221,
author = {Aurélien Coet},
title = {An Annotation System for Specifying Aliasing Invariants on Object Fields},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {221--222},
doi = {10.1145/3397537.3398480},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Overviewing the Liveness of ..."
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.
@InProceedings{<Programming'20> Companion20p211,
author = {Emanuel Moreira and Filipe F. Correia and João Bispo},
title = {Overviewing the Liveness of Refactoring for Energy Efficiency},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {211--212},
doi = {10.1145/3397537.3397538},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Towards a Dynamic Multiscale ..."
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.
@InProceedings{<Programming'20> Companion20p136,
author = {Amy Rae Fox and Philip Guo and Clemens Nylandsted Klokmose and Peter Dalsgaard and Arvind Satyanarayan and Haijun Xia and James D. Hollan},
title = {Towards a Dynamic Multiscale Personal Information Space: Beyond Application and Document Centered Views of Information},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {136--143},
doi = {10.1145/3397537.3397542},
year = {2020},
}
Publisher's Version
Video
Info
<Programming'20> Companion Companion '20: "Superoptimization of WebAssembly ..."
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.
@InProceedings{<Programming'20> Companion20p36,
author = {Javier Cabrera Arteaga and Shrinish Donde and Jian Gu and Orestis Floros and Lucas Satabin and Benoit Baudry and Martin Monperrus},
title = {Superoptimization of WebAssembly Bytecode},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {36--40},
doi = {10.1145/3397537.3397567},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Towards a Pattern Language ..."
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.
@InProceedings{<Programming'20> Companion20p102,
author = {Tao Dong and Gale Yang},
title = {Towards a Pattern Language for Interactive Coding Tutorials},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {102--105},
doi = {10.1145/3397537.3397558},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Pattern-Match-Oriented Proof ..."
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.
@InProceedings{<Programming'20> Companion20p223,
author = {Satoshi Egi},
title = {Pattern-Match-Oriented Proof Writing Language},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {223--224},
doi = {10.1145/3397537.3398481},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Polyglot Code Finder ..."
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.
@InProceedings{<Programming'20> Companion20p106,
author = {Jan Ehmueller and Alexander Riese and Hendrik Tjabben and Fabio Niephaus and Robert Hirschfeld},
title = {Polyglot Code Finder},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {106--112},
doi = {10.1145/3397537.3397559},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "User-Defined Interface Mappings ..."
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.
@InProceedings{<Programming'20> Companion20p19,
author = {Alexander Riese and Fabio Niephaus and Tim Felgentreff and Robert Hirschfeld},
title = {User-Defined Interface Mappings for the GraalVM},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {19--22},
doi = {10.1145/3397537.3399577},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Toward Presizing and Pretransitioning ..."
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.
@InProceedings{<Programming'20> Companion20p41,
author = {Johannes Henning and Tim Felgentreff and Fabio Niephaus and Robert Hirschfeld},
title = {Toward Presizing and Pretransitioning Strategies for GraalPython},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {41--45},
doi = {10.1145/3397537.3397564},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Helping Software Developers ..."
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.
@InProceedings{<Programming'20> Companion20p209,
author = {Sara Fernandes and André Restivo and Hugo Sereno Ferreira and Ademar Aguiar},
title = {Helping Software Developers through Live Software Metrics Visualization},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {209--210},
doi = {10.1145/3397537.3397539},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Helping Software Developers ..."
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.
@InProceedings{<Programming'20> Companion20p209,
author = {Sara Fernandes and André Restivo and Hugo Sereno Ferreira and Ademar Aguiar},
title = {Helping Software Developers through Live Software Metrics Visualization},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {209--210},
doi = {10.1145/3397537.3397539},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Superoptimization of WebAssembly ..."
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.
@InProceedings{<Programming'20> Companion20p36,
author = {Javier Cabrera Arteaga and Shrinish Donde and Jian Gu and Orestis Floros and Lucas Satabin and Benoit Baudry and Martin Monperrus},
title = {Superoptimization of WebAssembly Bytecode},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {36--40},
doi = {10.1145/3397537.3397567},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Towards a Dynamic Multiscale ..."
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.
@InProceedings{<Programming'20> Companion20p136,
author = {Amy Rae Fox and Philip Guo and Clemens Nylandsted Klokmose and Peter Dalsgaard and Arvind Satyanarayan and Haijun Xia and James D. Hollan},
title = {Towards a Dynamic Multiscale Personal Information Space: Beyond Application and Document Centered Views of Information},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {136--143},
doi = {10.1145/3397537.3397542},
year = {2020},
}
Publisher's Version
Video
Info
<Programming'20> Companion Companion '20: "Running Parallel Bytecode ..."
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.
@InProceedings{<Programming'20> Companion20p31,
author = {Juan Fumero and Athanasios Stratikopoulos and Christos Kotselidis},
title = {Running Parallel Bytecode Interpreters on Heterogeneous Hardware},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {31--35},
doi = {10.1145/3397537.3397563},
year = {2020},
}
Publisher's Version
Video
<Programming'20> Companion Companion '20: "Synthesizing User Interfaces ..."
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.
@InProceedings{<Programming'20> Companion20p84,
author = {Adam Granicz and Jozsef Uri and Andras Janko},
title = {Synthesizing User Interfaces using Functional Reactive Web Abstractions},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {84--89},
doi = {10.1145/3397537.3397554},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Evolution of the WebDSL Runtime: ..."
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.
@InProceedings{<Programming'20> Companion20p77,
author = {Danny M. Groenewegen and Elmer van Chastelet and Eelco Visser},
title = {Evolution of the WebDSL Runtime: Reliability Engineering of the WebDSL Web Programming Language},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {77--83},
doi = {10.1145/3397537.3397553},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Towards Efficient Interdisciplinary ..."
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.
@InProceedings{<Programming'20> Companion20p65,
author = {Ingo Börsting and Volker Gruhn},
title = {Towards Efficient Interdisciplinary Authoring of Industrial Augmented Reality Applications},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {65--68},
doi = {10.1145/3397537.3398474},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Enhancement of OpenJDK Biased ..."
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.
@InProceedings{<Programming'20> Companion20p23,
author = {Ting Wang and Michihiro Horie and Kazunori Ogata and Hao Chen Gui and Xiao Ping Guo and Yang Liu},
title = {Enhancement of OpenJDK Biased Locking for Infrequent Lock Contention},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {23--26},
doi = {10.1145/3397537.3397562},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Superoptimization of WebAssembly ..."
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.
@InProceedings{<Programming'20> Companion20p36,
author = {Javier Cabrera Arteaga and Shrinish Donde and Jian Gu and Orestis Floros and Lucas Satabin and Benoit Baudry and Martin Monperrus},
title = {Superoptimization of WebAssembly Bytecode},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {36--40},
doi = {10.1145/3397537.3397567},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Towards a Dynamic Multiscale ..."
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.
@InProceedings{<Programming'20> Companion20p136,
author = {Amy Rae Fox and Philip Guo and Clemens Nylandsted Klokmose and Peter Dalsgaard and Arvind Satyanarayan and Haijun Xia and James D. Hollan},
title = {Towards a Dynamic Multiscale Personal Information Space: Beyond Application and Document Centered Views of Information},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {136--143},
doi = {10.1145/3397537.3397542},
year = {2020},
}
Publisher's Version
Video
Info
<Programming'20> Companion Companion '20: "Enhancement of OpenJDK Biased ..."
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.
@InProceedings{<Programming'20> Companion20p23,
author = {Ting Wang and Michihiro Horie and Kazunori Ogata and Hao Chen Gui and Xiao Ping Guo and Yang Liu},
title = {Enhancement of OpenJDK Biased Locking for Infrequent Lock Contention},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {23--26},
doi = {10.1145/3397537.3397562},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Towards Visualization of Evolution ..."
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.
@InProceedings{<Programming'20> Companion20p61,
author = {Elke Franziska Heidmann and Annika Meinecke and Lynn von Kurnatowski and Andreas Schreiber},
title = {Towards Visualization of Evolution of Component-Based Software Architectures in VR},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {61--64},
doi = {10.1145/3397537.3398473},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Toward Presizing and Pretransitioning ..."
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.
@InProceedings{<Programming'20> Companion20p41,
author = {Johannes Henning and Tim Felgentreff and Fabio Niephaus and Robert Hirschfeld},
title = {Toward Presizing and Pretransitioning Strategies for GraalPython},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {41--45},
doi = {10.1145/3397537.3397564},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Three Trillion Lines: Infrastructure ..."
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.
@InProceedings{<Programming'20> Companion20p1,
author = {Toni Mattis and Patrick Rein and Robert Hirschfeld},
title = {Three Trillion Lines: Infrastructure for Mining GitHub in the Classroom},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {1--6},
doi = {10.1145/3397537.3397551},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "User-Defined Interface Mappings ..."
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.
@InProceedings{<Programming'20> Companion20p19,
author = {Alexander Riese and Fabio Niephaus and Tim Felgentreff and Robert Hirschfeld},
title = {User-Defined Interface Mappings for the GraalVM},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {19--22},
doi = {10.1145/3397537.3399577},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Toward Presizing and Pretransitioning ..."
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.
@InProceedings{<Programming'20> Companion20p41,
author = {Johannes Henning and Tim Felgentreff and Fabio Niephaus and Robert Hirschfeld},
title = {Toward Presizing and Pretransitioning Strategies for GraalPython},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {41--45},
doi = {10.1145/3397537.3397564},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Visual Design for a Tree-Oriented ..."
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.
@InProceedings{<Programming'20> Companion20p113,
author = {Tom Beckmann and Stefan Ramson and Patrick Rein and Robert Hirschfeld},
title = {Visual Design for a Tree-Oriented Projectional Editor},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {113--119},
doi = {10.1145/3397537.3397560},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Polyglot Code Finder ..."
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.
@InProceedings{<Programming'20> Companion20p106,
author = {Jan Ehmueller and Alexander Riese and Hendrik Tjabben and Fabio Niephaus and Robert Hirschfeld},
title = {Polyglot Code Finder},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {106--112},
doi = {10.1145/3397537.3397559},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Towards a Dynamic Multiscale ..."
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.
@InProceedings{<Programming'20> Companion20p136,
author = {Amy Rae Fox and Philip Guo and Clemens Nylandsted Klokmose and Peter Dalsgaard and Arvind Satyanarayan and Haijun Xia and James D. Hollan},
title = {Towards a Dynamic Multiscale Personal Information Space: Beyond Application and Document Centered Views of Information},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {136--143},
doi = {10.1145/3397537.3397542},
year = {2020},
}
Publisher's Version
Video
Info
<Programming'20> Companion Companion '20: "Enhancement of OpenJDK Biased ..."
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.
@InProceedings{<Programming'20> Companion20p23,
author = {Ting Wang and Michihiro Horie and Kazunori Ogata and Hao Chen Gui and Xiao Ping Guo and Yang Liu},
title = {Enhancement of OpenJDK Biased Locking for Infrequent Lock Contention},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {23--26},
doi = {10.1145/3397537.3397562},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Wildcard: Spreadsheet-Driven ..."
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.
@InProceedings{<Programming'20> Companion20p126,
author = {Geoffrey Litt and Daniel Jackson},
title = {Wildcard: Spreadsheet-Driven Customization of Web Applications},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {126--135},
doi = {10.1145/3397537.3397541},
year = {2020},
}
Publisher's Version
Info
<Programming'20> Companion Companion '20: "What It Takes to Create with ..."
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.
@InProceedings{<Programming'20> Companion20p197,
author = {Joel Jakubovic},
title = {What It Takes to Create with Domain-Appropriate Tools: Reflections on Implementing the “Id” System},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {197--207},
doi = {10.1145/3397537.3397549},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Synthesizing User Interfaces ..."
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.
@InProceedings{<Programming'20> Companion20p84,
author = {Adam Granicz and Jozsef Uri and Andras Janko},
title = {Synthesizing User Interfaces using Functional Reactive Web Abstractions},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {84--89},
doi = {10.1145/3397537.3397554},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Rethinking Programming “Environment”: ..."
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.
@InProceedings{<Programming'20> Companion20p149,
author = {Jun Kato and Keisuke Shimakage},
title = {Rethinking Programming “Environment”: Technical and Social Environment Design toward Convivial Computing},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {149--157},
doi = {10.1145/3397537.3397544},
year = {2020},
}
Publisher's Version
Video
Info
<Programming'20> Companion Companion '20: "Convivial Design Heuristics ..."
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.
@InProceedings{<Programming'20> Companion20p144,
author = {Stephen Kell},
title = {Convivial Design Heuristics for Software Systems},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {144--148},
doi = {10.1145/3397537.3397543},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Towards a Dynamic Multiscale ..."
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.
@InProceedings{<Programming'20> Companion20p136,
author = {Amy Rae Fox and Philip Guo and Clemens Nylandsted Klokmose and Peter Dalsgaard and Arvind Satyanarayan and Haijun Xia and James D. Hollan},
title = {Towards a Dynamic Multiscale Personal Information Space: Beyond Application and Document Centered Views of Information},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {136--143},
doi = {10.1145/3397537.3397542},
year = {2020},
}
Publisher's Version
Video
Info
<Programming'20> Companion Companion '20: "Achieving Guidance in Applied ..."
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.
@InProceedings{<Programming'20> Companion20p7,
author = {Lars Reimann and Günter Kniesel-Wünsche},
title = {Achieving Guidance in Applied Machine Learning through Software Engineering Techniques},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {7--12},
doi = {10.1145/3397537.3397552},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Running Parallel Bytecode ..."
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.
@InProceedings{<Programming'20> Companion20p31,
author = {Juan Fumero and Athanasios Stratikopoulos and Christos Kotselidis},
title = {Running Parallel Bytecode Interpreters on Heterogeneous Hardware},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {31--35},
doi = {10.1145/3397537.3397563},
year = {2020},
}
Publisher's Version
Video
<Programming'20> Companion Companion '20: "Chatting with Glue: Cognitive ..."
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.
@InProceedings{<Programming'20> Companion20p208,
author = {Max Krieger},
title = {Chatting with Glue: Cognitive Tools for Augmented Conversation},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {208--208},
doi = {10.1145/3397537.3397550},
year = {2020},
}
Publisher's Version
Info
<Programming'20> Companion Companion '20: "Towards Visualization of Evolution ..."
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.
@InProceedings{<Programming'20> Companion20p61,
author = {Elke Franziska Heidmann and Annika Meinecke and Lynn von Kurnatowski and Andreas Schreiber},
title = {Towards Visualization of Evolution of Component-Based Software Architectures in VR},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {61--64},
doi = {10.1145/3397537.3398473},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Program Comprehension for ..."
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.
@InProceedings{<Programming'20> Companion20p69,
author = {Renata Castelo-Branco and António Leitão and Catarina Brás},
title = {Program Comprehension for Live Algorithmic Design in Virtual Reality},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {69--76},
doi = {10.1145/3397537.3398475},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Wildcard: Spreadsheet-Driven ..."
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.
@InProceedings{<Programming'20> Companion20p126,
author = {Geoffrey Litt and Daniel Jackson},
title = {Wildcard: Spreadsheet-Driven Customization of Web Applications},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {126--135},
doi = {10.1145/3397537.3397541},
year = {2020},
}
Publisher's Version
Info
<Programming'20> Companion Companion '20: "Enhancement of OpenJDK Biased ..."
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.
@InProceedings{<Programming'20> Companion20p23,
author = {Ting Wang and Michihiro Horie and Kazunori Ogata and Hao Chen Gui and Xiao Ping Guo and Yang Liu},
title = {Enhancement of OpenJDK Biased Locking for Infrequent Lock Contention},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {23--26},
doi = {10.1145/3397537.3397562},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Three Trillion Lines: Infrastructure ..."
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.
@InProceedings{<Programming'20> Companion20p1,
author = {Toni Mattis and Patrick Rein and Robert Hirschfeld},
title = {Three Trillion Lines: Infrastructure for Mining GitHub in the Classroom},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {1--6},
doi = {10.1145/3397537.3397551},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Towards Visualization of Evolution ..."
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.
@InProceedings{<Programming'20> Companion20p61,
author = {Elke Franziska Heidmann and Annika Meinecke and Lynn von Kurnatowski and Andreas Schreiber},
title = {Towards Visualization of Evolution of Component-Based Software Architectures in VR},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {61--64},
doi = {10.1145/3397537.3398473},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Towards Requirements Engineering ..."
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.
@InProceedings{<Programming'20> Companion20p55,
author = {Nitish Patkar and Leonel Merino and Oscar Nierstrasz},
title = {Towards Requirements Engineering with Immersive Augmented Reality},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {55--60},
doi = {10.1145/3397537.3398472},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Supporting the Composition ..."
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.
@InProceedings{<Programming'20> Companion20p17,
author = {Brigitte Boden and Robert Mischke and Alexander Weinert and Andreas Schreiber},
title = {Supporting the Composition of Domain-Specific Software via Task-Specific Roles},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {17--18},
doi = {10.1145/3397537.3399576},
year = {2020},
}
Publisher's Version
Info
<Programming'20> Companion Companion '20: "Towards Language-Parametric ..."
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.
@InProceedings{<Programming'20> Companion20p213,
author = {Philippe D. Misteli},
title = {Towards Language-Parametric Refactorings},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {213--214},
doi = {10.1145/3397537.3398476},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Superoptimization of WebAssembly ..."
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.
@InProceedings{<Programming'20> Companion20p36,
author = {Javier Cabrera Arteaga and Shrinish Donde and Jian Gu and Orestis Floros and Lucas Satabin and Benoit Baudry and Martin Monperrus},
title = {Superoptimization of WebAssembly Bytecode},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {36--40},
doi = {10.1145/3397537.3397567},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "A Formalism to Model Higher-Order ..."
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.
@InProceedings{<Programming'20> Companion20p219,
author = {Damien Morard},
title = {A Formalism to Model Higher-Order Function},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {219--220},
doi = {10.1145/3397537.3398479},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Overviewing the Liveness of ..."
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.
@InProceedings{<Programming'20> Companion20p211,
author = {Emanuel Moreira and Filipe F. Correia and João Bispo},
title = {Overviewing the Liveness of Refactoring for Energy Efficiency},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {211--212},
doi = {10.1145/3397537.3397538},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "User-Defined Interface Mappings ..."
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.
@InProceedings{<Programming'20> Companion20p19,
author = {Alexander Riese and Fabio Niephaus and Tim Felgentreff and Robert Hirschfeld},
title = {User-Defined Interface Mappings for the GraalVM},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {19--22},
doi = {10.1145/3397537.3399577},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Toward Presizing and Pretransitioning ..."
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.
@InProceedings{<Programming'20> Companion20p41,
author = {Johannes Henning and Tim Felgentreff and Fabio Niephaus and Robert Hirschfeld},
title = {Toward Presizing and Pretransitioning Strategies for GraalPython},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {41--45},
doi = {10.1145/3397537.3397564},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Polyglot Code Finder ..."
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.
@InProceedings{<Programming'20> Companion20p106,
author = {Jan Ehmueller and Alexander Riese and Hendrik Tjabben and Fabio Niephaus and Robert Hirschfeld},
title = {Polyglot Code Finder},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {106--112},
doi = {10.1145/3397537.3397559},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Towards Requirements Engineering ..."
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.
@InProceedings{<Programming'20> Companion20p55,
author = {Nitish Patkar and Leonel Merino and Oscar Nierstrasz},
title = {Towards Requirements Engineering with Immersive Augmented Reality},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {55--60},
doi = {10.1145/3397537.3398472},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Enhancement of OpenJDK Biased ..."
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.
@InProceedings{<Programming'20> Companion20p23,
author = {Ting Wang and Michihiro Horie and Kazunori Ogata and Hao Chen Gui and Xiao Ping Guo and Yang Liu},
title = {Enhancement of OpenJDK Biased Locking for Infrequent Lock Contention},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {23--26},
doi = {10.1145/3397537.3397562},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Towards Requirements Engineering ..."
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.
@InProceedings{<Programming'20> Companion20p55,
author = {Nitish Patkar and Leonel Merino and Oscar Nierstrasz},
title = {Towards Requirements Engineering with Immersive Augmented Reality},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {55--60},
doi = {10.1145/3397537.3398472},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "LogicKit: Bringing Logic Programming ..."
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.
@InProceedings{<Programming'20> Companion20p13,
author = {Dimitri Racordon and Didier Buchs},
title = {LogicKit: Bringing Logic Programming to Swift},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {13--16},
doi = {10.1145/3397537.3399575},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Visual Design for a Tree-Oriented ..."
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.
@InProceedings{<Programming'20> Companion20p113,
author = {Tom Beckmann and Stefan Ramson and Patrick Rein and Robert Hirschfeld},
title = {Visual Design for a Tree-Oriented Projectional Editor},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {113--119},
doi = {10.1145/3397537.3397560},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Achieving Guidance in Applied ..."
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.
@InProceedings{<Programming'20> Companion20p7,
author = {Lars Reimann and Günter Kniesel-Wünsche},
title = {Achieving Guidance in Applied Machine Learning through Software Engineering Techniques},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {7--12},
doi = {10.1145/3397537.3397552},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Three Trillion Lines: Infrastructure ..."
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.
@InProceedings{<Programming'20> Companion20p1,
author = {Toni Mattis and Patrick Rein and Robert Hirschfeld},
title = {Three Trillion Lines: Infrastructure for Mining GitHub in the Classroom},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {1--6},
doi = {10.1145/3397537.3397551},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Visual Design for a Tree-Oriented ..."
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.
@InProceedings{<Programming'20> Companion20p113,
author = {Tom Beckmann and Stefan Ramson and Patrick Rein and Robert Hirschfeld},
title = {Visual Design for a Tree-Oriented Projectional Editor},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {113--119},
doi = {10.1145/3397537.3397560},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Helping Software Developers ..."
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.
@InProceedings{<Programming'20> Companion20p209,
author = {Sara Fernandes and André Restivo and Hugo Sereno Ferreira and Ademar Aguiar},
title = {Helping Software Developers through Live Software Metrics Visualization},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {209--210},
doi = {10.1145/3397537.3397539},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "User-Defined Interface Mappings ..."
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.
@InProceedings{<Programming'20> Companion20p19,
author = {Alexander Riese and Fabio Niephaus and Tim Felgentreff and Robert Hirschfeld},
title = {User-Defined Interface Mappings for the GraalVM},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {19--22},
doi = {10.1145/3397537.3399577},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Polyglot Code Finder ..."
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.
@InProceedings{<Programming'20> Companion20p106,
author = {Jan Ehmueller and Alexander Riese and Hendrik Tjabben and Fabio Niephaus and Robert Hirschfeld},
title = {Polyglot Code Finder},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {106--112},
doi = {10.1145/3397537.3397559},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "N-gram Models for Code Completion ..."
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.
@InProceedings{<Programming'20> Companion20p227,
author = {Myroslava Romaniuk},
title = {N-gram Models for Code Completion in Pharo},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {227--228},
doi = {10.1145/3397537.3398483},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Profiling Streams on the Java ..."
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.
@InProceedings{<Programming'20> Companion20p27,
author = {Edgar Eduardo Rosales Rosero and Andrea Rosà and Walter Binder},
title = {Profiling Streams on the Java Virtual Machine},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {27--30},
doi = {10.1145/3397537.3397565},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Profiling Streams on the Java ..."
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.
@InProceedings{<Programming'20> Companion20p27,
author = {Edgar Eduardo Rosales Rosero and Andrea Rosà and Walter Binder},
title = {Profiling Streams on the Java Virtual Machine},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {27--30},
doi = {10.1145/3397537.3397565},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Javardise: A Structured Code ..."
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.
@InProceedings{<Programming'20> Companion20p120,
author = {André L. Santos},
title = {Javardise: A Structured Code Editor for Programming Pedagogy in Java},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {120--125},
doi = {10.1145/3397537.3397561},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Superoptimization of WebAssembly ..."
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.
@InProceedings{<Programming'20> Companion20p36,
author = {Javier Cabrera Arteaga and Shrinish Donde and Jian Gu and Orestis Floros and Lucas Satabin and Benoit Baudry and Martin Monperrus},
title = {Superoptimization of WebAssembly Bytecode},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {36--40},
doi = {10.1145/3397537.3397567},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Towards a Dynamic Multiscale ..."
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.
@InProceedings{<Programming'20> Companion20p136,
author = {Amy Rae Fox and Philip Guo and Clemens Nylandsted Klokmose and Peter Dalsgaard and Arvind Satyanarayan and Haijun Xia and James D. Hollan},
title = {Towards a Dynamic Multiscale Personal Information Space: Beyond Application and Document Centered Views of Information},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {136--143},
doi = {10.1145/3397537.3397542},
year = {2020},
}
Publisher's Version
Video
Info
<Programming'20> Companion Companion '20: "Towards Dynamic SQL Compilation ..."
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.
@InProceedings{<Programming'20> Companion20p46,
author = {Filippo Schiavio and Daniele Bonetta and Walter Binder},
title = {Towards Dynamic SQL Compilation in Apache Spark},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {46--49},
doi = {10.1145/3397537.3397566},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Supporting the Composition ..."
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.
@InProceedings{<Programming'20> Companion20p17,
author = {Brigitte Boden and Robert Mischke and Alexander Weinert and Andreas Schreiber},
title = {Supporting the Composition of Domain-Specific Software via Task-Specific Roles},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {17--18},
doi = {10.1145/3397537.3399576},
year = {2020},
}
Publisher's Version
Info
<Programming'20> Companion Companion '20: "Towards Visualization of Evolution ..."
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.
@InProceedings{<Programming'20> Companion20p61,
author = {Elke Franziska Heidmann and Annika Meinecke and Lynn von Kurnatowski and Andreas Schreiber},
title = {Towards Visualization of Evolution of Component-Based Software Architectures in VR},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {61--64},
doi = {10.1145/3397537.3398473},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Rethinking Programming “Environment”: ..."
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.
@InProceedings{<Programming'20> Companion20p149,
author = {Jun Kato and Keisuke Shimakage},
title = {Rethinking Programming “Environment”: Technical and Social Environment Design toward Convivial Computing},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {149--157},
doi = {10.1145/3397537.3397544},
year = {2020},
}
Publisher's Version
Video
Info
<Programming'20> Companion Companion '20: "Spreadsheets as Notational ..."
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.
@InProceedings{<Programming'20> Companion20p158,
author = {Jonathan Skjøtt},
title = {Spreadsheets as Notational Environment for Paper Weaving},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {158--162},
doi = {10.1145/3397537.3397545},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Running Parallel Bytecode ..."
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.
@InProceedings{<Programming'20> Companion20p31,
author = {Juan Fumero and Athanasios Stratikopoulos and Christos Kotselidis},
title = {Running Parallel Bytecode Interpreters on Heterogeneous Hardware},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {31--35},
doi = {10.1145/3397537.3397563},
year = {2020},
}
Publisher's Version
Video
<Programming'20> Companion Companion '20: "Multiagent Live Programming ..."
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.
@InProceedings{<Programming'20> Companion20p90,
author = {Steven L. Tanimoto},
title = {Multiagent Live Programming Systems: Models and Prospects for Critical Applications},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {90--96},
doi = {10.1145/3397537.3397556},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Escaping the Prison of Style ..."
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.
@InProceedings{<Programming'20> Companion20p187,
author = {Antranig Basman and Philip Tchernavskij},
title = {Escaping the Prison of Style},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {187--196},
doi = {10.1145/3397537.3397548},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Polyglot Code Finder ..."
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.
@InProceedings{<Programming'20> Companion20p106,
author = {Jan Ehmueller and Alexander Riese and Hendrik Tjabben and Fabio Niephaus and Robert Hirschfeld},
title = {Polyglot Code Finder},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {106--112},
doi = {10.1145/3397537.3397559},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Synthesizing User Interfaces ..."
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.
@InProceedings{<Programming'20> Companion20p84,
author = {Adam Granicz and Jozsef Uri and Andras Janko},
title = {Synthesizing User Interfaces using Functional Reactive Web Abstractions},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {84--89},
doi = {10.1145/3397537.3397554},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "MATLAB Doesn't Love Me: ..."
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.
@InProceedings{<Programming'20> Companion20p97,
author = {Tijs van der Storm and Geor Bakker},
title = {MATLAB Doesn't Love Me: An Essay},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {97--101},
doi = {10.1145/3397537.3397557},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Evolution of the WebDSL Runtime: ..."
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.
@InProceedings{<Programming'20> Companion20p77,
author = {Danny M. Groenewegen and Elmer van Chastelet and Eelco Visser},
title = {Evolution of the WebDSL Runtime: Reliability Engineering of the WebDSL Web Programming Language},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {77--83},
doi = {10.1145/3397537.3397553},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Enhancement of OpenJDK Biased ..."
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.
@InProceedings{<Programming'20> Companion20p23,
author = {Ting Wang and Michihiro Horie and Kazunori Ogata and Hao Chen Gui and Xiao Ping Guo and Yang Liu},
title = {Enhancement of OpenJDK Biased Locking for Infrequent Lock Contention},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {23--26},
doi = {10.1145/3397537.3397562},
year = {2020},
}
Publisher's Version
<Programming'20> Companion Companion '20: "Can Programmers Escape the ..."
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.
@InProceedings{<Programming'20> Companion20p163,
author = {Marcel Weiher},
title = {Can Programmers Escape the Gentle Tyranny of call/return?},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {163--172},
doi = {10.1145/3397537.3397546},
year = {2020},
}
Publisher's Version
Info
<Programming'20> Companion Companion '20: "Supporting the Composition ..."
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.
@InProceedings{<Programming'20> Companion20p17,
author = {Brigitte Boden and Robert Mischke and Alexander Weinert and Andreas Schreiber},
title = {Supporting the Composition of Domain-Specific Software via Task-Specific Roles},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {17--18},
doi = {10.1145/3397537.3399576},
year = {2020},
}
Publisher's Version
Info
<Programming'20> Companion Companion '20: "Towards a Dynamic Multiscale ..."
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.
@InProceedings{<Programming'20> Companion20p136,
author = {Amy Rae Fox and Philip Guo and Clemens Nylandsted Klokmose and Peter Dalsgaard and Arvind Satyanarayan and Haijun Xia and James D. Hollan},
title = {Towards a Dynamic Multiscale Personal Information Space: Beyond Application and Document Centered Views of Information},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {136--143},
doi = {10.1145/3397537.3397542},
year = {2020},
}
Publisher's Version
Video
Info
<Programming'20> Companion Companion '20: "Towards a Pattern Language ..."
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.
@InProceedings{<Programming'20> Companion20p102,
author = {Tao Dong and Gale Yang},
title = {Towards a Pattern Language for Interactive Coding Tutorials},
booktitle = {Proc.\ <Programming'20> Companion},
publisher = {ACM},
pages = {102--105},
doi = {10.1145/3397537.3397558},
year = {2020},
}
Publisher's Version