<Programming'18> Companion – Author Index |
Contents -
Abstracts -
Authors
|
A B C D E F G H J K L M N O P R S T V W X Y Z
| Åkesson, Alfred |
<Programming'18> Companion Companion '18: "Live Programming of Internet ..."
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. 
@InProceedings{<Programming'18> Companion18p121,
author = {Alfred Åkesson and Mattias Nordahl and Görel Hedin and Boris Magnusson},
title = {Live Programming of Internet of Things in PalCom},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {121--126},
doi = {10.1145/3191697.3214342},
year = {2018},
}
 Publisher's Version
<Programming'18> Companion Companion '18: "DSL for End-User Service Composition ..."
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.
@InProceedings{<Programming'18> Companion18p239,
author = {Alfred Åkesson},
title = {DSL for End-User Service Composition},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {239--240},
doi = {10.1145/3191697.3213800},
year = {2018},
}
Publisher's Version
|
|
| Akram, Shoaib |
<Programming'18> Companion Companion '18: "Managing Hybrid Memories by ..."
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.
@InProceedings{<Programming'18> Companion18p75,
author = {Shoaib Akram and Kathryn S. McKinley and Jennifer B. Sartor and Lieven Eeckhout},
title = {Managing Hybrid Memories by Predicting Object Write Intensity},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {75--80},
doi = {10.1145/3191697.3213803},
year = {2018},
}
Publisher's Version
|
|
| Andronikakis, Andreas |
<Programming'18> Companion Companion '18: "On the Future of Research ..."
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.
@InProceedings{<Programming'18> Companion18p51,
author = {Foivos S. Zakkak and Andy Nisbet and John Mawer and Tim Hartley and Nikos Foutris and Orion Papadakis and Andreas Andronikakis and Iain Apreotesei and Christos Kotselidis},
title = {On the Future of Research VMs: A Hardware/Software Perspective},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {51--53},
doi = {10.1145/3191697.3191729},
year = {2018},
}
Publisher's Version
|
|
| Anjorin, Anthony |
<Programming'18> Companion Companion '18: "On the Development of Consistent ..."
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.
@InProceedings{<Programming'18> Companion18p18,
author = {Anthony Anjorin and Enes Yigitbas and Hermann Kaindl and Roman Popp},
title = {On the Development of Consistent User Interfaces (Extended Abstract)},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {18--20},
doi = {10.1145/3191697.3191716},
year = {2018},
}
Publisher's Version
<Programming'18> Companion Companion '18: "Towards a Visual Editor for ..."
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.
@InProceedings{<Programming'18> Companion18p33,
author = {Anthony Anjorin and Hsiang-Shang Ko},
title = {Towards a Visual Editor for Lens Combinators (Extended Abstract)},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {33--35},
doi = {10.1145/3191697.3191719},
year = {2018},
}
Publisher's Version
|
|
| Apreotesei, Iain |
<Programming'18> Companion Companion '18: "On the Future of Research ..."
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.
@InProceedings{<Programming'18> Companion18p51,
author = {Foivos S. Zakkak and Andy Nisbet and John Mawer and Tim Hartley and Nikos Foutris and Orion Papadakis and Andreas Andronikakis and Iain Apreotesei and Christos Kotselidis},
title = {On the Future of Research VMs: A Hardware/Software Perspective},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {51--53},
doi = {10.1145/3191697.3191729},
year = {2018},
}
Publisher's Version
|
|
| Basman, Antranig |
<Programming'18> Companion Companion '18: "An Anatomy of Interaction: ..."
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.
@InProceedings{<Programming'18> Companion18p188,
author = {Antranig Basman and Philip Tchernavskij and Simon Bates and Michel Beaudouin-Lafon},
title = {An Anatomy of Interaction: Co-occurrences and Entanglements},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {188--196},
doi = {10.1145/3191697.3214328},
year = {2018},
}
Publisher's Version
<Programming'18> Companion Companion '18: "Critique of ‘Semprola: A ..."
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.
@InProceedings{<Programming'18> Companion18p214,
author = {Antranig Basman},
title = {Critique of ‘Semprola: A Semiotic Programming Language’},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {214--217},
doi = {10.1145/3191697.3214331},
year = {2018},
}
Publisher's Version
|
|
| Bates, Simon |
<Programming'18> Companion Companion '18: "An Anatomy of Interaction: ..."
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.
@InProceedings{<Programming'18> Companion18p188,
author = {Antranig Basman and Philip Tchernavskij and Simon Bates and Michel Beaudouin-Lafon},
title = {An Anatomy of Interaction: Co-occurrences and Entanglements},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {188--196},
doi = {10.1145/3191697.3214328},
year = {2018},
}
Publisher's Version
|
|
| Bažant, Pavel |
<Programming'18> Companion Companion '18: "A Non-tabular Spreadsheet ..."
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.
@InProceedings{<Programming'18> Companion18p161,
author = {Pavel Bažant and Michaela Maršálková},
title = {A Non-tabular Spreadsheet with Broad Applicability},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {161--165},
doi = {10.1145/3191697.3214343},
year = {2018},
}
Publisher's Version
|
|
| Beaudouin-Lafon, Michel |
<Programming'18> Companion Companion '18: "An Anatomy of Interaction: ..."
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.
@InProceedings{<Programming'18> Companion18p188,
author = {Antranig Basman and Philip Tchernavskij and Simon Bates and Michel Beaudouin-Lafon},
title = {An Anatomy of Interaction: Co-occurrences and Entanglements},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {188--196},
doi = {10.1145/3191697.3214328},
year = {2018},
}
Publisher's Version
|
|
| Bergel, Alexandre |
<Programming'18> Companion Companion '18: "An API and Visual Environment ..."
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.
@InProceedings{<Programming'18> Companion18p117,
author = {Alexandre Bergel and Paulin Melatagia and Serge Stinckwich},
title = {An API and Visual Environment to Use Neural Network to Reason about Source Code},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {117--120},
doi = {10.1145/3191697.3214340},
year = {2018},
}
Publisher's Version
|
|
| Binder, Walter |
<Programming'18> Companion Companion '18: "Understanding Task Granularity ..."
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.
@InProceedings{<Programming'18> Companion18p54,
author = {Andrea Rosà and Eduardo Rosales and Filippo Schiavio and Walter Binder},
title = {Understanding Task Granularity on the JVM: Profiling, Analysis, and Optimization},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {54--56},
doi = {10.1145/3191697.3191724},
year = {2018},
}
Publisher's Version
|
|
| Boisseau, Guillaume |
<Programming'18> Companion Companion '18: "Understanding Profunctor Optics: ..."
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.
@InProceedings{<Programming'18> Companion18p30,
author = {Guillaume Boisseau},
title = {Understanding Profunctor Optics: A Representation Theorem (Extended Abstract)},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {30--32},
doi = {10.1145/3191697.3191718},
year = {2018},
}
Publisher's Version
|
|
| Caamaño, Juan Manuel Martinez |
<Programming'18> Companion Companion '18: "Easy::Jit: Compiler Assisted ..."
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.
@InProceedings{<Programming'18> Companion18p49,
author = {Juan Manuel Martinez Caamaño and Serge Guelton},
title = {Easy::Jit: Compiler Assisted Library to Enable Just-in-Time Compilation in C++ Codes},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {49--50},
doi = {10.1145/3191697.3191725},
year = {2018},
}
Publisher's Version
 Info
