<Programming 2018> Companion
2nd International Conference on the Art, Science, and Engineering of Programming (<Programming> 2018 Companion)
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 2018> Companion – Advance Table of Contents

Contents - Abstracts - Authors


Title Page

Welcome from the General Chair

2018 7th International Workshop on Bidirectional Transformations (Bx 2018)

2018 2nd International Workshop on Modern Language Runtimes, Ecosystems, and Vms (MoreVMs 2018)

2018 2nd International Workshop on Programming Technology for the Future Web (ProWeb 2018)

2018 International Workshop on Programming across the System Stack (PASS 2018)

PX/18 International Workshop on Programming Experience (PX/18)

2018 Salon des Refusés (SdR 2018)



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.
Article Search
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.

Article Search
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.
Article Search

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.
Article Search
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.
Article Search

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.
Article Search
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.
Article Search

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.
Article Search

MoreVMs 2018

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.
Article Search
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.
Article Search Info
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.
Article Search
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.
Article Search
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.
Article Search
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.
Article Search
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.
Article Search

ProWeb 2018

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.
Article Search
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.
Article Search

proc time: 3.8