Powered by
2016 ACM SIGPLAN International Conference on Systems, Programming, Languages and Applications: Software for Humanity (SPLASH Companion 2016),
October 30 – November 4, 2016,
Amsterdam, Netherlands
Student Research Competition
Design Pattern Builder: A Concept for Refinable Reusable Design Pattern Libraries
Tobias Dürschmid
(HPI, Germany)
Reuse is one of the core principles in professional software engineering.
Design patterns provide a reusable solution for common design problems.
But their implementations are generally not reusable as they are often well tailored to a specific context.
We introduce a concept, that facilitates the reuse of their implementations by defining an abstract design pattern definition that can be instantiated with specialized design decisions.
This approach is a meta-level Builder constructing design patterns as first-class citizens.
It simplifies the application of design patterns by providing a pattern library and still being able to adjust it to the concrete context.
@InProceedings{SPLASH Companion16p45,
author = {Tobias Dürschmid},
title = {Design Pattern Builder: A Concept for Refinable Reusable Design Pattern Libraries},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {45--46},
doi = {},
year = {2016},
}
End-User Software Engineering of Cognitive Robot Applications using Procedural Parameters and Complex Event Processing
Floris Erich
(University of Tsukuba, Japan)
Robots understand the world around them through sensing. To process the data produced by sensors we propose to use Procedural Parameters and Complex Event Processing (CEP). End-users model applications for robots as a CEP Graph, in which the end-users specify how input from the sensors of the robot is transformed to output for the actuators of the robot. Between input and output is a network of streams connected together by operators. By using Procedural Parameters a set of generic operators can be used within the CEP Graph. The CEP Graph can be executed on the robot or on a PC remotely controlling the robot.
@InProceedings{SPLASH Companion16p47,
author = {Floris Erich},
title = {End-User Software Engineering of Cognitive Robot Applications using Procedural Parameters and Complex Event Processing},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {47--48},
doi = {},
year = {2016},
}
A Compiler for Linear Algebra Operations
Henrik Barthels
(RWTH Aachen University, Germany)
In this paper we present a compiler that translates arithmetic expressions containing matrices to efficient sequences of calls to basic linear algebra kernels.
@InProceedings{SPLASH Companion16p49,
author = {Henrik Barthels},
title = {A Compiler for Linear Algebra Operations},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {49--50},
doi = {},
year = {2016},
}
An Approach to Compile Configurable Systems with #ifdefs Based on Impact Analysis
Larissa Braz
(Federal University of Campina Grande, Brazil)
Configurable systems typically use #ifdefs to denote variability. Generating and compiling all configurations may be time-consuming. An alternative consists of using variability-aware parsers, such as TypeChef. However, they may not scale. We propose a change-centric approach to compile configurable systems with #ifdefs by analyzing only configurations impacted by a code change. We implemented it in a tool called CHECKCONFIGMX. We perform an empirical study to evaluate 3,913 transformations applied to the 14 largest files of BusyBox, Apache HTTPD, and Expat configurable systems. CHECKCONFIGMX finds 595 compilation errors of 20 types introduced by 41 developers in 214 commits (5.46% of the analyzed transformations). In our study, it reduces by at least 50% (an average of 99%) the effort of evaluating the analyzed transformations by comparing with the exhaustive approach without considering a feature model.
@InProceedings{SPLASH Companion16p51,
author = {Larissa Braz},
title = {An Approach to Compile Configurable Systems with #ifdefs Based on Impact Analysis},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {51--52},
doi = {},
year = {2016},
}
Flexible Initialization of Immutable Objects
Tyler Etzel
(Cornell University, USA)
Immutability is a valuable feature for programmers in object-oriented languages: making objects immutable often simplifies reasoning about the correctness of code, particularly when concurrency is present. Java allows programmers to express and enforce immutability by declaring all fields of an object "final", but this comes at the cost of decreased expressiveness and intuitiveness of initialization. In this work, we propose a minimalistic type-based mechanism that both enforces immutability and relaxes these constraints on initialization. Furthermore, we propose and formalize two different type systems based on this mechanism that form a meaningful trade-off with respect to complexity, expressiveness, and strength of static guarantees. System One is simple, more expressive, and provides object-level immutability; System Two has more complicated annotation, is less expressive, and ensures that immutable objects are fully initialized in addition to enforcing immutability.
@InProceedings{SPLASH Companion16p53,
author = {Tyler Etzel},
title = {Flexible Initialization of Immutable Objects},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {53--54},
doi = {},
year = {2016},
}
Finding Concurrency Bugs Using Graph-Based Anomaly Detection in Big Code
Andrew Habib
(TU Darmstadt, Germany)
Concurrency bugs are very difficult and subtle to discover, reproduce, and fix. Many techniques have been devised by the academic as well as the industry communities to find these bugs. However, most of the effective techniques tend to focus on a subset of the various concurrency bugs types. We propose a new generic concurrency bug detection technique that leverages "Big Code": millions of lines of code freely available on code repositories. Our approach tries to learn the properties of what constitutes a good and a bad synchronization pattern from hundreds of concurrent software using graph-based anomaly detection.
@InProceedings{SPLASH Companion16p55,
author = {Andrew Habib},
title = {Finding Concurrency Bugs Using Graph-Based Anomaly Detection in Big Code},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {55--56},
doi = {},
year = {2016},
}
Reducing Procedure Call Bloat in ARM Binaries
Joseph Caldwell
(University of Tokyo, Japan)
The use of a standard calling convention throughout a binary can bloat code size and negatively impact power consumption, flash memory costs, and chip size in embedded or otherwise size-critical domains. This is particularly true in ”compressed” instruction sets, such as the 16-bit ARM Thumb instruction set, used in virtually all smart phones and in many other smaller-scale embedded devices. Here, we examine the extent of the problem in modern embedded software. We found that between 6-17% of the code in typical binaries represents overhead attributable to the calling convention. Finally, we propose a method of reducing this overhead by assigning calling conventions per-procedure during register allocation, and discuss solutions to scalability problems with this approach.
@InProceedings{SPLASH Companion16p57,
author = {Joseph Caldwell},
title = {Reducing Procedure Call Bloat in ARM Binaries},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {57--58},
doi = {},
year = {2016},
}
PixelDust: Supporting Dynamic Area of Interest Tagging in Programming Studies with Eye Tracking
Jessica Cherayil
(Wellesley College, USA)
Eye tracking studies are valuable for evaluating program- ming environments, but annotating what the programmer is looking at in a dynamic environment can be repetitive, time- consuming, and error prone. Through a participatory design exercise with two eye tracking researchers, I identified three significant challenges: search, extraction of code, and annotat- ing transient objects. By applying computer vision algorithms to video traces, I developed a mixed-initiative system called PIXELDUST, which allows the researcher to train a system to recognize different objects on a screen. My preliminary results demonstrate the versatility of the approach; for ex- ample, the system can recognize return statements, method signatures, tool tips, and dialog boxes.
@InProceedings{SPLASH Companion16p59,
author = {Jessica Cherayil},
title = {PixelDust: Supporting Dynamic Area of Interest Tagging in Programming Studies with Eye Tracking},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {59--60},
doi = {},
year = {2016},
}
Improving Live Debugging of Concurrent Threads
Max Leske
(University of Bern, Switzerland)
Contemporary live debuggers do not display the complete call stack history for concurrent threads. Hence, developers have less information at their disposal when debugging concurrent threads than when debugging a single threaded, sequential program. We solve the problem of incomplete thread history by creating a debugger that operates on a virtual call stack comprised of multiple threads. With live debuggers displaying at least the equivalent information for both single threaded, sequential programs and concurrent threads, developers can focus on the hard parts of concurrency issues.
@InProceedings{SPLASH Companion16p61,
author = {Max Leske},
title = {Improving Live Debugging of Concurrent Threads},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {61--62},
doi = {},
year = {2016},
}
xWIDL: Modular and Deep JavaScript API Misuses Checking Based on eXtended WebIDL
Zhen Zhang
(University of Science and Technology of China, China)
JavaScript is the de facto language of the Web, but is notoriously error-prone to use. 65% of common bugs like undefined/null variable usage are DOM-related. Besides DOM, JS APIs are also expected to manipulate graphic hardware and asynchronous I/O, which makes the condition even worse. Although WebIDL provides a formal contract between JS developers and platform implementation, its expressivity is too limited to support deep checking of API misuses. We propose the eXtended WebIDL (xWIDL) language and a modular API misuses checking framework based on xWIDL. We discuss how to handle the data exchange between JS analyzer and SMT-based verifier. Finally, we test our implementation in a case study manner and report our findings on its efficiency and modularity.
@InProceedings{SPLASH Companion16p63,
author = {Zhen Zhang},
title = {xWIDL: Modular and Deep JavaScript API Misuses Checking Based on eXtended WebIDL},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {63--64},
doi = {},
year = {2016},
}
Towards Object-Aware Development Tools
Andrei Chiş
(University of Bern, Switzerland)
Reasoning about object-oriented applications requires developers to answer contextual questions about their domain objects. Tailored development tools can support developers in this activity by providing relevant domain-specific information. Nonetheless, a high effort for extending development tools to handle domain-specific objects, together with diverging mechanisms for creating, sharing and discovering extensions, discourage developers to adapt their tools. To address this, we propose to enable contextual behavior in development tools by allowing domain objects to decide how they are handled in development tools. We show that combining this idea with mechanisms for specifying extensions using internal DSLs can significantly reduce the cost of tailoring development tools to specific domains.
@InProceedings{SPLASH Companion16p65,
author = {Andrei Chiş},
title = {Towards Object-Aware Development Tools},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {65--66},
doi = {},
year = {2016},
}
Info
Deducing Classes: Integrating the Domain Models of Object-Oriented Applications
Patrick Rein
(HPI, Germany)
The interoperability of applications depends on a successful
mapping between their domain models. Nowadays, common file formats serve as a mediator between the different domain models but cause friction losses during the conversion of data. These loses could be mitigated whenever the models are already working on the same concepts but are only using different representations for them. We propose the concept of deducing classes which interpret existing object structures and detect instances of themselves in this existing data. Further, we introduce a planning algorithm which combines deducing classes to allow unanticipated interactions between applications. We discuss some of the implications of this approach and illustrate upcoming research challenges.
@InProceedings{SPLASH Companion16p67,
author = {Patrick Rein},
title = {Deducing Classes: Integrating the Domain Models of Object-Oriented Applications},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {67--68},
doi = {},
year = {2016},
}
Energy Profiling with Alpaca
Logan Goldberg, Joel Katticaran, and Abraham Mhaidli
(Grinnell College, USA)
Rapid increases in demand for cloud computing, large-scale internet services, and mobile devices have led to a correspondingly large increase in the amount of energy required for computation. This additional energy use comes at a high cost, both financially and environmentally.
Energy profilers are useful tools which allow programmers to energy audit their programs and determine what functions are responsible for the most energy use. In this paper, we introduce a new technique for energy profiling, which takes energy measurements at regularly spaced intervals and uses linear regression to correlate executing functions with changes in power demand. We have implemented this technique in Alpaca, an energy profiler for Linux. Initial results suggest that this approach shows promise in energy profiling programs in an accurate and meaningful way.
@InProceedings{SPLASH Companion16p69,
author = {Logan Goldberg and Joel Katticaran and Abraham Mhaidli},
title = {Energy Profiling with Alpaca},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {69--70},
doi = {},
year = {2016},
}
Scrambler: Dynamic Layout Adaptation
David Chang, Thu Nguyen, and Niko Takayesu
(Grinnell College, USA)
Developers and compiler writers spend significant effort on performance tuning and optimizations. However, the impact of these efforts must be taken with a grain of salt. Prior work has shown that changes to a program's layout—the placement of code and data in memory—can change performance by more than the effect of standard optimization techniques.
This paper presents Scrambler, a system that dynamically changes the layout of programs to improve their performance. Scrambler runs C and C++ programs with a randomized layout, and monitors these programs for evidence of layout-related performance issues. When an issue is detected, Scrambler relocates the offending code to eliminate the layout issue. We evaluate Scrambler on eight SPEC CPU2006 benchmarks, and find that Scrambler can provide speedups as large as 4.6% by fixing layouts that hurt branch predictor performance. These early results are encouraging, and we plan to extend this work to support additional layout-related performance issues in the future.
@InProceedings{SPLASH Companion16p71,
author = {David Chang and Thu Nguyen and Niko Takayesu},
title = {Scrambler: Dynamic Layout Adaptation},
booktitle = {Proc.\ SPLASH Companion},
publisher = {ACM},
pages = {71--72},
doi = {},
year = {2016},
}
proc time: 1.18