|
|
| Church, Luke |
<Programming'18> Companion Companion '18: "Critique of ‘Lector in Codigo ..."
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.
@InProceedings{<Programming'18> Companion18p187,
author = {Luke Church},
title = {Critique of ‘Lector in Codigo or The Role of the Reader’},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {187--187},
doi = {10.1145/3191697.3214327},
year = {2018},
}
Publisher's Version
|
|
| Clarkson, James |
<Programming'18> Companion Companion '18: "Towards Practical Heterogeneous ..."
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.
@InProceedings{<Programming'18> Companion18p46,
author = {James Clarkson and Juan Fumero and Michail Papadimitriou and Maria Xekalaki and Christos Kotselidis},
title = {Towards Practical Heterogeneous Virtual Machines},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {46--48},
doi = {10.1145/3191697.3191730},
year = {2018},
}
Publisher's Version
|
|
| Corbett, Jon M. R. |
<Programming'18> Companion Companion '18: "Indigenizing Computer Programming ..."
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.
@InProceedings{<Programming'18> Companion18p243,
author = {Jon M. R. Corbett},
title = {Indigenizing Computer Programming for Cultural Maintenance},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {243--244},
doi = {10.1145/3191697.3213802},
year = {2018},
}
Publisher's Version
|
|
| Costiou, Steven |
<Programming'18> Companion Companion '18: "Collectors ..."
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.
@InProceedings{<Programming'18> Companion18p144,
author = {Steven Costiou and Mickaël Kerboeuf and Alain Plantec and Marcus Denker},
title = {Collectors},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {144--152},
doi = {10.1145/3191697.3214335},
year = {2018},
}
Publisher's Version
|
|
| Daloze, Benoit |
<Programming'18> Companion Companion '18: "Few Versatile vs. Many Specialized ..."
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.
@InProceedings{<Programming'18> Companion18p135,
author = {Stefan Marr and Benoit Daloze},
title = {Few Versatile vs. Many Specialized Collections: How to Design a Collection Library for Exploratory Programming?},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {135--143},
doi = {10.1145/3191697.3214334},
year = {2018},
}
Publisher's Version
Info
|
|
| Denker, Marcus |
<Programming'18> Companion Companion '18: "Collectors ..."
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.
@InProceedings{<Programming'18> Companion18p144,
author = {Steven Costiou and Mickaël Kerboeuf and Alain Plantec and Marcus Denker},
title = {Collectors},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {144--152},
doi = {10.1145/3191697.3214335},
year = {2018},
}
Publisher's Version
|
|
| Devriese, Dominique |
<Programming'18> Companion Companion '18: "Scalagna 0.1: Towards Multi-tier ..."
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.
@InProceedings{<Programming'18> Companion18p69,
author = {Bob Reynders and Michael Greefs and Dominique Devriese and Frank Piessens},
title = {Scalagna 0.1: Towards Multi-tier Programming with Scala and Scala.js},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {69--74},
doi = {10.1145/3191697.3191731},
year = {2018},
}
Publisher's Version
|
|
| Drossopoulou, Sophia |
<Programming'18> Companion Companion '18: "Writing Safe Smart Contracts ..."
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.
@InProceedings{<Programming'18> Companion18p218,
author = {Franklin Schrans and Susan Eisenbach and Sophia Drossopoulou},
title = {Writing Safe Smart Contracts in Flint},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {218--219},
doi = {10.1145/3191697.3213790},
year = {2018},
}
Publisher's Version
|
|
| Duchêne, Adrien |
<Programming'18> Companion Companion '18: "A Lightweight Data Sharing ..."
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.
@InProceedings{<Programming'18> Companion18p42,
author = {Adrien Duchêne and Hugues Marchal and Zhenjiang Hu and Pierre-Yves Schobbens},
title = {A Lightweight Data Sharing System Based on Bidirectional Transformations},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {42--45},
doi = {10.1145/3191697.3191722},
year = {2018},
}
Publisher's Version
|
|
| Eeckhout, Lieven |
<Programming'18> Companion Companion '18: "Managing Hybrid Memories by ..."
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.
@InProceedings{<Programming'18> Companion18p75,
author = {Shoaib Akram and Kathryn S. McKinley and Jennifer B. Sartor and Lieven Eeckhout},
title = {Managing Hybrid Memories by Predicting Object Write Intensity},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {75--80},
doi = {10.1145/3191697.3213803},
year = {2018},
}
Publisher's Version
|
|
| Eekelen, Marko van |
<Programming'18> Companion Companion '18: "Detecting Energy Bugs and ..."
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.
@InProceedings{<Programming'18> Companion18p93,
author = {Pascal van Gastel and Bernard van Gastel and Marko van Eekelen},
title = {Detecting Energy Bugs and Hotspots in Control Software using Model Checking},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {93--98},
doi = {10.1145/3191697.3213805},
year = {2018},
}
Publisher's Version
|
|
| Eichholz, Matthias |
<Programming'18> Companion Companion '18: "Towards Safe Modular Composition ..."
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.
@InProceedings{<Programming'18> Companion18p81,
author = {Matthias Eichholz and Guido Salvaneschi and Mira Mezini},
title = {Towards Safe Modular Composition of Network Functions},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {81--86},
doi = {10.1145/3191697.3213804},
year = {2018},
}
Publisher's Version
|
|
| Eisenbach, Susan |
<Programming'18> Companion Companion '18: "Writing Safe Smart Contracts ..."
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.
@InProceedings{<Programming'18> Companion18p218,
author = {Franklin Schrans and Susan Eisenbach and Sophia Drossopoulou},
title = {Writing Safe Smart Contracts in Flint},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {218--219},
doi = {10.1145/3191697.3213790},
year = {2018},
}
Publisher's Version
|
|
| Eramo, Romina |
<Programming'18> Companion Companion '18: "Enhancing the JTL Tool for ..."
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.
@InProceedings{<Programming'18> Companion18p36,
author = {Romina Eramo and Alfonso Pierantonio and Michele Tucci},
title = {Enhancing the JTL Tool for Bidirectional Transformations},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {36--41},
doi = {10.1145/3191697.3191720},
year = {2018},
}
Publisher's Version
|
|
| Foutris, Nikos |
<Programming'18> Companion Companion '18: "On the Future of Research ..."
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.
@InProceedings{<Programming'18> Companion18p51,
author = {Foivos S. Zakkak and Andy Nisbet and John Mawer and Tim Hartley and Nikos Foutris and Orion Papadakis and Andreas Andronikakis and Iain Apreotesei and Christos Kotselidis},
title = {On the Future of Research VMs: A Hardware/Software Perspective},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {51--53},
doi = {10.1145/3191697.3191729},
year = {2018},
}
Publisher's Version
|
|
| Fumero, Juan |
<Programming'18> Companion Companion '18: "Towards Practical Heterogeneous ..."
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.
@InProceedings{<Programming'18> Companion18p46,
author = {James Clarkson and Juan Fumero and Michail Papadimitriou and Maria Xekalaki and Christos Kotselidis},
title = {Towards Practical Heterogeneous Virtual Machines},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {46--48},
doi = {10.1145/3191697.3191730},
year = {2018},
}
Publisher's Version
|
|
| Gastel, Bernard van |
<Programming'18> Companion Companion '18: "Detecting Energy Bugs and ..."
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.
@InProceedings{<Programming'18> Companion18p93,
author = {Pascal van Gastel and Bernard van Gastel and Marko van Eekelen},
title = {Detecting Energy Bugs and Hotspots in Control Software using Model Checking},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {93--98},
doi = {10.1145/3191697.3213805},
year = {2018},
}
Publisher's Version
|
|
| Gastel, Pascal van |
<Programming'18> Companion Companion '18: "Detecting Energy Bugs and ..."
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.
@InProceedings{<Programming'18> Companion18p93,
author = {Pascal van Gastel and Bernard van Gastel and Marko van Eekelen},
title = {Detecting Energy Bugs and Hotspots in Control Software using Model Checking},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {93--98},
doi = {10.1145/3191697.3213805},
year = {2018},
}
Publisher's Version
|
|
| Gazizullina, Alisa |
<Programming'18> Companion Companion '18: "Fully Homomorphic Encryption ..."
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.
@InProceedings{<Programming'18> Companion18p224,
author = {Alisa Gazizullina},
title = {Fully Homomorphic Encryption Scheme for Secure Computation},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {224--226},
doi = {10.1145/3191697.3213794},
year = {2018},
}
Publisher's Version
|
|
| Greefs, Michael |
<Programming'18> Companion Companion '18: "Scalagna 0.1: Towards Multi-tier ..."
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.
@InProceedings{<Programming'18> Companion18p69,
author = {Bob Reynders and Michael Greefs and Dominique Devriese and Frank Piessens},
title = {Scalagna 0.1: Towards Multi-tier Programming with Scala and Scala.js},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {69--74},
doi = {10.1145/3191697.3191731},
year = {2018},
}
Publisher's Version
|
|
| Greenberg, Michael |
<Programming'18> Companion Companion '18: "Word Expansion Supports POSIX ..."
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.
@InProceedings{<Programming'18> Companion18p153,
author = {Michael Greenberg},
title = {Word Expansion Supports POSIX Shell Interactivity},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {153--160},
doi = {10.1145/3191697.3214336},
year = {2018},
}
Publisher's Version
|
|
| Guelton, Serge |
<Programming'18> Companion Companion '18: "Easy::Jit: Compiler Assisted ..."
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.
@InProceedings{<Programming'18> Companion18p49,
author = {Juan Manuel Martinez Caamaño and Serge Guelton},
title = {Easy::Jit: Compiler Assisted Library to Enable Just-in-Time Compilation in C++ Codes},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {49--50},
doi = {10.1145/3191697.3191725},
year = {2018},
}
Publisher's Version
Info
|
|
| Hartley, Tim |
<Programming'18> Companion Companion '18: "On the Future of Research ..."
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.
@InProceedings{<Programming'18> Companion18p51,
author = {Foivos S. Zakkak and Andy Nisbet and John Mawer and Tim Hartley and Nikos Foutris and Orion Papadakis and Andreas Andronikakis and Iain Apreotesei and Christos Kotselidis},
title = {On the Future of Research VMs: A Hardware/Software Perspective},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {51--53},
doi = {10.1145/3191697.3191729},
year = {2018},
}
Publisher's Version
|
|
| Häubl, Christian |
<Programming'18> Companion Companion '18: "Sulong, and Thanks for All ..."
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.
@InProceedings{<Programming'18> Companion18p58,
author = {Manuel Rigger and Roland Schatz and Jacob Kreindl and Christian Häubl and Hanspeter Mössenböck},
title = {Sulong, and Thanks for All the Fish},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {58--60},
doi = {10.1145/3191697.3191726},
year = {2018},
}
Publisher's Version
|
|
| Hedin, Görel |
<Programming'18> Companion Companion '18: "Live Programming of Internet ..."
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.
@InProceedings{<Programming'18> Companion18p121,
author = {Alfred Åkesson and Mattias Nordahl and Görel Hedin and Boris Magnusson},
title = {Live Programming of Internet of Things in PalCom},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {121--126},
doi = {10.1145/3191697.3214342},
year = {2018},
}
Publisher's Version
|
|
| Hirschfeld, Robert |
<Programming'18> Companion Companion '18: "The Exploration Workspace: ..."
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.
@InProceedings{<Programming'18> Companion18p113,
author = {Patrick Rein and Robert Hirschfeld},
title = {The Exploration Workspace: Interleaving the Implementation and Use of Plain Objects in Smalltalk},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {113--116},
doi = {10.1145/3191697.3214339},
year = {2018},
}
Publisher's Version
<Programming'18> Companion Companion '18: "Do Java Programmers Write ..."
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.
@InProceedings{<Programming'18> Companion18p127,
author = {Siegfried Horschig and Toni Mattis and Robert Hirschfeld},
title = {Do Java Programmers Write Better Python? Studying Off-Language Code Quality on GitHub},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {127--134},
doi = {10.1145/3191697.3214341},
year = {2018},
}
Publisher's Version
|
|
| Horschig, Siegfried |
<Programming'18> Companion Companion '18: "Do Java Programmers Write ..."
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.
@InProceedings{<Programming'18> Companion18p127,
author = {Siegfried Horschig and Toni Mattis and Robert Hirschfeld},
title = {Do Java Programmers Write Better Python? Studying Off-Language Code Quality on GitHub},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {127--134},
doi = {10.1145/3191697.3214341},
year = {2018},
}
Publisher's Version
|
|
| Hu, Zhenjiang |
<Programming'18> Companion Companion '18: "A Lightweight Data Sharing ..."
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.
@InProceedings{<Programming'18> Companion18p42,
author = {Adrien Duchêne and Hugues Marchal and Zhenjiang Hu and Pierre-Yves Schobbens},
title = {A Lightweight Data Sharing System Based on Bidirectional Transformations},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {42--45},
doi = {10.1145/3191697.3191722},
year = {2018},
}
Publisher's Version
|
|
| Jindal, Vasu |
<Programming'18> Companion Companion '18: "Towards an Intelligent Fault ..."
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.
@InProceedings{<Programming'18> Companion18p222,
author = {Vasu Jindal},
title = {Towards an Intelligent Fault Prediction Code Editor to Improve Software Quality using Deep Learning},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {222--223},
doi = {10.1145/3191697.3213793},
year = {2018},
}
Publisher's Version
|
|
| Johnson, Michael |
<Programming'18> Companion Companion '18: "Confidentiality in the Process ..."
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.
@InProceedings{<Programming'18> Companion18p1,
author = {Michael Johnson and Perdita Stevens},
title = {Confidentiality in the Process of (Model-Driven) Software Development},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {1--8},
doi = {10.1145/3191697.3191714},
year = {2018},
}
Publisher's Version
<Programming'18> Companion Companion '18: "Cospans and Symmetric Lenses ..."
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.
@InProceedings{<Programming'18> Companion18p21,
author = {Michael Johnson and Robert Rosebrugh},
title = {Cospans and Symmetric Lenses},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {21--29},
doi = {10.1145/3191697.3191717},
year = {2018},
}
Publisher's Version
|
|
| Kaindl, Hermann |
<Programming'18> Companion Companion '18: "On the Development of Consistent ..."
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.
@InProceedings{<Programming'18> Companion18p18,
author = {Anthony Anjorin and Enes Yigitbas and Hermann Kaindl and Roman Popp},
title = {On the Development of Consistent User Interfaces (Extended Abstract)},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {18--20},
doi = {10.1145/3191697.3191716},
year = {2018},
}
Publisher's Version
|
|
| Kell, Stephen |
<Programming'18> Companion Companion '18: "The Inevitable Death of VMs: ..."
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.
@InProceedings{<Programming'18> Companion18p61,
author = {Stephen Kell},
title = {The Inevitable Death of VMs: A Progress Report},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {61--62},
doi = {10.1145/3191697.3191728},
year = {2018},
}
Publisher's Version
<Programming'18> Companion Companion '18: "Critique of ‘Files as Directories: ..."
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.
@InProceedings{<Programming'18> Companion18p175,
author = {Stephen Kell},
title = {Critique of ‘Files as Directories: Some Thoughts on Accessing Structured Data within Files’ (2)},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {175--179},
doi = {10.1145/3191697.3214325},
year = {2018},
}
Publisher's Version
|
|
| Kerboeuf, Mickaël |
<Programming'18> Companion Companion '18: "Collectors ..."
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.
@InProceedings{<Programming'18> Companion18p144,
author = {Steven Costiou and Mickaël Kerboeuf and Alain Plantec and Marcus Denker},
title = {Collectors},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {144--152},
doi = {10.1145/3191697.3214335},
year = {2018},
}
Publisher's Version
|
|
| Kim, Byoungoh |
<Programming'18> Companion Companion '18: "A Framework for Dynamic Inter-device ..."
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.
@InProceedings{<Programming'18> Companion18p63,
author = {Jihyeok Park and Joonyoung Park and Yoonkyong Lee and Chul-Joo Kim and Byoungoh Kim and Sukyoung Ryu},
title = {A Framework for Dynamic Inter-device Task Dispatch with Eventual Consistency},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {63--68},
doi = {10.1145/3191697.3191732},
year = {2018},
}
Publisher's Version
|
|
| Kim, Chul-Joo |
<Programming'18> Companion Companion '18: "A Framework for Dynamic Inter-device ..."
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.
@InProceedings{<Programming'18> Companion18p63,
author = {Jihyeok Park and Joonyoung Park and Yoonkyong Lee and Chul-Joo Kim and Byoungoh Kim and Sukyoung Ryu},
title = {A Framework for Dynamic Inter-device Task Dispatch with Eventual Consistency},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {63--68},
doi = {10.1145/3191697.3191732},
year = {2018},
}
Publisher's Version
|
|
| Ko, Hsiang-Shang |
<Programming'18> Companion Companion '18: "Towards a Visual Editor for ..."
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.
@InProceedings{<Programming'18> Companion18p33,
author = {Anthony Anjorin and Hsiang-Shang Ko},
title = {Towards a Visual Editor for Lens Combinators (Extended Abstract)},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {33--35},
doi = {10.1145/3191697.3191719},
year = {2018},
}
Publisher's Version
|
|
| König, Harald |
<Programming'18> Companion Companion '18: "Multimodel Correspondence ..."
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.
@InProceedings{<Programming'18> Companion18p9,
author = {Patrick Stünkel and Harald König and Yngve Lamo and Adrian Rutle},
title = {Multimodel Correspondence through Inter-model Constraints},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {9--17},
doi = {10.1145/3191697.3191715},
year = {2018},
}
Publisher's Version
|
|
| Kostova, Sandra |
<Programming'18> Companion Companion '18: "Applying Aspect-Oriented Change ..."
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.
@InProceedings{<Programming'18> Companion18p87,
author = {Sandra Kostova and Valentino Vranić},
title = {Applying Aspect-Oriented Change Realization in the Mobile Application Domain},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {87--92},
doi = {10.1145/3191697.3213806},
year = {2018},
}
Publisher's Version
|
|
| Kotselidis, Christos |
<Programming'18> Companion Companion '18: "Towards Practical Heterogeneous ..."
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.
@InProceedings{<Programming'18> Companion18p46,
author = {James Clarkson and Juan Fumero and Michail Papadimitriou and Maria Xekalaki and Christos Kotselidis},
title = {Towards Practical Heterogeneous Virtual Machines},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {46--48},
doi = {10.1145/3191697.3191730},
year = {2018},
}
Publisher's Version
<Programming'18> Companion Companion '18: "On the Future of Research ..."
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.
@InProceedings{<Programming'18> Companion18p51,
author = {Foivos S. Zakkak and Andy Nisbet and John Mawer and Tim Hartley and Nikos Foutris and Orion Papadakis and Andreas Andronikakis and Iain Apreotesei and Christos Kotselidis},
title = {On the Future of Research VMs: A Hardware/Software Perspective},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {51--53},
doi = {10.1145/3191697.3191729},
year = {2018},
}
Publisher's Version
|
|
| Kreindl, Jacob |
<Programming'18> Companion Companion '18: "Sulong, and Thanks for All ..."
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.
@InProceedings{<Programming'18> Companion18p58,
author = {Manuel Rigger and Roland Schatz and Jacob Kreindl and Christian Häubl and Hanspeter Mössenböck},
title = {Sulong, and Thanks for All the Fish},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {58--60},
doi = {10.1145/3191697.3191726},
year = {2018},
}
Publisher's Version
|
|
| Lamo, Yngve |
<Programming'18> Companion Companion '18: "Multimodel Correspondence ..."
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.
@InProceedings{<Programming'18> Companion18p9,
author = {Patrick Stünkel and Harald König and Yngve Lamo and Adrian Rutle},
title = {Multimodel Correspondence through Inter-model Constraints},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {9--17},
doi = {10.1145/3191697.3191715},
year = {2018},
}
Publisher's Version
|
|
| Lee, Yoonkyong |
<Programming'18> Companion Companion '18: "A Framework for Dynamic Inter-device ..."
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.
@InProceedings{<Programming'18> Companion18p63,
author = {Jihyeok Park and Joonyoung Park and Yoonkyong Lee and Chul-Joo Kim and Byoungoh Kim and Sukyoung Ryu},
title = {A Framework for Dynamic Inter-device Task Dispatch with Eventual Consistency},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {63--68},
doi = {10.1145/3191697.3191732},
year = {2018},
}
Publisher's Version
|
|
| Magnusson, Boris |
<Programming'18> Companion Companion '18: "Live Programming of Internet ..."
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.
@InProceedings{<Programming'18> Companion18p121,
author = {Alfred Åkesson and Mattias Nordahl and Görel Hedin and Boris Magnusson},
title = {Live Programming of Internet of Things in PalCom},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {121--126},
doi = {10.1145/3191697.3214342},
year = {2018},
}
Publisher's Version
|
|
| Marchal, Hugues |
<Programming'18> Companion Companion '18: "A Lightweight Data Sharing ..."
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.
@InProceedings{<Programming'18> Companion18p42,
author = {Adrien Duchêne and Hugues Marchal and Zhenjiang Hu and Pierre-Yves Schobbens},
title = {A Lightweight Data Sharing System Based on Bidirectional Transformations},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {42--45},
doi = {10.1145/3191697.3191722},
year = {2018},
}
Publisher's Version
|
|
| Marr, Stefan |
<Programming'18> Companion Companion '18: "Few Versatile vs. Many Specialized ..."
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.
@InProceedings{<Programming'18> Companion18p135,
author = {Stefan Marr and Benoit Daloze},
title = {Few Versatile vs. Many Specialized Collections: How to Design a Collection Library for Exploratory Programming?},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {135--143},
doi = {10.1145/3191697.3214334},
year = {2018},
}
Publisher's Version
Info
|
|
| Marra, Matteo |
<Programming'18> Companion Companion '18: "Debugging Support for Big ..."
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.
@InProceedings{<Programming'18> Companion18p241,
author = {Matteo Marra},
title = {Debugging Support for Big Data Processing Applications},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {241--242},
doi = {10.1145/3191697.3213801},
year = {2018},
}
Publisher's Version
|
|
| Maršálková, Michaela |
<Programming'18> Companion Companion '18: "A Non-tabular Spreadsheet ..."
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.
@InProceedings{<Programming'18> Companion18p161,
author = {Pavel Bažant and Michaela Maršálková},
title = {A Non-tabular Spreadsheet with Broad Applicability},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {161--165},
doi = {10.1145/3191697.3214343},
year = {2018},
}
Publisher's Version
|
|
| Mattis, Toni |
<Programming'18> Companion Companion '18: "Do Java Programmers Write ..."
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.
@InProceedings{<Programming'18> Companion18p127,
author = {Siegfried Horschig and Toni Mattis and Robert Hirschfeld},
title = {Do Java Programmers Write Better Python? Studying Off-Language Code Quality on GitHub},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {127--134},
doi = {10.1145/3191697.3214341},
year = {2018},
}
Publisher's Version
<Programming'18> Companion Companion '18: "Mining Concepts from Code ..."
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.
@InProceedings{<Programming'18> Companion18p232,
author = {Toni Mattis},
title = {Mining Concepts from Code using Community Detection in Co-occurrence Graphs},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {232--233},
doi = {10.1145/3191697.3213797},
year = {2018},
}
Publisher's Version
|
|
| Mawer, John |
<Programming'18> Companion Companion '18: "On the Future of Research ..."
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.
@InProceedings{<Programming'18> Companion18p51,
author = {Foivos S. Zakkak and Andy Nisbet and John Mawer and Tim Hartley and Nikos Foutris and Orion Papadakis and Andreas Andronikakis and Iain Apreotesei and Christos Kotselidis},
title = {On the Future of Research VMs: A Hardware/Software Perspective},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {51--53},
doi = {10.1145/3191697.3191729},
year = {2018},
}
Publisher's Version
|
|
| McKinley, Kathryn S. |
<Programming'18> Companion Companion '18: "Managing Hybrid Memories by ..."
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.
@InProceedings{<Programming'18> Companion18p75,
author = {Shoaib Akram and Kathryn S. McKinley and Jennifer B. Sartor and Lieven Eeckhout},
title = {Managing Hybrid Memories by Predicting Object Write Intensity},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {75--80},
doi = {10.1145/3191697.3213803},
year = {2018},
}
Publisher's Version
|
|
| Melatagia, Paulin |
<Programming'18> Companion Companion '18: "An API and Visual Environment ..."
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.
@InProceedings{<Programming'18> Companion18p117,
author = {Alexandre Bergel and Paulin Melatagia and Serge Stinckwich},
title = {An API and Visual Environment to Use Neural Network to Reason about Source Code},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {117--120},
doi = {10.1145/3191697.3214340},
year = {2018},
}
Publisher's Version
|
|
| Mezini, Mira |
<Programming'18> Companion Companion '18: "Towards Safe Modular Composition ..."
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.
@InProceedings{<Programming'18> Companion18p81,
author = {Matthias Eichholz and Guido Salvaneschi and Mira Mezini},
title = {Towards Safe Modular Composition of Network Functions},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {81--86},
doi = {10.1145/3191697.3213804},
year = {2018},
}
Publisher's Version
<Programming'18> Companion Companion '18: "Reactive Programming Experience ..."
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.
@InProceedings{<Programming'18> Companion18p105,
author = {Ragnar Mogk and Guido Salvaneschi and Mira Mezini},
title = {Reactive Programming Experience with REScala},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {105--112},
doi = {10.1145/3191697.3214337},
year = {2018},
}
Publisher's Version
|
|
| Mogk, Ragnar |
<Programming'18> Companion Companion '18: "Reactive Programming Experience ..."
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.
@InProceedings{<Programming'18> Companion18p105,
author = {Ragnar Mogk and Guido Salvaneschi and Mira Mezini},
title = {Reactive Programming Experience with REScala},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {105--112},
doi = {10.1145/3191697.3214337},
year = {2018},
}
Publisher's Version
|
|
| Mössenböck, Hanspeter |
<Programming'18> Companion Companion '18: "Sulong, and Thanks for All ..."
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.
@InProceedings{<Programming'18> Companion18p58,
author = {Manuel Rigger and Roland Schatz and Jacob Kreindl and Christian Häubl and Hanspeter Mössenböck},
title = {Sulong, and Thanks for All the Fish},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {58--60},
doi = {10.1145/3191697.3191726},
year = {2018},
}
Publisher's Version
|
|
| Nisbet, Andy |
<Programming'18> Companion Companion '18: "On the Future of Research ..."
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.
@InProceedings{<Programming'18> Companion18p51,
author = {Foivos S. Zakkak and Andy Nisbet and John Mawer and Tim Hartley and Nikos Foutris and Orion Papadakis and Andreas Andronikakis and Iain Apreotesei and Christos Kotselidis},
title = {On the Future of Research VMs: A Hardware/Software Perspective},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {51--53},
doi = {10.1145/3191697.3191729},
year = {2018},
}
Publisher's Version
|
|
| Nordahl, Mattias |
<Programming'18> Companion Companion '18: "Live Programming of Internet ..."
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.
@InProceedings{<Programming'18> Companion18p121,
author = {Alfred Åkesson and Mattias Nordahl and Görel Hedin and Boris Magnusson},
title = {Live Programming of Internet of Things in PalCom},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {121--126},
doi = {10.1145/3191697.3214342},
year = {2018},
}
Publisher's Version
|
|
| Oney, Steve |
<Programming'18> Companion Companion '18: "Attention Patterns for Code ..."
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.
@InProceedings{<Programming'18> Companion18p99,
author = {Louis Spinelli and Maulishree Pandey and Steve Oney},
title = {Attention Patterns for Code Animations: Using Eye Trackers to Evaluate Dynamic Code Presentation Techniques},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {99--104},
doi = {10.1145/3191697.3214338},
year = {2018},
}
Publisher's Version
|
|
| Öqvist, Jesper |
<Programming'18> Companion Companion '18: "ExtendJ: Extensible Java Compiler ..."
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.
@InProceedings{<Programming'18> Companion18p234,
author = {Jesper Öqvist},
title = {ExtendJ: Extensible Java Compiler},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {234--235},
doi = {10.1145/3191697.3213798},
year = {2018},
}
Publisher's Version
|
|
| Pandey, Maulishree |
<Programming'18> Companion Companion '18: "Attention Patterns for Code ..."
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.
@InProceedings{<Programming'18> Companion18p99,
author = {Louis Spinelli and Maulishree Pandey and Steve Oney},
title = {Attention Patterns for Code Animations: Using Eye Trackers to Evaluate Dynamic Code Presentation Techniques},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {99--104},
doi = {10.1145/3191697.3214338},
year = {2018},
}
Publisher's Version
|
|
| Papadakis, Orion |
<Programming'18> Companion Companion '18: "On the Future of Research ..."
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.
@InProceedings{<Programming'18> Companion18p51,
author = {Foivos S. Zakkak and Andy Nisbet and John Mawer and Tim Hartley and Nikos Foutris and Orion Papadakis and Andreas Andronikakis and Iain Apreotesei and Christos Kotselidis},
title = {On the Future of Research VMs: A Hardware/Software Perspective},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {51--53},
doi = {10.1145/3191697.3191729},
year = {2018},
}
Publisher's Version
|
|
| Papadimitriou, Michail |
<Programming'18> Companion Companion '18: "Towards Practical Heterogeneous ..."
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.
@InProceedings{<Programming'18> Companion18p46,
author = {James Clarkson and Juan Fumero and Michail Papadimitriou and Maria Xekalaki and Christos Kotselidis},
title = {Towards Practical Heterogeneous Virtual Machines},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {46--48},
doi = {10.1145/3191697.3191730},
year = {2018},
}
Publisher's Version
|
|
| Park, Jihyeok |
<Programming'18> Companion Companion '18: "A Framework for Dynamic Inter-device ..."
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.
@InProceedings{<Programming'18> Companion18p63,
author = {Jihyeok Park and Joonyoung Park and Yoonkyong Lee and Chul-Joo Kim and Byoungoh Kim and Sukyoung Ryu},
title = {A Framework for Dynamic Inter-device Task Dispatch with Eventual Consistency},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {63--68},
doi = {10.1145/3191697.3191732},
year = {2018},
}
Publisher's Version
|
|
| Park, Joonyoung |
<Programming'18> Companion Companion '18: "A Framework for Dynamic Inter-device ..."
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.
@InProceedings{<Programming'18> Companion18p63,
author = {Jihyeok Park and Joonyoung Park and Yoonkyong Lee and Chul-Joo Kim and Byoungoh Kim and Sukyoung Ryu},
title = {A Framework for Dynamic Inter-device Task Dispatch with Eventual Consistency},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {63--68},
doi = {10.1145/3191697.3191732},
year = {2018},
}
Publisher's Version
|
|
| Petricek, Tomas |
<Programming'18> Companion Companion '18: "Critique of ‘An Anatomy ..."
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.
@InProceedings{<Programming'18> Companion18p197,
author = {Tomas Petricek},
title = {Critique of ‘An Anatomy of Interaction: Co-occurrences and Entanglements’},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {197--201},
doi = {10.1145/3191697.3214329},
year = {2018},
}
Publisher's Version
|
|
| Pierantonio, Alfonso |
<Programming'18> Companion Companion '18: "Enhancing the JTL Tool for ..."
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.
@InProceedings{<Programming'18> Companion18p36,
author = {Romina Eramo and Alfonso Pierantonio and Michele Tucci},
title = {Enhancing the JTL Tool for Bidirectional Transformations},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {36--41},
doi = {10.1145/3191697.3191720},
year = {2018},
}
Publisher's Version
|
|
| Piessens, Frank |
<Programming'18> Companion Companion '18: "Scalagna 0.1: Towards Multi-tier ..."
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.
@InProceedings{<Programming'18> Companion18p69,
author = {Bob Reynders and Michael Greefs and Dominique Devriese and Frank Piessens},
title = {Scalagna 0.1: Towards Multi-tier Programming with Scala and Scala.js},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {69--74},
doi = {10.1145/3191697.3191731},
year = {2018},
}
Publisher's Version
|
|
| Plantec, Alain |
<Programming'18> Companion Companion '18: "Collectors ..."
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.
@InProceedings{<Programming'18> Companion18p144,
author = {Steven Costiou and Mickaël Kerboeuf and Alain Plantec and Marcus Denker},
title = {Collectors},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {144--152},
doi = {10.1145/3191697.3214335},
year = {2018},
}
Publisher's Version
|
|
| Popp, Roman |
<Programming'18> Companion Companion '18: "On the Development of Consistent ..."
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.
@InProceedings{<Programming'18> Companion18p18,
author = {Anthony Anjorin and Enes Yigitbas and Hermann Kaindl and Roman Popp},
title = {On the Development of Consistent User Interfaces (Extended Abstract)},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {18--20},
doi = {10.1145/3191697.3191716},
year = {2018},
}
Publisher's Version
|
|
| Rein, Patrick |
<Programming'18> Companion Companion '18: "The Exploration Workspace: ..."
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.
@InProceedings{<Programming'18> Companion18p113,
author = {Patrick Rein and Robert Hirschfeld},
title = {The Exploration Workspace: Interleaving the Implementation and Use of Plain Objects in Smalltalk},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {113--116},
doi = {10.1145/3191697.3214339},
year = {2018},
}
Publisher's Version
<Programming'18> Companion Companion '18: "A Soup of Objects: Convenience ..."
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.
@InProceedings{<Programming'18> Companion18p236,
author = {Patrick Rein},
title = {A Soup of Objects: Convenience Interfaces for Accessing Domain Objects in a Global Object Graph},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {236--238},
doi = {10.1145/3191697.3213799},
year = {2018},
}
Publisher's Version
|
|
| Reynders, Bob |
<Programming'18> Companion Companion '18: "Scalagna 0.1: Towards Multi-tier ..."
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.
@InProceedings{<Programming'18> Companion18p69,
author = {Bob Reynders and Michael Greefs and Dominique Devriese and Frank Piessens},
title = {Scalagna 0.1: Towards Multi-tier Programming with Scala and Scala.js},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {69--74},
doi = {10.1145/3191697.3191731},
year = {2018},
}
Publisher's Version
|
|
| Rigger, Manuel |
<Programming'18> Companion Companion '18: "Sulong, and Thanks for All ..."
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.
@InProceedings{<Programming'18> Companion18p58,
author = {Manuel Rigger and Roland Schatz and Jacob Kreindl and Christian Häubl and Hanspeter Mössenböck},
title = {Sulong, and Thanks for All the Fish},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {58--60},
doi = {10.1145/3191697.3191726},
year = {2018},
}
Publisher's Version
<Programming'18> Companion Companion '18: "Sandboxed Execution of C and ..."
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.
@InProceedings{<Programming'18> Companion18p227,
author = {Manuel Rigger},
title = {Sandboxed Execution of C and Other Unsafe Languages on the Java Virtual Machine},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {227--229},
doi = {10.1145/3191697.3213795},
year = {2018},
}
Publisher's Version
|
|
| Rosà, Andrea |
<Programming'18> Companion Companion '18: "Understanding Task Granularity ..."
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.
@InProceedings{<Programming'18> Companion18p54,
author = {Andrea Rosà and Eduardo Rosales and Filippo Schiavio and Walter Binder},
title = {Understanding Task Granularity on the JVM: Profiling, Analysis, and Optimization},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {54--56},
doi = {10.1145/3191697.3191724},
year = {2018},
}
Publisher's Version
|
|
| Rosales, Eduardo |
<Programming'18> Companion Companion '18: "Understanding Task Granularity ..."
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.
@InProceedings{<Programming'18> Companion18p54,
author = {Andrea Rosà and Eduardo Rosales and Filippo Schiavio and Walter Binder},
title = {Understanding Task Granularity on the JVM: Profiling, Analysis, and Optimization},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {54--56},
doi = {10.1145/3191697.3191724},
year = {2018},
}
Publisher's Version
|
|
| Rosebrugh, Robert |
<Programming'18> Companion Companion '18: "Cospans and Symmetric Lenses ..."
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.
@InProceedings{<Programming'18> Companion18p21,
author = {Michael Johnson and Robert Rosebrugh},
title = {Cospans and Symmetric Lenses},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {21--29},
doi = {10.1145/3191697.3191717},
year = {2018},
}
Publisher's Version
|
|
| Rutle, Adrian |
<Programming'18> Companion Companion '18: "Multimodel Correspondence ..."
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.
@InProceedings{<Programming'18> Companion18p9,
author = {Patrick Stünkel and Harald König and Yngve Lamo and Adrian Rutle},
title = {Multimodel Correspondence through Inter-model Constraints},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {9--17},
doi = {10.1145/3191697.3191715},
year = {2018},
}
Publisher's Version
|
|
| Ryu, Sukyoung |
<Programming'18> Companion Companion '18: "A Framework for Dynamic Inter-device ..."
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.
@InProceedings{<Programming'18> Companion18p63,
author = {Jihyeok Park and Joonyoung Park and Yoonkyong Lee and Chul-Joo Kim and Byoungoh Kim and Sukyoung Ryu},
title = {A Framework for Dynamic Inter-device Task Dispatch with Eventual Consistency},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {63--68},
doi = {10.1145/3191697.3191732},
year = {2018},
}
Publisher's Version
|
|
| Salvaneschi, Guido |
<Programming'18> Companion Companion '18: "Towards Safe Modular Composition ..."
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.
@InProceedings{<Programming'18> Companion18p81,
author = {Matthias Eichholz and Guido Salvaneschi and Mira Mezini},
title = {Towards Safe Modular Composition of Network Functions},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {81--86},
doi = {10.1145/3191697.3213804},
year = {2018},
}
Publisher's Version
<Programming'18> Companion Companion '18: "Reactive Programming Experience ..."
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.
@InProceedings{<Programming'18> Companion18p105,
author = {Ragnar Mogk and Guido Salvaneschi and Mira Mezini},
title = {Reactive Programming Experience with REScala},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {105--112},
doi = {10.1145/3191697.3214337},
year = {2018},
}
Publisher's Version
|
|
| Sartor, Jennifer B. |
<Programming'18> Companion Companion '18: "Managing Hybrid Memories by ..."
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.
@InProceedings{<Programming'18> Companion18p75,
author = {Shoaib Akram and Kathryn S. McKinley and Jennifer B. Sartor and Lieven Eeckhout},
title = {Managing Hybrid Memories by Predicting Object Write Intensity},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {75--80},
doi = {10.1145/3191697.3213803},
year = {2018},
}
Publisher's Version
|
|
| Schatz, Roland |
<Programming'18> Companion Companion '18: "Sulong, and Thanks for All ..."
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.
@InProceedings{<Programming'18> Companion18p58,
author = {Manuel Rigger and Roland Schatz and Jacob Kreindl and Christian Häubl and Hanspeter Mössenböck},
title = {Sulong, and Thanks for All the Fish},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {58--60},
doi = {10.1145/3191697.3191726},
year = {2018},
}
Publisher's Version
|
|
| Schiavio, Filippo |
<Programming'18> Companion Companion '18: "Understanding Task Granularity ..."
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.
@InProceedings{<Programming'18> Companion18p54,
author = {Andrea Rosà and Eduardo Rosales and Filippo Schiavio and Walter Binder},
title = {Understanding Task Granularity on the JVM: Profiling, Analysis, and Optimization},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {54--56},
doi = {10.1145/3191697.3191724},
year = {2018},
}
Publisher's Version
|
|
| Schobbens, Pierre-Yves |
<Programming'18> Companion Companion '18: "A Lightweight Data Sharing ..."
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.
@InProceedings{<Programming'18> Companion18p42,
author = {Adrien Duchêne and Hugues Marchal and Zhenjiang Hu and Pierre-Yves Schobbens},
title = {A Lightweight Data Sharing System Based on Bidirectional Transformations},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {42--45},
doi = {10.1145/3191697.3191722},
year = {2018},
}
Publisher's Version
|
|
| Schrans, Franklin |
<Programming'18> Companion Companion '18: "Writing Safe Smart Contracts ..."
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.
@InProceedings{<Programming'18> Companion18p218,
author = {Franklin Schrans and Susan Eisenbach and Sophia Drossopoulou},
title = {Writing Safe Smart Contracts in Flint},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {218--219},
doi = {10.1145/3191697.3213790},
year = {2018},
}
Publisher's Version
|
|
| Sharpe, Oli |
<Programming'18> Companion Companion '18: "Semprola: A Semiotic Programming ..."
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.
@InProceedings{<Programming'18> Companion18p202,
author = {Oli Sharpe},
title = {Semprola: A Semiotic Programming Language},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {202--213},
doi = {10.1145/3191697.3214330},
year = {2018},
}
Publisher's Version
|
|
| Spinelli, Louis |
<Programming'18> Companion Companion '18: "Attention Patterns for Code ..."
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.
@InProceedings{<Programming'18> Companion18p99,
author = {Louis Spinelli and Maulishree Pandey and Steve Oney},
title = {Attention Patterns for Code Animations: Using Eye Trackers to Evaluate Dynamic Code Presentation Techniques},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {99--104},
doi = {10.1145/3191697.3214338},
year = {2018},
}
Publisher's Version
|
|
| Stevens, Perdita |
<Programming'18> Companion Companion '18: "Confidentiality in the Process ..."
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.
@InProceedings{<Programming'18> Companion18p1,
author = {Michael Johnson and Perdita Stevens},
title = {Confidentiality in the Process of (Model-Driven) Software Development},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {1--8},
doi = {10.1145/3191697.3191714},
year = {2018},
}
Publisher's Version
|
|
| Stinckwich, Serge |
<Programming'18> Companion Companion '18: "An API and Visual Environment ..."
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.
@InProceedings{<Programming'18> Companion18p117,
author = {Alexandre Bergel and Paulin Melatagia and Serge Stinckwich},
title = {An API and Visual Environment to Use Neural Network to Reason about Source Code},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {117--120},
doi = {10.1145/3191697.3214340},
year = {2018},
}
Publisher's Version
|
|
| Stünkel, Patrick |
<Programming'18> Companion Companion '18: "Multimodel Correspondence ..."
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.
@InProceedings{<Programming'18> Companion18p9,
author = {Patrick Stünkel and Harald König and Yngve Lamo and Adrian Rutle},
title = {Multimodel Correspondence through Inter-model Constraints},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {9--17},
doi = {10.1145/3191697.3191715},
year = {2018},
}
Publisher's Version
|
|
| Susungi, Adilla |
<Programming'18> Companion Companion '18: "On the Semantics of Loop Transformation ..."
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.
@InProceedings{<Programming'18> Companion18p230,
author = {Adilla Susungi},
title = {On the Semantics of Loop Transformation Languages},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {230--231},
doi = {10.1145/3191697.3213796},
year = {2018},
}
Publisher's Version
|
|
| Tchernavskij, Philip |
<Programming'18> Companion Companion '18: "Critique of ‘Files as Directories: ..."
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.
@InProceedings{<Programming'18> Companion18p171,
author = {Philip Tchernavskij},
title = {Critique of ‘Files as Directories: Some Thoughts on Accessing Structured Data within Files’ (1)},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {171--174},
doi = {10.1145/3191697.3214324},
year = {2018},
}
Publisher's Version
<Programming'18> Companion Companion '18: "An Anatomy of Interaction: ..."
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.
@InProceedings{<Programming'18> Companion18p188,
author = {Antranig Basman and Philip Tchernavskij and Simon Bates and Michel Beaudouin-Lafon},
title = {An Anatomy of Interaction: Co-occurrences and Entanglements},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {188--196},
doi = {10.1145/3191697.3214328},
year = {2018},
}
Publisher's Version
|
|
| Tucci, Michele |
<Programming'18> Companion Companion '18: "Enhancing the JTL Tool for ..."
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.
@InProceedings{<Programming'18> Companion18p36,
author = {Romina Eramo and Alfonso Pierantonio and Michele Tucci},
title = {Enhancing the JTL Tool for Bidirectional Transformations},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {36--41},
doi = {10.1145/3191697.3191720},
year = {2018},
}
Publisher's Version
|
|
| Videla, Alvaro |
<Programming'18> Companion Companion '18: "Lector in Codigo or The Role ..."
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)?
@InProceedings{<Programming'18> Companion18p180,
author = {Alvaro Videla},
title = {Lector in Codigo or The Role of the Reader},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {180--186},
doi = {10.1145/3191697.3214326},
year = {2018},
}
Publisher's Version
|
|
| Vranić, Valentino |
<Programming'18> Companion Companion '18: "Applying Aspect-Oriented Change ..."
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.
@InProceedings{<Programming'18> Companion18p87,
author = {Sandra Kostova and Valentino Vranić},
title = {Applying Aspect-Oriented Change Realization in the Mobile Application Domain},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {87--92},
doi = {10.1145/3191697.3213806},
year = {2018},
}
Publisher's Version
|
|
| Wimmer, Raphael |
<Programming'18> Companion Companion '18: "Files as Directories: Some ..."
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.
@InProceedings{<Programming'18> Companion18p166,
author = {Raphael Wimmer},
title = {Files as Directories: Some Thoughts on Accessing Structured Data within Files},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {166--170},
doi = {10.1145/3191697.3214323},
year = {2018},
}
Publisher's Version
Info
|
|
| Wingo, Andy |
<Programming'18> Companion Companion '18: "Self-Hosted Scripting in Guile ..."
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.
@InProceedings{<Programming'18> Companion18p57,
author = {Andy Wingo},
title = {Self-Hosted Scripting in Guile},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {57--57},
doi = {10.1145/3191697.3191727},
year = {2018},
}
Publisher's Version
|
|
| Xekalaki, Maria |
<Programming'18> Companion Companion '18: "Towards Practical Heterogeneous ..."
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.
@InProceedings{<Programming'18> Companion18p46,
author = {James Clarkson and Juan Fumero and Michail Papadimitriou and Maria Xekalaki and Christos Kotselidis},
title = {Towards Practical Heterogeneous Virtual Machines},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {46--48},
doi = {10.1145/3191697.3191730},
year = {2018},
}
Publisher's Version
|
|
| Yigitbas, Enes |
<Programming'18> Companion Companion '18: "On the Development of Consistent ..."
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.
@InProceedings{<Programming'18> Companion18p18,
author = {Anthony Anjorin and Enes Yigitbas and Hermann Kaindl and Roman Popp},
title = {On the Development of Consistent User Interfaces (Extended Abstract)},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {18--20},
doi = {10.1145/3191697.3191716},
year = {2018},
}
Publisher's Version
|
|
| Zakkak, Foivos S. |
<Programming'18> Companion Companion '18: "On the Future of Research ..."
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.
@InProceedings{<Programming'18> Companion18p51,
author = {Foivos S. Zakkak and Andy Nisbet and John Mawer and Tim Hartley and Nikos Foutris and Orion Papadakis and Andreas Andronikakis and Iain Apreotesei and Christos Kotselidis},
title = {On the Future of Research VMs: A Hardware/Software Perspective},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {51--53},
doi = {10.1145/3191697.3191729},
year = {2018},
}
Publisher's Version
|
|
| Zigmond, Ezra |
<Programming'18> Companion Companion '18: "Fine-Grained, Dynamic Access ..."
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.
@InProceedings{<Programming'18> Companion18p220,
author = {Ezra Zigmond},
title = {Fine-Grained, Dynamic Access Control for Database-Backed Applications},
booktitle = {Proc.\ <Programming'18> Companion},
publisher = {ACM},
pages = {220--221},
doi = {10.1145/3191697.3213791},
year = {2018},
}
Publisher's Version
|
124 authors
proc time: 18.02