FSE '16: "Guided Code Synthesis using ..."
Guided Code Synthesis using Deep Neural Networks
Carol V. Alexandru
(University of Zurich, Switzerland)
Can we teach computers how to program? Recent advances in neural network research reveal that certain neural networks are able not only to learn the syntax, grammar and semantics of arbitrary character sequences, but also synthesize new samples `in the style of' the original training data. We explore the adaptation of these techniques to code classification, comprehension and completion.
@InProceedings{FSE16p1068,
author = {Carol V. Alexandru},
title = {Guided Code Synthesis using Deep Neural Networks},
booktitle = {Proc.\ FSE},
publisher = {ACM},
pages = {1068--1070},
doi = {},
year = {2016},
}
FSE '16: "Understanding Behavioural ..."
Understanding Behavioural Patterns in JavaScript
Saba Alimadadi
(University of British Columbia, Canada)
JavaScript is one of the most popular programming languages. How- ever, understanding the dynamic behaviour of JavaScript apps is challenging in practice. There are many factors that hinder JavaScript comprehension, such as its dynamic, asynchronous, and event- driven nature, the dynamic interplay between JavaScript and the Document Object Model, and the asynchronous communication between client and server. In this research work, we have already proposed methods for understanding event-based and asynchronous JavaScript behaviour. To enhance the scalability of our methods, we propose a new technique that adopts bio-informatics algorithms to extract sequences of actions from execution traces that form higher-level patterns.
@InProceedings{FSE16p1076,
author = {Saba Alimadadi},
title = {Understanding Behavioural Patterns in JavaScript},
booktitle = {Proc.\ FSE},
publisher = {ACM},
pages = {1076--1078},
doi = {},
year = {2016},
}
FSE '16: "Supporting Change in Product ..."
Supporting Change in Product Lines within the Context of Use Case-Driven Development and Testing
Ines Hajri
(University of Luxembourg, Luxembourg)
Product Line Engineering (PLE) is becoming a common practice in industry to enhance product quality, to reduce development costs, and to improve time-to-market. At the same time, many development contexts are use case-driven and this strongly influences their requirements engineering and system testing practices. In this PhD project, we aim to achieve automated and effective change management in a product family within the context of use case-driven development and system testing. To this end, we first provide a modeling method for capturing variability information explicitly in Product Line (PL) use case and domain models. Then, we propose an automated configuration approach to automatically generate Product Specific (PS) use case and domain models from PL models. In addition, we plan to provide a change impact analysis approach for PL use case and domain models and automated regression test selection for system test cases derived from PL use case models.
@InProceedings{FSE16p1082,
author = {Ines Hajri},
title = {Supporting Change in Product Lines within the Context of Use Case-Driven Development and Testing},
booktitle = {Proc.\ FSE},
publisher = {ACM},
pages = {1082--1084},
doi = {},
year = {2016},
}
FSE '16: "Regression Testing of Web ..."
Regression Testing of Web Applications using Record/Replay Tools
Mouna Hammoudi
(University of Nebraska-Lincoln, USA)
Software engineers often use record/replay tools to enable the automated testing of web applications. Tests created in this man- ner can then be used to regression test new versions of the web applications as they evolve. Web application tests recorded by record/replay tools, however, can be quite brittle; they can easily break as applications change. For this reason, researchers have be- gun to seek approaches for automatically repairing record/replay tests. This research investigates different aspects in relation to test- ing web applications using record/replay tools. The areas that we are interested in include taxonomizing the causes behind breakages and developing automated techniques to repair breakages, creating prevention techniques to stop the occurrence of breakages and de- veloping automated frameworks for root cause analysis. Finally, we intend to evaluate all of these activities via controlled studies involving software engineers and real web application tests.
@InProceedings{FSE16p1079,
author = {Mouna Hammoudi},
title = {Regression Testing of Web Applications using Record/Replay Tools},
booktitle = {Proc.\ FSE},
publisher = {ACM},
pages = {1079--1081},
doi = {},
year = {2016},
}
FSE '16: "Understanding and Improving ..."
Understanding and Improving Continuous Integration
Michael Hilton
(Oregon State University, USA)
Continuous Integration (CI) has been widely adopted in the software development industry. However, the usage of CI in practice has been ignored for far too long by the research community. We propose to fill this blind spot by doing in- depth research into CI usage in practice. We will answer how questions by using using quantitative methods, such as investigating open source data that is publicly available. We will answer why questions using qualitative methods, such as semi-structured interviews and large scale surveys. In the course of our research, we plan on identifying barriers that developers face when using CI. We will develop techniques to overcome those barriers via automation. This work is advised by Professor Danny Dig.
@InProceedings{FSE16p1066,
author = {Michael Hilton},
title = {Understanding and Improving Continuous Integration},
booktitle = {Proc.\ FSE},
publisher = {ACM},
pages = {1066--1067},
doi = {},
year = {2016},
}
FSE '16: "On the Utility of Dominator ..."
On the Utility of Dominator Mutants for Mutation Testing
Bob Kurtz
(George Mason University, USA)
Mutation testing has been shown to support the generation of test sets that are highly effective at detecting faults. However, practitioner adoption of mutation testing has been minimal in part because of problems that arise from the huge numbers of redundant and equivalent mutants that are generated. The research described here examines the relationship between mutants and attempts to reduce the number of redundant and equivalent mutants in order to make mutation testing more practical for the software tester.
@InProceedings{FSE16p1088,
author = {Bob Kurtz},
title = {On the Utility of Dominator Mutants for Mutation Testing},
booktitle = {Proc.\ FSE},
publisher = {ACM},
pages = {1088--1090},
doi = {},
year = {2016},
}
FSE '16: "Data Structure Synthesis ..."
Data Structure Synthesis
Calvin Loncaric
(University of Washington, USA)
All mainstream languages ship with libraries implementing lists, maps, sets, trees, and other common data structures. These libraries are sufficient for some use cases, but other applications need specialized data structures with different operations. For such applications, the standard libraries are not enough.
I propose to develop techniques to automatically synthesize data structure implementations from high-level specifications. My initial results on a large class of collection data structures demonstrate that this is possible and lend hope to the prospect of general data structure synthesis. Synthesized implementations can save programmer time and improve correctness while matching the performance of handwritten code.
@InProceedings{FSE16p1073,
author = {Calvin Loncaric},
title = {Data Structure Synthesis},
booktitle = {Proc.\ FSE},
publisher = {ACM},
pages = {1073--1075},
doi = {},
year = {2016},
}
FSE '16: "Input-Sensitive Performance ..."
Input-Sensitive Performance Testing
Qi Luo
(College of William and Mary, USA)
One goal of performance testing is to find specific test input data for exposing performance bottlenecks and identify the methods responsible for these performance bottlenecks. A big and important challenges of performance testing is how to deeply understand the performance behaviors of a nontrivial software system in terms of test input data to properly select the specific test input values for finding the problematic methods. Thus, we propose this research program to automatically analyze performance behaviors in software and link these behaviors with test input data for selecting the specific ones that can expose performance bottlenecks. In addition, this research further examines the corresponding execution traces of selected inputs for targeting the problematic methods.
@InProceedings{FSE16p1085,
author = {Qi Luo},
title = {Input-Sensitive Performance Testing},
booktitle = {Proc.\ FSE},
publisher = {ACM},
pages = {1085--1087},
doi = {},
year = {2016},
}
FSE '16: "Refactoring and Migration ..."
Refactoring and Migration of Cascading Style Sheets: Towards Optimization and Improved Maintainability
Davood Mazinanian
(Concordia University, Canada)
Cascading Style Sheets is the standard styling language, and is extensively used for defining the presentation of web, mobile and desktop applications. Despite its popularity, the language's design shortcomings have made CSS development and maintenance challenging. This thesis aims at developing techniques for safely transforming CSS code (through refactoring, or migration to a preprocessor language), with the goal of optimization and improved maintainability.
@InProceedings{FSE16p1057,
author = {Davood Mazinanian},
title = {Refactoring and Migration of Cascading Style Sheets: Towards Optimization and Improved Maintainability},
booktitle = {Proc.\ FSE},
publisher = {ACM},
pages = {1057--1059},
doi = {},
year = {2016},
}
FSE '16: "Generating Interactive Web ..."
Generating Interactive Web Pages from Storyboards
Pavel Panchekha
(University of Washington, USA)
Web design is a visual art, but web designs are code. Designers work visually and must then manually translate their designs to code. We propose using synthesis to automatically translate the storyboards designers already produce into CSS stylesheets and JavaScript code. To build a synthesis tool for this complex domain, we will use a novel composition mechanism that allows splitting the synthesis task among domain-specific solvers.
We have built a domain-specific solver for CSS stylesheets; solvers for DOM actions and JavaScript code can be built with similar techniques. To compose the three domain-specific solvers, we propose using partial counterexamples to exchange information between different domains. Early results suggest that this composition mechanism is fast and allows specializing each solver to its domain.
@InProceedings{FSE16p1071,
author = {Pavel Panchekha},
title = {Generating Interactive Web Pages from Storyboards},
booktitle = {Proc.\ FSE},
publisher = {ACM},
pages = {1071--1072},
doi = {},
year = {2016},
}
FSE '16: "Automating Repetitive Code ..."
Automating Repetitive Code Changes using Examples
Reudismam Rolim
(Federal University of Campina Grande, Brazil)
While adding features, fixing bugs, or refactoring the code, developers may perform repetitive code edits. Although Integrated Development Environments (IDEs) automate some transformations such as renaming, many repetitive edits are performed manually, which is error-prone and time-consuming. To help developers to apply these edits, we propose a technique to perform repetitive edits using examples. The technique receives as input the source code before and after the developer edits some target locations of the change and produces as output the top-ranked program transformation that can be applied to edit the remaining target locations in the codebase. The technique uses a state-of-the-art program synthesis methodology and has three main components: a) a DSL for describing program transformations; b) synthesis algorithms to learn program transformations in this DSL; c) ranking algorithms to select the program transformation with the higher probability of performing the desired repetitive edit. In our preliminary evaluation, in a dataset of 59 repetitive edit cases taken from real C# source code repositories, the technique performed, in 83% of the cases, the intended transformation using only 2.8 examples.
@InProceedings{FSE16p1063,
author = {Reudismam Rolim},
title = {Automating Repetitive Code Changes using Examples},
booktitle = {Proc.\ FSE},
publisher = {ACM},
pages = {1063--1065},
doi = {},
year = {2016},
}
FSE '16: "Developing a Reusable Control-Based ..."
Developing a Reusable Control-Based Approach to Build Self-Adaptive Software Systems with Formal Guarantees
Stepan Shevtsov
(Linnaeus University, Sweden)
An increasingly important concern of software engineers is handling uncertainty at runtime. Over the last decade researchers have applied architecture-based self-adaptation approaches to address this concern. However, providing guarantees required by current software systems has shown to be challenging with these approaches. To tackle this challenge, we study the application of control theory to realize self-adaptation and develop novel control-based adaptation mechanisms that guarantee desired system properties. Results are validated on systems with strict requirements.
@InProceedings{FSE16p1060,
author = {Stepan Shevtsov},
title = {Developing a Reusable Control-Based Approach to Build Self-Adaptive Software Systems with Formal Guarantees},
booktitle = {Proc.\ FSE},
publisher = {ACM},
pages = {1060--1062},
doi = {},
year = {2016},
}