SPLASH Companion '17: "Framework Support for Usability ..."
Framework Support for Usability Evaluation of Domain-Specific Languages
Ankica Barišić
(Nova University of Lisbon, Portugal)
In this paper we propose a conceptual framework that supports the iterative development process of DSLs concerning the issue of their Usability evaluation. A multiple-case studies were conducted in order validate the proposed method.
@InProceedings{SPLASH Companion17p16,
author = {Ankica Barišić},
title = {Framework Support for Usability Evaluation of Domain-Specific Languages},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {16--18},
doi = {},
year = {2017},
}
Video
SPLASH Companion '17: "Understanding the Interplay ..."
Understanding the Interplay between Task Scheduling, Memory and Performance
Germán Ceballos, Erik Hagersten, and David Black-Schaffer
(Uppsala University, Sweden)
New programming models have been introduced to aid the programmer dealing with the complexity of large-scale systems, simplifying the coding process and making applications more scalable. Task-based programming is one example that became popular recently. At the same time, understanding performance of multicore systems is key for getting faster execution times and optimize workloads, but it is becoming harder due to the increased complexity of hardware and the runtime systems.
To address this, we present TaskInsight, a technique to characterize the memory behavior of different task schedulers through the analysis of data reuse. TaskInsight provides high-level information that can be correlated with tasks’ performance variation over time to understand data reuse through the caches due to scheduling choices. This allows to identify which scheduling decisions affected performance, when were they taken, and why the performance changed, both in single and multi-threaded executions.
We demonstrate how TaskInsight can diagnose cases where poor scheduling caused over 60% difference on average (and up to 7x slowdowns) due to changes in the tasks’ data reuse through the caches.
@InProceedings{SPLASH Companion17p21,
author = {Germán Ceballos and Erik Hagersten and David Black-Schaffer},
title = {Understanding the Interplay between Task Scheduling, Memory and Performance},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {21--23},
doi = {},
year = {2017},
}
SPLASH Companion '17: "What Merge Tool Should I Use? ..."
What Merge Tool Should I Use?
Guilherme Cavalcanti
(Federal University of Pernambuco, Brazil)
While unstructured merge tools try to automatically resolve merge conflicts via textual similarity, semistructured and structured merge tools try to go further by exploiting the syntactic structure and semantics of the involved artefacts. Previous studies compare these merge approaches with respect to the number of reported conflicts, showing, for most projects and merge situations, a reduction in favor of semistructured and structured merge. However, these studies do not investigate whether this reduction actually leads to integration effort reduction (Productivity) without negative impact on the correctness of the merging process (Quality). To analyze this, and to better understand how these tools could be improved, we propose empirical studies to identify spurious conflicts (false positives) reported by one approach but not by the other, and interference reported as conflict by one approach but missed by the other (false negatives).
@InProceedings{SPLASH Companion17p19,
author = {Guilherme Cavalcanti},
title = {What Merge Tool Should I Use?},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {19--20},
doi = {},
year = {2017},
}
SPLASH Companion '17: "How to Make Tasks Faster: ..."
How to Make Tasks Faster: Revealing the Complex Interactions of Tasks in the Memory System
Germán Ceballos
(Uppsala University, Sweden)
New programming models have been introduced to aid the programmer dealing with the complexity of large-scale systems, simplifying the coding process and making applications more scalable regardless. Task-based programming is one example that became popular recently. At the same time, understanding performance of multicore systems is crucial for getting faster execution times and to optimize efficiency, but it is becoming harder due to the increased complexity of hardware architectures, and the interplay between the scheduling of tasks and caches. In this work, we develop models to understand how scheduling affects the performance of tasks due to memory behavior in the task-based context, and for that, we study cache sharing both in temporal and spatial ways. In temporal cache sharing, the effect of data reused over time by the tasks executed is modeled to predict different scenarios resulting in a tool called StatTask. In spatial cache sharing, the effect of tasks fighting for the cache at a given point in time through their execution is quantified and used to model their behavior on arbitrary cache sizes. We also present a new methodology called TaskInsight that can explain performance differences across different schedules for the same application. Finally, we explain how these methods set up a unique and solid platform to reveal insight into how to improve the performance of the execution of large-scale task-based applications.
@InProceedings{SPLASH Companion17p1,
author = {Germán Ceballos},
title = {How to Make Tasks Faster: Revealing the Complex Interactions of Tasks in the Memory System},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {1--3},
doi = {},
year = {2017},
}
SPLASH Companion '17: "Understanding the Interplay ..."
Understanding the Interplay between Task Scheduling, Memory and Performance
Germán Ceballos, Erik Hagersten, and David Black-Schaffer
(Uppsala University, Sweden)
New programming models have been introduced to aid the programmer dealing with the complexity of large-scale systems, simplifying the coding process and making applications more scalable. Task-based programming is one example that became popular recently. At the same time, understanding performance of multicore systems is key for getting faster execution times and optimize workloads, but it is becoming harder due to the increased complexity of hardware and the runtime systems.
To address this, we present TaskInsight, a technique to characterize the memory behavior of different task schedulers through the analysis of data reuse. TaskInsight provides high-level information that can be correlated with tasks’ performance variation over time to understand data reuse through the caches due to scheduling choices. This allows to identify which scheduling decisions affected performance, when were they taken, and why the performance changed, both in single and multi-threaded executions.
We demonstrate how TaskInsight can diagnose cases where poor scheduling caused over 60% difference on average (and up to 7x slowdowns) due to changes in the tasks’ data reuse through the caches.
@InProceedings{SPLASH Companion17p21,
author = {Germán Ceballos and Erik Hagersten and David Black-Schaffer},
title = {Understanding the Interplay between Task Scheduling, Memory and Performance},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {21--23},
doi = {},
year = {2017},
}
SPLASH Companion '17: "QuixBugs: A Multi-Lingual ..."
QuixBugs: A Multi-Lingual Program Repair Benchmark Set Based on the Quixey Challenge
Derrick Lin, James Koppel, Angela Chen, and Armando Solar-Lezama
(Massachusetts Institute of Technology, USA; Google, USA)
Recent years have seen an explosion of work in automated program repair. While previous work has focused exclusively on tools for single languages, recent work in multi-language transformation has opened the door for multi-language program repair tools. Evaluating the performance of such a tool requires having a benchmark set of similar buggy programs in different languages. We present QuixBugs, consisting of 40 programs translated to both Python and Java, each with a bug on a single line. The QuixBugs benchmark suite is based on problems from the Quixey Challenge, where programmers were given a short buggy program and 1 minute to fix the bug.
@InProceedings{SPLASH Companion17p55,
author = {Derrick Lin and James Koppel and Angela Chen and Armando Solar-Lezama},
title = {QuixBugs: A Multi-Lingual Program Repair Benchmark Set Based on the Quixey Challenge},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {55--56},
doi = {},
year = {2017},
}
SPLASH Companion '17: "ZenSheet Studio: A Spreadsheet-Inspired ..."
ZenSheet Studio: A Spreadsheet-Inspired Environment for Reactive Computing
Monica Figuera
(Simón Bolívar University, Venezuela)
Widely criticized as error-prone, causing millions of dollars in losses, spreadsheets continue to be extremely popular, decades after their introduction. The ZenSheet project aims to turn spreadsheets into modern and robust computing environments, with minimal impact on the learning curve. This paper focuses on ZenSheet Studio: a web client that delivers a generalized spreadsheet computing experience.
@InProceedings{SPLASH Companion17p33,
author = {Monica Figuera},
title = {ZenSheet Studio: A Spreadsheet-Inspired Environment for Reactive Computing},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {33--35},
doi = {},
year = {2017},
}
Info
SPLASH Companion '17: "SmartJS: Dynamic and Self-Adaptable ..."
SmartJS: Dynamic and Self-Adaptable Runtime Middleware for Next-Generation IoT Systems
Julien Gascon-Samson, Mohammad Rafiuzzaman, and Karthik Pattabiraman
(University of British Columbia, Canada)
The Internet of Things (IoT) has gained wide popularity both in the academic and industrial contexts. However, IoT-based systems exhibit many important challenges across many dimensions. In this work, we propose SmartJS, a rich Javascript-based middleware platform and runtime environment that abstracts the complexity of the various IoT platforms by providing a high-level framework for IoT system developers. SmartJS abstracts large-scale distributed system considerations, such as scheduling, monitoring and self-adaptation, and proposes a rich inter-device Javascript-based code migration framework. Finally, it provides debugging and monitoring techniques to analyze performance and observe system-wide security properties.
@InProceedings{SPLASH Companion17p51,
author = {Julien Gascon-Samson and Mohammad Rafiuzzaman and Karthik Pattabiraman},
title = {SmartJS: Dynamic and Self-Adaptable Runtime Middleware for Next-Generation IoT Systems},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {51--52},
doi = {},
year = {2017},
}
SPLASH Companion '17: "Combining Visual and Textual ..."
Combining Visual and Textual Languages for Dyslexia
Luis F. González
(Universidad Politécnica de Madrid, Spain; Politecnico Colombiano Jaime Isaza Cadavid, Colombia)
This paper describes the research of a Software, Systems and Computing PhD thesis conducted at the Universidad Politécnica de Madrid. The aim of this research is threefold: i) design a model to promote interaction between programmers with and without dyslexia during software development as part of a team, ii) overcome the obstacles facing dyslexic programmers when they are writing a program, and iii) increase software development performance and efficiency levels when one of the programmers has symptoms of dyslexia.
@InProceedings{SPLASH Companion17p4,
author = {Luis F. González},
title = {Combining Visual and Textual Languages for Dyslexia},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {4--6},
doi = {},
year = {2017},
}
SPLASH Companion '17: "Understanding the Interplay ..."
Understanding the Interplay between Task Scheduling, Memory and Performance
Germán Ceballos, Erik Hagersten, and David Black-Schaffer
(Uppsala University, Sweden)
New programming models have been introduced to aid the programmer dealing with the complexity of large-scale systems, simplifying the coding process and making applications more scalable. Task-based programming is one example that became popular recently. At the same time, understanding performance of multicore systems is key for getting faster execution times and optimize workloads, but it is becoming harder due to the increased complexity of hardware and the runtime systems.
To address this, we present TaskInsight, a technique to characterize the memory behavior of different task schedulers through the analysis of data reuse. TaskInsight provides high-level information that can be correlated with tasks’ performance variation over time to understand data reuse through the caches due to scheduling choices. This allows to identify which scheduling decisions affected performance, when were they taken, and why the performance changed, both in single and multi-threaded executions.
We demonstrate how TaskInsight can diagnose cases where poor scheduling caused over 60% difference on average (and up to 7x slowdowns) due to changes in the tasks’ data reuse through the caches.
@InProceedings{SPLASH Companion17p21,
author = {Germán Ceballos and Erik Hagersten and David Black-Schaffer},
title = {Understanding the Interplay between Task Scheduling, Memory and Performance},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {21--23},
doi = {},
year = {2017},
}
SPLASH Companion '17: "Incremental Parametric Syntax ..."
Incremental Parametric Syntax for Multi-Language Transformation
James Koppel and Armando Solar-Lezama
(Massachusetts Institute of Technology, USA)
We present a new approach for building source-to-source transformations that can run on multiple programming languages, based on a new way of representing programs called incremental parametric syntax. We implement this approach in our Cubix system, and construct incremental parametric syntaxes for C, Java, JavaScript, Lua, and Python, demonstrating three multi-language program transformations that can run on all of them. Our evaluation shows that (1) once a transformation is written, relatively little work is required to configure it for a new language (2) transformations built this way output readable code which preserve the structure of the original, according to participants in our human study, and (3) despite dealing with many languages, our transformations can still handle language corner-cases, and pass 90% of compiler test suites.
@InProceedings{SPLASH Companion17p53,
author = {James Koppel and Armando Solar-Lezama},
title = {Incremental Parametric Syntax for Multi-Language Transformation},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {53--54},
doi = {},
year = {2017},
}
SPLASH Companion '17: "QuixBugs: A Multi-Lingual ..."
QuixBugs: A Multi-Lingual Program Repair Benchmark Set Based on the Quixey Challenge
Derrick Lin, James Koppel, Angela Chen, and Armando Solar-Lezama
(Massachusetts Institute of Technology, USA; Google, USA)
Recent years have seen an explosion of work in automated program repair. While previous work has focused exclusively on tools for single languages, recent work in multi-language transformation has opened the door for multi-language program repair tools. Evaluating the performance of such a tool requires having a benchmark set of similar buggy programs in different languages. We present QuixBugs, consisting of 40 programs translated to both Python and Java, each with a bug on a single line. The QuixBugs benchmark suite is based on problems from the Quixey Challenge, where programmers were given a short buggy program and 1 minute to fix the bug.
@InProceedings{SPLASH Companion17p55,
author = {Derrick Lin and James Koppel and Angela Chen and Armando Solar-Lezama},
title = {QuixBugs: A Multi-Lingual Program Repair Benchmark Set Based on the Quixey Challenge},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {55--56},
doi = {},
year = {2017},
}
SPLASH Companion '17: "Genetic Improvement in Code ..."
Genetic Improvement in Code Interpreters and Compilers
Oliver Krauss
(JKU Linz, Austria; University of Applied Sciences Upper Austria at Hagenberg, Austria)
Modern compilers provide code optimizations before and during run-time, thus moving required domain knowledge about the compilation process away from the developer and speeding up resulting software. These optimizations are often based on formal proof, or alternatively have recovery paths as backup. Genetic improvement (GI), a field of science utilizing genetic programming, a stochastic optimization technique, has been previously utilized to fix bugs in software and improve non-functional software requirements.
This work proposes to research the applicability of GI in an offline phase directly at the interpreter or compiler level. The primary goal is to reformulate existing source code in such a way that existing optimizations can be applied in order to increase performance even further and requiring even less domain knowledge from the developer about a programming language and/or compiler. From these reformulations, patterns can be identified that allow code restructuring without the overhead GI poses.
@InProceedings{SPLASH Companion17p7,
author = {Oliver Krauss},
title = {Genetic Improvement in Code Interpreters and Compilers},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {7--9},
doi = {},
year = {2017},
}
SPLASH Companion '17: "How to Efficiently Process ..."
How to Efficiently Process 2100 List Variations
Lukas Lazarek
(University of Massachusetts at Lowell, USA)
Variational execution offers an avenue of efficiently analyzing configurable systems, but data structures like lists require special consideration. We implement automatic substitution of a more efficient list representation in a variational execution framework and evaluate its performance in micro-benchmarks. The results suggest that the substitution may offer substantial performance improvements to programs involving highly variational lists.
@InProceedings{SPLASH Companion17p36,
author = {Lukas Lazarek},
title = {How to Efficiently Process 2<sup>100</sup> List Variations},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {36--38},
doi = {},
year = {2017},
}
SPLASH Companion '17: "Automatic Testing of Interactive ..."
Automatic Testing of Interactive JavaScript Debuggers
Daniel Lehmann
(TU Darmstadt, Germany)
When debugging programs, we often assume the debugger itself is correct. However, when it is not, it becomes hard to find bugs or lets developers search for bugs that are not even present. We thus propose a new approach to automatic testing of debuggers, inspired by differential testing of compilers. Our approach generates debugger actions to exercise the debugger and records a trace during the debugging session. By comparing traces of different debuggers against each other, we find deviating behavior and bugs. We evaluate our approach on the JavaScript debuggers of Firefox and Chromium and find 16 previously unreported bugs, four of which are already confirmed and fixed.
@InProceedings{SPLASH Companion17p24,
author = {Daniel Lehmann},
title = {Automatic Testing of Interactive JavaScript Debuggers},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {24--26},
doi = {},
year = {2017},
}
SPLASH Companion '17: "Simulation-Based Code Duplication ..."
Simulation-Based Code Duplication for Enhancing Compiler Optimizations
David Leopoldseder
(JKU Linz, Austria)
The scope of compiler optimizations is often limited by control flow, which prohibits optimizations across basic block boundaries. Code duplication can solve this problem by extending basic block sizes, thus enabling subsequent optimizations. However, duplicating code for every optimization opportunity may lead to excessive code growth. Therefore, a holistic approach is required that is capable of finding optimization opportunities and classifying their impact.
This paper presents a novel approach to determine which code should be duplicated in order to improve peak performance. The approach analyzes duplication candidates for subsequent optimizations opportunities. It does so by simulating a duplication and analyzing its impact on other optimizations. This allows a compiler to weight up multiple success metrics in order to choose those duplications with the maximum optimization potential. We further show how to map code duplication opportunities to an optimization cost model that allows us to maximize performance while minimizing code size increase.
@InProceedings{SPLASH Companion17p10,
author = {David Leopoldseder},
title = {Simulation-Based Code Duplication for Enhancing Compiler Optimizations},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {10--12},
doi = {},
year = {2017},
}
SPLASH Companion '17: "Computer-Assisted Specification ..."
Computer-Assisted Specification of Asynchronous Interfaces with Non-deterministic Behavior
Nicholas V. Lewchenko
(University of Colorado at Boulder, USA)
The Android Framework is designed around components with asynchronous interfaces, in which inputs and outputs are not directly coupled. Precisely specifying behavior of this sort is a slow, error-prone process, and thus documentation and testing for such components is usually incomplete. I have participated over the last year in a collaborative research project seeking to solve this problem by automating the generation and verification of these specifications via active learning on a live Android system. Part of my work has been the extension of our automation technique to Android Framework components with non-deterministic behavior that prevents direct application of active learning algorithms. To this end, I have applied our learning engine in the form of a specification assistant which mixes automation and manual guidance to learn non-deterministic interfaces with as little user intervention as possible.
@InProceedings{SPLASH Companion17p27,
author = {Nicholas V. Lewchenko},
title = {Computer-Assisted Specification of Asynchronous Interfaces with Non-deterministic Behavior},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {27--29},
doi = {},
year = {2017},
}
SPLASH Companion '17: "QuixBugs: A Multi-Lingual ..."
QuixBugs: A Multi-Lingual Program Repair Benchmark Set Based on the Quixey Challenge
Derrick Lin, James Koppel, Angela Chen, and Armando Solar-Lezama
(Massachusetts Institute of Technology, USA; Google, USA)
Recent years have seen an explosion of work in automated program repair. While previous work has focused exclusively on tools for single languages, recent work in multi-language transformation has opened the door for multi-language program repair tools. Evaluating the performance of such a tool requires having a benchmark set of similar buggy programs in different languages. We present QuixBugs, consisting of 40 programs translated to both Python and Java, each with a bug on a single line. The QuixBugs benchmark suite is based on problems from the Quixey Challenge, where programmers were given a short buggy program and 1 minute to fix the bug.
@InProceedings{SPLASH Companion17p55,
author = {Derrick Lin and James Koppel and Angela Chen and Armando Solar-Lezama},
title = {QuixBugs: A Multi-Lingual Program Repair Benchmark Set Based on the Quixey Challenge},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {55--56},
doi = {},
year = {2017},
}
SPLASH Companion '17: "How Are Programming Questions ..."
How Are Programming Questions from Women Received on Stack Overflow? A Case Study of Peer Parity
Savannah Morgan
(Centre College, USA)
Stack Overflow is a useful Q&A online community for programmers. However, it has not been as popular among programmers who are women. Prior studies have shown low participation of women programmers on Stack Overflow, but have not demonstrated how the presence of their peers may promote activity. In this work, we understand how the presence of women, through peer parity, can encourage women to participate more on Stack Overflow. We extracted 3,2209,817 posts from the most recent Stack Overflow data dump. By modifying a popular gender computing tool, we took the first names of online users and identified the gender of 2,502,438 users from the 5,987,284 list of current users. We randomly selected peer parity and non peer parity questions asked by women and identify differences in participation on those posts. We found that women become more active after they have taken part in a peer parity post. With further analysis of peer parity through eye tracking and tone detection tools we can determine ways to foster a more welcoming community that would encourage women to participate.
@InProceedings{SPLASH Companion17p39,
author = {Savannah Morgan},
title = {How Are Programming Questions from Women Received on Stack Overflow? A Case Study of Peer Parity},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {39--41},
doi = {},
year = {2017},
}
SPLASH Companion '17: "Verifying the Proxy Design ..."
Verifying the Proxy Design Pattern using Object Propositions
Ligia Nistor
(Carnegie Mellon University, USA)
In this extended abstract we explore the expressiveness and modularity of our recently published object propositions methodology by applying it to verify properties about programs that use the proxy design pattern. Our instance of the proxy pattern implements a general proxy-real object system that is routinely used in industry and the verification of which is challenging.
@InProceedings{SPLASH Companion17p30,
author = {Ligia Nistor},
title = {Verifying the Proxy Design Pattern using Object Propositions},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {30--32},
doi = {},
year = {2017},
}
SPLASH Companion '17: "Devirtualization in LLVM ..."
Devirtualization in LLVM
Piotr Padlewski
(University of Warsaw, Poland)
Devirtualization is an optimization changing indirect (virtual) calls to direct calls. It improves performance by allowing extra inlining and removal of redundant loads. This paper presents a novel way of handling C++ devirtualization in LLVM by unifying virtual table loads across calls using different SSA values to represent different dynamic types.
@InProceedings{SPLASH Companion17p42,
author = {Piotr Padlewski},
title = {Devirtualization in LLVM},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {42--44},
doi = {},
year = {2017},
}
SPLASH Companion '17: "SmartJS: Dynamic and Self-Adaptable ..."
SmartJS: Dynamic and Self-Adaptable Runtime Middleware for Next-Generation IoT Systems
Julien Gascon-Samson, Mohammad Rafiuzzaman, and Karthik Pattabiraman
(University of British Columbia, Canada)
The Internet of Things (IoT) has gained wide popularity both in the academic and industrial contexts. However, IoT-based systems exhibit many important challenges across many dimensions. In this work, we propose SmartJS, a rich Javascript-based middleware platform and runtime environment that abstracts the complexity of the various IoT platforms by providing a high-level framework for IoT system developers. SmartJS abstracts large-scale distributed system considerations, such as scheduling, monitoring and self-adaptation, and proposes a rich inter-device Javascript-based code migration framework. Finally, it provides debugging and monitoring techniques to analyze performance and observe system-wide security properties.
@InProceedings{SPLASH Companion17p51,
author = {Julien Gascon-Samson and Mohammad Rafiuzzaman and Karthik Pattabiraman},
title = {SmartJS: Dynamic and Self-Adaptable Runtime Middleware for Next-Generation IoT Systems},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {51--52},
doi = {},
year = {2017},
}
SPLASH Companion '17: "SmartJS: Dynamic and Self-Adaptable ..."
SmartJS: Dynamic and Self-Adaptable Runtime Middleware for Next-Generation IoT Systems
Julien Gascon-Samson, Mohammad Rafiuzzaman, and Karthik Pattabiraman
(University of British Columbia, Canada)
The Internet of Things (IoT) has gained wide popularity both in the academic and industrial contexts. However, IoT-based systems exhibit many important challenges across many dimensions. In this work, we propose SmartJS, a rich Javascript-based middleware platform and runtime environment that abstracts the complexity of the various IoT platforms by providing a high-level framework for IoT system developers. SmartJS abstracts large-scale distributed system considerations, such as scheduling, monitoring and self-adaptation, and proposes a rich inter-device Javascript-based code migration framework. Finally, it provides debugging and monitoring techniques to analyze performance and observe system-wide security properties.
@InProceedings{SPLASH Companion17p51,
author = {Julien Gascon-Samson and Mohammad Rafiuzzaman and Karthik Pattabiraman},
title = {SmartJS: Dynamic and Self-Adaptable Runtime Middleware for Next-Generation IoT Systems},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {51--52},
doi = {},
year = {2017},
}
SPLASH Companion '17: "Incremental Parametric Syntax ..."
Incremental Parametric Syntax for Multi-Language Transformation
James Koppel and Armando Solar-Lezama
(Massachusetts Institute of Technology, USA)
We present a new approach for building source-to-source transformations that can run on multiple programming languages, based on a new way of representing programs called incremental parametric syntax. We implement this approach in our Cubix system, and construct incremental parametric syntaxes for C, Java, JavaScript, Lua, and Python, demonstrating three multi-language program transformations that can run on all of them. Our evaluation shows that (1) once a transformation is written, relatively little work is required to configure it for a new language (2) transformations built this way output readable code which preserve the structure of the original, according to participants in our human study, and (3) despite dealing with many languages, our transformations can still handle language corner-cases, and pass 90% of compiler test suites.
@InProceedings{SPLASH Companion17p53,
author = {James Koppel and Armando Solar-Lezama},
title = {Incremental Parametric Syntax for Multi-Language Transformation},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {53--54},
doi = {},
year = {2017},
}
SPLASH Companion '17: "QuixBugs: A Multi-Lingual ..."
QuixBugs: A Multi-Lingual Program Repair Benchmark Set Based on the Quixey Challenge
Derrick Lin, James Koppel, Angela Chen, and Armando Solar-Lezama
(Massachusetts Institute of Technology, USA; Google, USA)
Recent years have seen an explosion of work in automated program repair. While previous work has focused exclusively on tools for single languages, recent work in multi-language transformation has opened the door for multi-language program repair tools. Evaluating the performance of such a tool requires having a benchmark set of similar buggy programs in different languages. We present QuixBugs, consisting of 40 programs translated to both Python and Java, each with a bug on a single line. The QuixBugs benchmark suite is based on problems from the Quixey Challenge, where programmers were given a short buggy program and 1 minute to fix the bug.
@InProceedings{SPLASH Companion17p55,
author = {Derrick Lin and James Koppel and Angela Chen and Armando Solar-Lezama},
title = {QuixBugs: A Multi-Lingual Program Repair Benchmark Set Based on the Quixey Challenge},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {55--56},
doi = {},
year = {2017},
}
SPLASH Companion '17: "Advanced Debugging Techniques ..."
Advanced Debugging Techniques to Identify Concurrency Bugs in Actor-based Programs
Carmen Torres Lopez
(Vrije Universiteit Brussel, Belgium)
Actor-based programs are not exempt from concurrency bugs. Inspiring contributions for debugging actor-based programs have been developed, however there is no approach that reliably identifies the root cause of complex concurrency bugs. Solving this problem can result in a reduction of the debugging time that programmers spend when developing concurrent applications. I propose a debugging approach based on the combination of offline debugging techniques that aim to help developers in the process of finding the root cause of concurrency bugs. I plan to evaluate this proposal through user studies and performance evaluation.
@InProceedings{SPLASH Companion17p13,
author = {Carmen Torres Lopez},
title = {Advanced Debugging Techniques to Identify Concurrency Bugs in Actor-based Programs},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {13--15},
doi = {},
year = {2017},
}
SPLASH Companion '17: "Principles, Patterns, and ..."
Principles, Patterns, and Techniques for Designing and Implementing Practical Fluent Interfaces in Java
Haochen Xie
(Nagoya University, Japan)
In this research, the author sought a meta-theory that establishes essential concepts and fundamental techniques in helping programmers design and implement practical fluent interfaces in the Java language. An anatomy of the conceptual establishment of fluent interfaces is established and presented. Six primitives, roles that a key method could play are also identified. The author also coined the term transition choreography and attributed it as the core of the design theory for practical fluent interfaces in Java. Results in this research may apply as well in languages other than Java.
@InProceedings{SPLASH Companion17p45,
author = {Haochen Xie},
title = {Principles, Patterns, and Techniques for Designing and Implementing Practical Fluent Interfaces in Java},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {45--47},
doi = {},
year = {2017},
}
Info
SPLASH Companion '17: "Abstracting Resource Effects ..."
Abstracting Resource Effects
Valerie Zhao
(Wellesley College, USA)
In developing secure programs, reasoning about effects on resources can be hindered by obscure changes in program state. Effect systems mitigate this difficulty by describing these changes, but may require large amounts of low-level effect annotations, and create obstacles for reasoning. To reduce overhead, we propose an effect system, with a focus on system resources, that supports effect abstraction. It is being implemented in Wyvern, a capability-safe language.
@InProceedings{SPLASH Companion17p48,
author = {Valerie Zhao},
title = {Abstracting Resource Effects},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {48--50},
doi = {},
year = {2017},
}