Powered by
Conference Publishing Consulting
2nd International Conference on the Art, Science, and Engineering of Programming (<Programming> 2018 Companion), April 9–12, 2018, Nice, France

<Programming'18> Companion – Companion Proceedings

 Contents - Abstracts - Authors

Frontmatter

Title Page


Message from the Chairs
The International Conference on the Art, Science, and Engineering of Programming (<Programming> for short) is a new conference focused on programming topics including the experience of programming. The second edition of this conference was held during April 9-12, 2018 in Nice, France. It consisted of four days of conference, including 6 workshops, 1 compiler coding dojo (CoCoDo), 1 poster session, a student research competition, and 2 keynotes.
2018 7th International Workshop on Bidirectional Transformations (Bx 2018)
Bidirectional transformations (bx) are a mechanism for maintaining the consistency of at least two related sources of information. Such sources can be relational databases, software models and code, or any other document following standard or ad-hoc formats. Bx are an emerging topic in a wide range of research areas, with prominent presence at top conferences in several different fields (namely databases, programming languages, software engineering, and graph transformation), but with results in one field often getting limited exposure in the others. Bx 2018 is a dedicated venue for bx in all relevant fields, and is part of a workshop series that was created in order to promote cross-disciplinary research and awareness in the area. As such, since its beginning in 2012, the workshop has rotated between venues in different fields. In 2018, bx was co-located with <Programming> for the first time in Nice, France.
2018 2nd International Workshop on Modern Language Runtimes, Ecosystems, and VMs (MoreVMs 2018)
MoreVMs'18 aims to bring together industrial and academic programmers to discuss the design, implementation, and usage of modern languages and runtimes. This includes aspects such as reuse of language runtimes, modular implementation, language design and compilation strategies.
2018 2nd International Workshop on Programming Technology for the Future Web (ProWeb 2018)
It is our distinct pleasure to welcome you to ProWeb18. Full-fledged web applications have become ubiquitous on desktop and mobile devices alike. Whereas “responsive” web applications already offered a more desktop-like experience, there is an increasing demand for “rich” web applications (RIAs) that offer collaborative and even off-line functionality —Google docs being the prototypical example. Long gone are the days that web servers merely had to answer incoming HTTP request with a block of static HTML. Today’s servers react to a continuous stream of events coming from JavaScript applications that have been pushed to clients. As a result, application logic and data are increasingly distributed. Traditional dichotomies such as “client vs. server” and “offline vs. online” are fading. The 2nd International Workshop on Programming Technology for the Future Web, or ProWeb18, is a forum for researchers and practitioners to share and discuss new technology for programming these and future evolutions of the web.
2018 International Workshop on Programming across the System Stack (PASS 2018)
The landscape of computation platforms has changed dramatically in recent years. Emerging systems - such as wearable devices, smartphones, unmanned aerial vehicles, Internet of things, cloud computing servers, heterogeneous clusters, and data centers -pose a distinct set of system-oriented challenges ranging from data throughput, energy efficiency, security, real-time guarantees, to high performance. In the meantime, code quality, such as modularity or extensibility, remains a cornerstone in modern software engineering, bringing in crucial benefits such as modular reasoning, program understanding, and collaborative software development. Current methodologies and software development technologies should be revised in order to produce software to meet system-oriented goals, while preserving high internal code quality.
PX/18 International Workshop on Programming Experience (PX/18)
Imagine a software development task: some sort of requirements, specification, or goal including performance constraints and perhaps a platform and programming language. A group of developers head into a vast workroom. In that room they design and code—and sometimes they discover they need to explore the domain outside the room and the nature of potential solutions. The Programming Experience (PX) Workshop is about what happens in that room when one or a couple of programmers sit down in front of computers and produce code. Do they create text that is transformed into running behavior (the old way), or do they operate on behavior directly (“liveness”); are they exploring the live domain to understand the true nature of the requirements; are they like authors creating new worlds; does visualization matter; is the experience immediate, immersive, vivid and continuous; do fluency, literacy, and learning matter; do they build tools, meta-tools; are they creating languages to express new concepts quickly and easily; and curiously, is joy relevant to the experience? The focus of the workshop is charactering the experience of programming and considering how to improve and evolve it.
2018 Salon des Refusés (SdR 2018)
Salon des Refusés (“exhibition of rejects”) was an 1863 exhibition of artworks rejected from the official Paris Salon. It displayed works by later famous modernists such as Édouard Manet, whose paintings were rejected by the jury of the Paris Salon because they did not follow the strict rules of academic art. Many interesting ideas about programming struggle to find space in the modern programming language research community, often because they are difficult to evaluate using strict academic rules. Inspired by the Salon des Refusés, we aim to provide a space where new programming paradigms can appear.
2018 Student Research Competition
I am delighted to present the extended abstracts accepted to the ACM Student Research Competition held at the second International Conference on the Art, Science and Engineering of Programming (Programming '18).

 Info
Sponsors
Sponsors and Partners

BX 2018

Model Transformation

Confidentiality in the Process of (Model-Driven) Software Development
Michael Johnson and Perdita Stevens
(Macquarie University, Australia; University of Edinburgh, UK)
Much is now understood about how to develop software that will have good security properties in use. We claim that a topic which needs more attention, in particular from the Bx community, is security, especially confidentiality, in the software development process itself. What is then at issue is not what particular users of the software may be allowed to know, but rather, what particular developers of the software may be allowed to know. How can software development processes guarantee to respect confidentiality without compromising effective development?
The question is of general interest across software engineering, but model-driven development (MDD) seems a particularly promising arena in which to address it, because of MDD's focus on separation of concerns. In MDD, different people work with separate models, where (ideally) each model records all and only the information necessary to those who work with it. When necessary, the models are reconciled by bidirectional transformations, which automate a process which would otherwise have to be undertaken manually by the groups of experts meeting and studying both their models in order to bring them back into consistency. In model-driven development confidentiality issues become particularly clear and tractable, and bidirectional transformations have a key technical role. We hope to encourage the community to take up this challenge, and in this paper we begin our own analysis of a selection of the issues, focusing particularly on developing a threat model and some examples of secure restoration of consistency.

 Publisher's Version
Multimodel Correspondence through Inter-model Constraints
Patrick Stünkel, Harald König, Yngve Lamo, and Adrian Rutle
(Western Norway University of Applied Sciences, Norway; University of Applied Sciences FHDW Hannover, Germany)
The synchronisation of n≥ 2 heterogenously typed models requires a thorough understanding of global consistency rules. After having related these models by determining identical entities in them, we express the global rules in terms of diagrammatic predicates imposed on a comprehensive metamodel, which integrates the structural properties of all involved model spaces. If the global rules are violated, a possible subsequent consistency restoration can make use of formal descriptions for the verification of these rules. The comprehensive metamodel is constructed in the category of directed graphs. If there is an arbitrary number of related models, comprehensive artefacts can formally be represented by colimits, i.e. by universal categorical constructions. The goal of the paper is to establish a practical algorithm for this construction. The main example, a web service integration scenario from the health care domain, also shows that relating graph morphisms may be non-injective, which is incorporated into the algorithm.

 Publisher's Version
On the Development of Consistent User Interfaces (Extended Abstract)
Anthony Anjorin, Enes Yigitbas, Hermann Kaindl, and Roman Popp
(University of Paderborn, Germany; Vienna University of Technology, Austria)
User Interface (UI) development is challenging as modern UIs are expected to be available for a wide-range of diverse and constantly changing contexts including various (mobile) platforms, users, and environments. Model-Driven Engineering (MDE) principles have been successfully applied to UI development, resulting in a clear separation into multiple UI models on different levels of abstraction. While this addresses many challenges involved in UI development, it also poses an additional challenge: ensuring that all the different UI models remain consistent during their development and maintenance. In this paper, we argue that this consistency related challenge has not yet been adequately addressed, and identify consistent UI development as a new and promising application domain for existing and future research on bidirectional transformations.

 Publisher's Version

Mathematical Foundations

Cospans and Symmetric Lenses
Michael Johnson and Robert Rosebrugh
(Macquarie University, Australia; Mount Allison University, Canada)
We characterize those symmetric d-lenses which are representable as cospans of d-lenses. Such a symmetric d-lens must have unique corrs per pair of objects and satisfy two other technical conditions. When the d-lens is also ``least change'' then the corresponding cospan consists of c-lenses.

 Publisher's Version
Understanding Profunctor Optics: A Representation Theorem (Extended Abstract)
Guillaume Boisseau
(University of Oxford, UK)
Profunctor optics are composable building blocks used to define bidirectional data accessors. They form a powerful language to describe transformations of data. Unfortunately, contrary to more familiar optics like put-get lenses, profunctor optics have a complex type that makes them difficult to reason about. Moreover, linking usual optics with an equivalent profunctor representation has so far been done on a case-by-case basis, with definitions that sometimes feel very ad hoc. This makes it hard both to analyse properties of existing profunctor optics and to define new ones. This extended abstract proposes a general form for profunctor optics, and presents an equivalent representation called existential optics that is closer to intuition. This representation enables easier understanding of how profunctor optics function and are combined, as well as easier definition of useful new such optics.

 Publisher's Version

Tools and Systems

Towards a Visual Editor for Lens Combinators (Extended Abstract)
Anthony Anjorin and Hsiang-Shang Ko
(University of Paderborn, Germany; National Institute of Informatics, Japan)
Languages for programming state-based asymmetric lenses are usually based on lens combinators, whose style, having a functional programming origin, is alien to most programmers and awkward to use even for experienced functional programmers. We propose a visual syntax mimicking circuit diagrams for the combinator-based language BiGUL, provide a relational interpretation that allows the diagrams to be understood bidirectionally, and sketch how an editor for the visual syntax can help to construct, understand, and debug lens combinator programs in an intuitive and friendly way.

 Publisher's Version
Enhancing the JTL Tool for Bidirectional Transformations
Romina Eramo, Alfonso Pierantonio, and Michele Tucci
(University of L'Aquila, Italy)
In Model-Driven Engineering, the potential advantages of using bidirectional transformations in various scenarios are largely recognized; as for instance, assuring the overall consistency of a set of interrelated models which requires the capability of propagating changes back and forth the transformation chain. Among the existing approaches, JTL (Janus Transformation Language) is a constraint-based bidirectional transformation language specifically tailored to support change propagation and non-deterministic transformations. In fact, its relational and constraint-based semantics allows to restore consistency by returning all admissible models. This paper introduces the new implementation of the language and presents the tools and its features by means of a running example.

 Publisher's Version

Experience Report

A Lightweight Data Sharing System Based on Bidirectional Transformations
Adrien Duchêne, Hugues Marchal, Zhenjiang Hu, and Pierre-Yves Schobbens
(University of Namur, Belgium; National Institute of Informatics, Japan)
Although the data sharing and synchronizing problems have been raised many years ago, they remain major issues in the database community. Still, some tools are provided to end-users in order to answer some of their needs. Yet, those platforms are most likely very complicated to handle notably because they ask the user to have very much knowledge, the user sometimes being the developer. Also, most of those systems do not really insure data consistency. Our approach based on bidirectional transformations (BXs) resolves collaboration between companies having their own data structure in an easier way, guaranteeing data consistency thanks to BXs. All this means that the user does not need to know databases structure other than his and the shared mappings, and will also never be asked to use pure code or database knowledge, limiting then the complexity. In addition to this, the system profits the bidirectional transformations properties to authorize or not editing the shared data. The bidirectional functions coded in BiGUL have indeed the power to grant or not any other user in the sharing group to edit the data. Moreover, the system is extensible in the way that the user can easily join a sharing group, after providing to the bidirectional functions a GLAV mapping table matching his local structure with the shared one.

 Publisher's Version

MoreVMs 2018

Towards Practical Heterogeneous Virtual Machines
James Clarkson, Juan Fumero, Michail Papadimitriou, Maria Xekalaki, and Christos Kotselidis
(University of Manchester, UK)
Heterogeneous computing has emerged as a means to achieve high performance and energy efficiency. Naturally, this trend has been accompanied by changes in software development norms that do not necessarily favor programmers. A prime example is the two most popular heterogeneous programming languages, CUDA and OpenCL, which expose several low-level features to the API making them difficult to use by non-expert users.
Instead of using low-level programming languages, developers tend to prefer more high-level, object-oriented languages typically executed on managed runtime environments. Although many programmers might expect that such languages would have already been adapted for execution on heterogeneous hardware, the reality is that their support is either very limited or totally absent. This paper highlights the main reasons and complexities of enabling heterogeneous managed runtime systems and proposes a number of directions to address those challenges.

 Publisher's Version
Easy::Jit: Compiler Assisted Library to Enable Just-in-Time Compilation in C++ Codes
Juan Manuel Martinez Caamaño and Serge Guelton
(Quarkslab, France)
Compiled languages like C++ generally don't have access to Just-in-Time facilities, which limits the range of possible optimizations. This paper introduces an hybrid approach that combines classical ahead of time compilation with user-specified dynamic recompilation of some functions, using runtime information to improve compiled code.

 Publisher's Version Info
On the Future of Research VMs: A Hardware/Software Perspective
Foivos S. Zakkak, Andy Nisbet, John Mawer, Tim Hartley, Nikos Foutris, Orion Papadakis, Andreas Andronikakis, Iain Apreotesei, and Christos Kotselidis
(University of Manchester, UK)
In the recent years, we have witnessed an explosion of the usages of Virtual Machines (VMs) which are currently found in desktops, smartphones, and cloud deployments. These recent developments create new research opportunities in the VM domain extending from performance to energy efficiency, and scalability studies. Research into these directions necessitates research frameworks for VMs that provide full coverage of the execution domains and hardware platforms. Unfortunately, the state of the art on Research VMs does not live up to such expectations and lacks behind industrial-strength software, making it hard for the research community to provide valuable insights.
This paper presents our work in attempting to tackle those shortcomings by introducing Beehive, our vision towards a modular and seamlessly extensible ecosystem for research on virtual machines. Beehive unifies a number of existing state-of-the-art tools and components with novel ones providing a complete platform for hardware/software co-design of Virtual Machines.

 Publisher's Version
Understanding Task Granularity on the JVM: Profiling, Analysis, and Optimization
Andrea Rosà, Eduardo Rosales, Filippo Schiavio, and Walter Binder
(University of Lugano, Switzerland)
Task granularity, i.e., the amount of work performed by parallel tasks, is a key performance attribute of parallel applications. On the one hand, fine-grained tasks (i.e., small tasks carrying out few computations) may introduce considerable parallelization overheads. On the other hand, coarse-grained tasks (i.e., large tasks performing substantial computations) may not fully utilize the available CPU cores, resulting in missed parallelization opportunities. We focus on task-parallel applications running in a single Java Virtual Machine on a shared-memory multicore. Despite their performance may considerably depend on the granularity of their tasks, related analyses and optimizations have received little attention in the literature. In this paper, we advocate the need for providing a better understanding of task granularity for such applications. We discuss the importance of improving our knowledge on this topic, and highlight the related challenges. We present new approaches to profile, analyze and optimize task granularity, and discuss the results obtained so far.

 Publisher's Version
Self-Hosted Scripting in Guile
Andy Wingo
(Igalia, Spain)
Guile is a language implementation that grew out of the scripting movement in the 90s. Its initial implementation was entirely written in C. To increase the speed and expressive power of user programs written in Scheme, about 10 years ago Guile started to move to be a self-hosted compiler. Guile managed to keep the interactive, source-focussed, fast-starting aspects of scripting even while adding a sizeable Scheme compiler by making use of object file formats from the static compilation world: DWARF and ELF.

 Publisher's Version
Sulong, and Thanks for All the Fish
Manuel Rigger, Roland Schatz, Jacob Kreindl, Christian Häubl, and Hanspeter Mössenböck
(JKU Linz, Austria; Oracle Labs, Austria)
Dynamic languages rely on native extensions written in languages such as C/C++ or Fortran. To efficiently support the execution of native extensions in the multi-lingual GraalVM, we have implemented Sulong, which executes LLVM IR to support all languages that have an LLVM front end. It supports configurations with respect to memory-allocation and memory-access strategies that have different tradeoffs concerning safety and interoperability with native libraries. Recently, we have been working on balancing the tradeoffs, on supporting inline assembly and GCC compiler builtins, and on executing a complete libc on Sulong.

 Publisher's Version
The Inevitable Death of VMs: A Progress Report
Stephen Kell
(University of Cambridge, UK)
Language virtual machines (VMs), as implementation artifacts, are characterised by hard boundaries which limit their conduciveness to language interoperability, whole-system tooling, and other interactions with the `world outside'. Since the VM paradigm emerged, it has become increasingly clear that no single language or VM can succeed to the exclusion of others. This motivates a different approach in which languages are no longer implemented as VMs per se, but as participants in certain shared system-wide protocols, shared across diverse collection of languages and constituting a more porous boundary. One means of achieving such a shift is to evolve the underlying infrastructure from an essentially Unix-like environment to one that incorporates VM-like services, including memory management primitives, as a core protocol shared between many language implementations. Ongoing work towards these goals within the liballocs runtime is discussed, specifically concerning pointer identification, process-wide garbage collection, and speculative optimisations.

 Publisher's Version

ProWeb 2018

A Framework for Dynamic Inter-device Task Dispatch with Eventual Consistency
Jihyeok Park, Joonyoung Park, Yoonkyong Lee, Chul-Joo Kim, Byoungoh Kim, and Sukyoung Ryu
(KAIST, South Korea; Samsung Electronics, South Korea)
The Internet of Things (IoT) allows various things like mobile devices and electronic appliances to communicate over network. Inter-device apps can share data between devices and dispatch specific tasks to other devices to utilize their resources. The prevalence of JavaScript web apps that can run anywhere providing any browsers opens the gate to unanticipated interactions between devices. However, the current techniques require developers construct tasks to dispatch statically with strong consistency, and they do not provide any disciplined way to develop inter-device apps. In this paper, we propose IDTD (Inter-Device Task Dispatch), a framework that allows developers to construct and dispatch tasks into multiple devices dynamically with eventual consistency in a systematic manner. We provide a high-level architecture of IDTD, prove the soundness and eventual consistency of the framework, and present its practical usability.

 Publisher's Version
Scalagna 0.1: Towards Multi-tier Programming with Scala and Scala.js
Bob Reynders, Michael Greefs, Dominique Devriese, and Frank Piessens
(KU Leuven, Belgium)
In the state-of-practice, developing web applications requires dealing with multiple programming languages or codebases. To address this issue, researchers have proposed multi-tier languages such as Hop or Links that support client and server development in a single language and in one codebase. Even if such multi-tier languages are often strongly based on an existing language - for instance Hop is based on Scheme - they are new languages, and require a new compiler.
The objective of this paper is to define a multi-tier language as a library-based Scala DSL. Scala already supports compilation to both the Java VM and to JavaScript. The multi-tier language we propose in this paper, Scalagna, combines the existing Scala JVM and JavaScript ecosystems into a single programming model without requiring changes to, or rewrites of the existing Scala compilers. We discuss how this is possible using Scala's excellent support for definining DSLs, and the experimental Scala macro system. We show that Scalagna has reasonable performance, and by porting an existing Eliom application, we provide evidence that Scalagna is as expressive as other established and existing multi-tier languages.

 Publisher's Version

PASS 2018

Managing Hybrid Memories by Predicting Object Write Intensity
Shoaib Akram, Kathryn S. McKinley, Jennifer B. Sartor, and Lieven Eeckhout
(Ghent University, Belgium; Google, USA; Vrije Universiteit Brussel, Belgium)
Emerging Non-Volatile Memory (NVM) technologies offer more capacity and energy efficiency than DRAM, but their write endurance is lower and latency is higher. Hybrid memories seek the best of both worlds — scalability, efficiency, and performance — by combining DRAM and NVM. Our work proposes modifying a standard managed language runtime to allocate objects either in DRAM or NVM to maximize the use of NVM capacity without wearing it out. The key to our approach is correctly predicting highly mutated objects and allocating them in DRAM and allocating rarely mutated objects in NVM. We explore write-intensity prediction based on object (1) size, (2) class type, and (3) allocation site. We find predictions using allocation site are the most accurate. Our memory manager for hybrid memories consists of (1) an offline profiling phase that produces placement advice on a per allocation-site basis, and (2) a garbage collector that allocates mature objects in DRAM or NVM based on this advice and that allocates highly mutated nursery objects in DRAM. We explore two heuristics for classifying sites as write-intensive (DRAM) or rarely written (NVM).Write-Frequency (FREQ) uses the number of writes to objects allocated by each site. Although it can limit writes to NVM up to 1% and 3%, it allocates just 50% to 20% of mature objects in DRAM. Write-Density (DENS) computes number of writes to objects relative to object size. Write-Density is a better predictor. When it limits NVM writes to 2%, it can allocate 88% of mature objects to NVM. Pareto optimal configurations may increase writes to 10% and store 99% of mature objects in NVM. Using write-intensity predictors to proactively place objects in hybrid DRAM and NVM memory systems prolongs NVM’s lifetime while exploiting its capacity.

 Publisher's Version
Towards Safe Modular Composition of Network Functions
Matthias Eichholz, Guido Salvaneschi, and Mira Mezini
(TU Darmstadt, Germany)
Network Function Virtualization (NFV) aims to overcome the limitations of hardware middleboxes by moving network functions to software. Ultimately, this approach enables deployment into virtualized environments with higher flexibility, reducing deployment time and costs. In common industrial practice, multiple smaller network functions are often chained together into service function chains. Yet, service function chains are extremely fragile, lacking basic guarantees on correct composition and dependency reasoning. In this position paper, we propose a roadmap towards language abstractions that address this issue. We introduce the problems with current service function chaining technology and present the research program we envision.

 Publisher's Version
Applying Aspect-Oriented Change Realization in the Mobile Application Domain
Sandra Kostova and Valentino Vranić
(Slovak University of Technology in Bratislava, Slovakia)
Aspect-oriented programming makes possible to express changes in a modular way directly at the level of programming language constructs. This is particularly useful in situations that require explicit change manipulation, such as change reapplication to another version branch in application customization. However, it may be tricky to employ appropriate aspect-oriented constructs in a correct way that accommodates well the change to be implemented. This has been successfully addressed by an approach to aspect-oriented change realization based on a two-level change type model, which features a catalog of specification and implementation change types and their relationships, primarily targeting the web application domain. In this paper, we explore the applicability of the change types gathered in this catalog for the mobile application domain. For this, we performed a study that involved a set of hypothetical scenarios and two real mobile applications for Android. The study revealed that the change types known from the web application domain are in their essence applicable to the mobile application domain. It also lead to the discovery of four new specification change types in the mobile application domain and the corresponding specification--implementation change type relationships along with further relationships between known change types.

 Publisher's Version
Detecting Energy Bugs and Hotspots in Control Software using Model Checking
Pascal van Gastel, Bernard van Gastel, and Marko van Eekelen
(Avans University of Applied Sciences, Netherlands; Open University, Netherlands; Radboud University Nijmegen, Netherlands)
We explore a way to find energy deficiencies in code by model checking, both properties related to utilisation (energy hotspots) and not related to utilisation (energy bugs). Temporal logic properties (expressed using LTL) finds these deficiencies during the development of a system, employing a novel energy-inefficiency metric. The formal model is deduced from hardware specifications, a definition of utilisation and a control software application written in C. Model checking results in a set of traces (formally a counter-example) that can be related to the matching execution path in the source code by the software developer. The traces include energy footprints and enable developers to improve the energy efficiency of the application. A smart light system serves as a case study to evaluate the proposed approach.

 Publisher's Version

PX/18

Attention Patterns for Code Animations: Using Eye Trackers to Evaluate Dynamic Code Presentation Techniques
Louis Spinelli, Maulishree Pandey, and Steve Oney
(University of Washington, USA; University of Michigan, USA)
Programming instructors seek new ways to present code to novice programmers. It is important to understand how these new presentation methods affect students. We prototyped three different ways to animate the presentation of code. We used eye-tracking technology to observe participants as they were presented with animations and completed three activities: code summarization, syntax error correction, and logic error correction. The prototypes, our method for observation, and our analysis methods were each informed by previous research. We observed variation in how participants consumed animations. Our initial results indicate that viewing animations of a single textual representation of source code may affect the attentional processes of novice programmers during subsequent tasks.

 Publisher's Version
Reactive Programming Experience with REScala
Ragnar Mogk, Guido Salvaneschi, and Mira Mezini
(TU Darmstadt, Germany)
Reactive programming is a recent programming paradigm that specifically targets reactive applications. Over the years, a number of reactive languages have been proposed, with different combinations of features, and various target domains.
Unfortunately, there is a lack of knowledge about the experience of developing software applications with reactive languages. As a result, a number of design choices in reactive programming languages remain disconnected from experience and the applicability of reactive programming to various domains remains unclear.
To bridge this gap, we report on our experience of developing reactive applications as well as teaching reactive programming in REScala, which we collected over several years of research and practice.

 Publisher's Version
The Exploration Workspace: Interleaving the Implementation and Use of Plain Objects in Smalltalk
Patrick Rein and Robert Hirschfeld
(HPI, Germany)
When engaging in exploratory programming, the activities of exploring, understanding, implementing, and using objects of a particular domain should ideally be tightly interwoven to allow for short feedback cycles and continuous progress towards desired levels of comprehension and knowledge. However, when working with plain data objects using state-of-the-art development tools, programmers often have to resort to a more sequential workflow in which they first need to understand the model, then implement it, and only afterwards can start using and exploring it.
We propose the exploration workspace tool which enables programmers to interleave these activities to better support the exploration of objects they are not fully acquainted with. We achieve this by trying to tolerate deviations of the assumed protocol from the protocol actually provided by the objects the programmers wish to interact with. For that, we strive for non-intrusive tool support that helps to semi-automatically build up the vocabulary preferred in interactions. We also suggest to consolidate both domain object implementations and exploration scripts once learning progressed.
Through an example scenario, we will illustrate various resolution strategies applied during the implementation of a geographical map showing social media posts and photos.

 Publisher's Version
An API and Visual Environment to Use Neural Network to Reason about Source Code
Alexandre Bergel, Paulin Melatagia, and Serge Stinckwich
(University of Chile, Chile; University of Yaoundé, Cameroon; Sorbonne University, France)
Neural networks are gaining popularity in software engineering. This paper presents a dedicated API and visual environment to train and use a neural networks on software source code related data. This short paper illustrates the API using two examples involving prediction of source code properties.

 Publisher's Version
Live Programming of Internet of Things in PalCom
Alfred Åkesson, Mattias Nordahl, Görel Hedin, and Boris Magnusson
(Lund University, Sweden)
PalCom is a middleware toolkit for pervasive computing and internet-of-things. We discuss how PalCom supports exploration and live programming through three phases: exploring services, assembling them into applications, and exposing them as new services. We give an example of this workflow through the construction of a simple photo booth application.

 Publisher's Version
Do Java Programmers Write Better Python? Studying Off-Language Code Quality on GitHub
Siegfried Horschig, Toni Mattis, and Robert Hirschfeld
(HPI, Germany)
There are style guides and best practices for many programming languages. Their goal is to promote uniformity and readability of code, consequentially reducing the chance of errors.
While programmers who are frequently using the same programming language tend to internalize most of its best practices eventually, little is known about what happens when they casually switch languages and write code in a less familiar language. Insights into the factors that lead to coding convention violations could help to improve tutorials for programmers switching languages, make teachers aware of mistakes they might expect depending on what language students have been using before, or influence the order in which programming languages are taught.
To approach this question, we make use of a large-scale data set representing a major part of the open source development activity happening on GitHub. In this data set, we search for Java and C++ programmers that occasionally program Python and study their Python code quality using a lint tool.
Comparing their defect rates to those from Python programmers reveals significant effects in both directions: We observe that some of Python's best practices have more widespread adoption among Java and C++ programmers than Python experts. At the same time, python-specific coding conventions, especially indentation, scoping, and the use of semicolons, are violated more frequently.
We conclude that programming off-language is not generally associated with better or worse code quality, but individual coding conventions are violated more or less frequently depending on whether they are more universal or language-specific. We intend to motivate a discussion and more research on what causes these effects, how we can mitigate or use them for good, and which related effects can be studied using the presented data set.

 Publisher's Version
Few Versatile vs. Many Specialized Collections: How to Design a Collection Library for Exploratory Programming?
Stefan Marr and Benoit Daloze
(University of Kent, UK; JKU Linz, Austria)
While an integral part of all programming languages, the design of collection libraries is rarely studied. This work briefly reviews the collection libraries of 14 languages to identify possible design dimensions. Some languages have surprisingly few but versatile collections, while others have large libraries with many specialized collections. Based on the identified design dimensions, we argue that a small collection library with only a sequence, a map, and a set type are a suitable choice to facilitate exploratory programming. Such a design minimizes the number of decisions programmers have to make when dealing with collections, and it improves discoverability of collection operations. We further discuss techniques that make their implementation practical from a performance perspective. Based on these arguments, we conclude that languages which aim to support exploratory programming should strive for small and versatile collection libraries.

 Publisher's Version Info
Collectors
Steven Costiou, Mickaël Kerboeuf, Alain Plantec, and Marcus Denker
(CNRS, France; University of Brest, France; Inria, France; University of Lille, France)
Observing and modifying object-oriented programs often means interacting with objects. At runtime, it can be a complex task to identify those objects due to the live state of the program. Some objects may exist for only a very limited period of time, others can be hardly reachable because they are never stored in variables. To address this problem we present Collectors. They are dedicated objects which can collect objects of interest at runtime and present them to the developer. Collectors are non-intrusive, removable code instrumentations. They can be dynamically specified and injected at runtime. They expose an API to allow their specification and the access to the collected objects. In this paper, we present an implementation of Collectors in Pharo, a Smalltalk dialect. We enrich the Pharo programming and debugging environment with tools that support the Collectors API. We illustrate the use of these API and tools through the collection and the logging of specific objects in a running IOT application.

 Publisher's Version
Word Expansion Supports POSIX Shell Interactivity
Michael Greenberg
(Pomona College Claremont, USA)
The POSIX shell is the standard tool to deploy, control, and maintain systems of all kinds; the shell is used on a sliding scale from one-off commands in an interactive mode all the way to complex scripts managing, e.g., system boot sequences. For all of its utility, the POSIX shell is feared and maligned as a programming language: the shell is feared because of its incredible power, where a single command can destroy not just local but also remote systems; the shell is maligned because its semantics are non-standard, using word expansion where other languages would use evaluation.
I conjecture that word expansion is in fact an essential piece of the POSIX shell’s interactivity; word expansion is well adapted to the shell’s use cases and contributes critically to the shell’s interactive feel.

 Publisher's Version
A Non-tabular Spreadsheet with Broad Applicability
Pavel Bažant and Michaela Maršálková
We present Nezt -- a prototype of a live programming environment inspired by spreadsheets, but with a more expressive computational model. In contrast to traditional spreadsheets, cells can contain other cells in a hierarchical fashion, and one can define custom functions and use them in formulas. Our goal is to share some of the accessibility, immediacy and ease of use of spreadsheets, while achieving broad applicability, especially in the areas of application prototyping and scientific computing. The project is motivated by our own needs, but we hope it could be useful to many different types of users including advanced end-users like scientists who program as part of their work. Design influences include Excel, Lisp, JetBrains MPS and Boxer. The ultimate goal is a versatile live programming environment without the accidental complexities of mainstream professional programming.

 Publisher's Version

Salon des Refusés

Files as Directories: Some Thoughts on Accessing Structured Data within Files
Raphael Wimmer
(University of Regensburg, Germany)
This paper explores the concept of files as directories (FAD) as a unified interface to structured data within a file by representing such a file as (virtual) directory and the structured data as subdirectories and subfiles. Transparent conversion of files and their structured data into directory trees is to be handled by virtual filesystem providers. This allows for arbitrary applications and programming languages to read and write data within supported file types without the need to understand the file format - e.g., in order to modify pixel values within an image file, paragraphs in a text document, or settings in a configuration file. Advantages of this approach compared to API-mediated file access might include better learnability, modularity, explorability, synchronous access, better integration of proprietary applications, and a few other nice features. While technical issues of the FAD concept have been discussed by developers in the past, no major operating system allows FAD at the moment. In this paper I present concept, advantages, limitations, and use cases of FAD.

 Publisher's Version Info
Critique of ‘Files as Directories: Some Thoughts on Accessing Structured Data within Files’ (1)
Philip Tchernavskij
(University of Paris-Sud, France)
In this critique of Files as Directories (FAD) by Raphael Wimmer, I argue that FAD as presented applies primarily to traditional programming tasks, consider FAD as a broader subversion of app-like software, and speculate about the hypothetical design space of FAD beyond programming.

 Publisher's Version
Critique of ‘Files as Directories: Some Thoughts on Accessing Structured Data within Files’ (2)
Stephen Kell
(University of Cambridge, UK)
In this critique I argue that the motivations and direction of the `files as directories' idea are sound, but the conceptual difficulties are considerable yet non-obvious, and are not limited to those identified by the author. I highlight a selection of concerns, including Unix's latent pluralism, the blurred boundary between naming and computation in languages, and issues of bidirectionality, semantic diversity and support for economical migration.

 Publisher's Version
Lector in Codigo or The Role of the Reader
Alvaro Videla
(Durazno, Uruguay)
In this article I want to explore the relation between the process of writing computer programs with that of writing literary works of fiction. I want to see what parallels can we trace from the ideas presented by Umberto Eco in Lector in Fabula and Six Walks in the Fictional Woods, with the way we write programs today.
The goal of this article is to ask--and try to answer--the following questions: what can we learn as programmers from literary theory? What ideas can we incorporate from that discipline into our day to day programming activities, so we write code that's easier to understand for other humans (or our future selves)?

 Publisher's Version
Critique of ‘Lector in Codigo or The Role of the Reader’
Luke Church
(University of Cambridge, UK)
In 'Lector in Codigo', Videla challenges us to write for people and computers simultaneously. I examine the implications of this challenge.

 Publisher's Version
An Anatomy of Interaction: Co-occurrences and Entanglements
Antranig Basman, Philip Tchernavskij, Simon Bates, and Michel Beaudouin-Lafon
(Raising the Floor - International, UK; University of Paris-Sud, France; OCAD University, Canada)
We present a new taxonomy for describing the conditions and implementation of interactions. Current mechanisms for embedding interaction in software promote a hard separation between the programmers who produce the software, and the communities who go on to use it. In order to support open ecologies of function and fabrication, where this separation is negotiated by communities of users and designers, we need to reconceive those mechanisms. We describe interaction in two phases: Co-occurrence, the prerequisite conditions for an interaction to take place; and entanglement, the temporary coupling and interplay between elements participating in the interaction. We then sketch a blueprint of a system where those phases and their adjacent mechanisms enable communities of users to build and use interactive software. There are many ways of conceiving this new design space, and we present three dominant metaphors which we have employed so far, based on chemical reactions, quantum physics and cooking. We exhibit different systems which we have implemented based on these metaphors, and sketch how future systems will further empower citizens to design and inhabit their own interactions, express ownership over them and share them with communities of interest.

 Publisher's Version
Critique of ‘An Anatomy of Interaction: Co-occurrences and Entanglements’
Tomas Petricek
(University of Kent, UK)
The paper by Basman et al. suggests that we think about programming in terms of interaction rather than algorithms. This call needs to be interpreted in a broad sense – the idea of interaction is not just another programming abstraction, but different way of structuring our thinking about programming. This includes thinking about how users can interact with the software more generally, but also what are effective metaphorical ways of thinking about software.
In this critique, we review some of the core ideas presented by Basman et al. We consider what programming substrate might be used to implement the systems proposed by Basman et al. That is, systems that blur the boundaries between users and developers. We also review a number of systems that are technically similar to co-occurrences and entanglements and we reconsider them through the perspective of the research paradigm based on interaction.

 Publisher's Version
Semprola: A Semiotic Programming Language
Oli Sharpe
(Go Meta, UK)
Most people interested in developing new programming languages or programming environments are looking at how to improve the syntax and semantics of the program text or at tools that help make programmers more productive at crafting the program text. What we need is a more fundamental change to the conception of what a program is. This paper introduces a new, Semiotic Programming environment in which we program with signs in a context, rather than with symbols in a text file and where we treat dialogue rather than functions as the dominant organising principle of our code. All of the information held in this environment is managed in a distributed, semiotic graph that is organized into multiple ontological spaces. Taken together these enable our programs and data to have greater semantic depth. Finally the paper gives a brief introduction to Semprola, a Semiotic Programming Language that can be used in this Semiotic Programming environment.

 Publisher's Version
Critique of ‘Semprola: A Semiotic Programming Language’
Antranig Basman
(Raising the Floor - International, UK)
We supply a critique of the paper Semprola: A Semiotic Programming Language, suggesting directions in which its work of bringing semiotics to programming can be refined, and supplying opinions on areas where it may be refounded.

 Publisher's Version

Student Research Competition

Undergraduate Category

Writing Safe Smart Contracts in Flint
Franklin Schrans, Susan Eisenbach, and Sophia Drossopoulou
(Imperial College London, UK)
Blockchain-based platforms such as Ethereum support the execution of versatile decentralized applications, known as smart contracts. These typically hold and transfer digital currency (e.g., Ether) to other parties on the platform. Contracts have been subject to numerous attacks, losing hundreds of millions of dollars (in Ether). We propose Flint, a new type-safe, capabilities-secure, contract-oriented programming language specifically designed for writing robust smart contracts. To help programmers reason about access control of functions, Flint programmers use caller capabilities. To prevent vulnerabilities relating to the unintentional loss of currency, transfers of assets in Flint are performed through safe atomic operations, inspired by linear type theory.

 Publisher's Version
Fine-Grained, Dynamic Access Control for Database-Backed Applications
Ezra Zigmond
(Harvard University, USA)
Flaws in access control checks in database-backed applications frequently lead to security vulnerabilities. I present a new language, ShillDB, for writing secure, database-backed applications. ShillDB supports writing declarative database security policies as part of program interfaces, and the language runtime enforces these security policies.

 Publisher's Version
Towards an Intelligent Fault Prediction Code Editor to Improve Software Quality using Deep Learning
Vasu Jindal
(University of Texas at Dallas, USA)
Software quality assurance has become the pillar for success in software companies. High quality, low maintenance programs can be achieved if fault-prone modules can be identified early in the development lifecycle. In this paper, we propose a new intelligent Integrated Development Environment (IDE) which seamlessly allow programmers to test their code for faults using prior source code databases. Our IDE is built upon deep learning models for making recommendations. The editor also gives scores to programmers on their program design. We evaluate and validate our approach using famous NASA code repositories.

 Publisher's Version
Fully Homomorphic Encryption Scheme for Secure Computation
Alisa Gazizullina
(Innopolis University, Russia)
Nowadays, more and more organizations move their data to the cloud. When it comes to cloud computing, which is common among different industries for its speed and efficiency, data has to be decrypted to allow mathematical operations to be applied to it. Thus, in this case, the original data is seen in its plain format by the third-party service, which introduces a problem of keeping the data secret to avoid data leakages. Fully Homomorphic Encryption schemes help to address this issue by making computation applicable over ciphertexts. Most of the existent solutions, while providing good data protection require huge computational resources and produce big keys and ciphertexts. In this paper, we propose a new compact fully homomorphic encryption scheme with keys and output data which are well suited for practical use.

 Publisher's Version

Graduate Category

Sandboxed Execution of C and Other Unsafe Languages on the Java Virtual Machine
Manuel Rigger
(JKU Linz, Austria)
Sulong is a system that tackles buffer overflows and other low-level errors in languages like C by automatically checking them and aborting execution if an error is detected. Supporting unstandardized elements such as inline assembly and compiler builtins is a challenge, which we have addressed by investigating their usage in a large number of open-source programs. Finally, we have devised an introspection mechanism, for which Sulong exposes metadata such as bounds, which library writers can use to increase the robustness of their libraries.

 Publisher's Version
On the Semantics of Loop Transformation Languages
Adilla Susungi
(MINES ParisTech, France)
Languages for loop transformations have been leveraged for different type of tools and frameworks in different application domains, yet they lack formal semantics. As a step towards formal specification, this works intends to clarify the underlying concepts of such languages using a denotational approach.

 Publisher's Version
Mining Concepts from Code using Community Detection in Co-occurrence Graphs
Toni Mattis
(HPI, Germany)
Software modularity is a quality that determines how fluently individual parts (modules) of a system can vary and be understood if taken by themselves. However, modularity tends to degrade during program evolution – old concepts may get entangled with code introduced into their modules, while new concepts can be scattered over many existing modules.
In this work, we propose to infer high-level concepts and relations between them independently from the current module decomposition by exploiting the vocabulary used by programmers. Our approach uses an extensible graph-based vocabulary representation in which we detect latent communities representing our concepts. Inferred concepts can be used to support program comprehension, track architectural drift over time, and provide recommendations for related code or refactorings.

 Publisher's Version
ExtendJ: Extensible Java Compiler
Jesper Öqvist
(Lund University, Sweden)
ExtendJ (formerly JastAddJ) is an extensible Java compiler, supporting full Java source-to-bytecode compilation. ExtendJ enables researchers and developers to easily build powerful language extensions, custom static analyses, and other tools for Java. ExtendJ is built with Reference Attribute Grammars and Aspect Oriented Programming, enabling easy extension development.

 Publisher's Version
A Soup of Objects: Convenience Interfaces for Accessing Domain Objects in a Global Object Graph
Patrick Rein
(HPI, Germany)
Conventional desktop systems, such as Microsoft Windows or MacOS, are structured around applications. From a technical perspective the domain objects, such as emails or tasks, are contained within these applications. This separation of object graphs restricts interactions and integrations between applications to cases for which the original developers added support. Through the Home system we want to explore an alternative architecture for desktop systems supporting such ad-hoc integrations. This architecture is based on a single shared runtime object graph spanning all applications. We evolved and evaluated our architecture and the described mechanisms by using the resulting environment for over 13 months for everyday productivity tasks.

 Publisher's Version
DSL for End-User Service Composition
Alfred Åkesson
(Lund University, Sweden)
We present an approach for connecting and coordinating distributed devices with different capabilities. More specifically, our research focuses on the design of an domain specific language that allows end-users to coordinate devices in pervasive systems.

 Publisher's Version
Debugging Support for Big Data Processing Applications
Matteo Marra
(Vrije Universiteit Brussel, Belgium)
Current trends in Big Data processing indicate that the volume, velocity and variety of data are increasing quickly due to an explosion on diversity and number of sources of information. This poses challenges for Big Data frameworks to be able to meet the new requirements of the emerging real-time streaming data processing applications. This research project focuses on the academic study of integrated development environments and debugging tools to assist the software development of Big Data applications.

 Publisher's Version
Indigenizing Computer Programming for Cultural Maintenance
Jon M. R. Corbett
(University of British Columbia, Canada)
This paper presents the concept of a culturally and domain specific natural language processing framework. The Indigenous Digital Media Toolkit (IDMT) is a programming language with a specialized user interface that uses the Cree language and syllabic writing system to programmatically create digital artworks and provides a digital foundation for the maintenance and/or revitalization of Indigenous culture.

 Publisher's Version

proc time: 10.46