FSE 2016- Proceedings of the 2016 24th ACM SIGSOFT International Symposium on Foundations of Software Engineering

Full Citation in the ACM Digital Library

SESSION: Keynotes

"Womenomics" and gender-inclusive software: what software engineers need to know (invited talk)

Building a socio-technical theory of coordination: why and how (outstanding research award)

Correct or usable? the limits of traditional verification (impact paper award)

SESSION: Showcases

Continuous deployment of mobile software at facebook (showcase)

Model, execute, and deploy: answering the hard questions in end-user programming (showcase)

Making invisible things visible: tracking down known vulnerabilities at 3000 companies (showcase)

Developer workflow at google (showcase)

SESSION: Research Papers

Titanium: efficient analysis of evolving alloy specifications

Mining performance specifications

Designing minimal effective normative systems with the help of lightweight formal methods

Proteus: computing disjunctive loop summary via path dependency analysis

A cross-tool communication study on program analysis tool notifications

Factors influencing code review processes in industry

Foraging and navigations, fundamentally: developers' predictions of value and cost

How to break an API: cost negotiation and community values in three software ecosystems

Python predictive analysis for bug detection

Crash consistency validation made easy

Discovering bug patterns in JavaScript

Effort-aware just-in-time defect prediction: simple unsupervised models could be better than supervised models

Detecting sensitive data disclosure via bi-directional text correlation analysis

Multi-representational security analysis

String analysis for side channels with segmented oracles

WebRanz: web page randomization for better advertisement delivery and web-bot prevention

A discrete-time feedback controller for containerized cloud applications

Keep it SIMPLEX: satisfying multiple goals with guarantees in control-based self-adaptive systems

Automated change impact analysis between SysML models of requirements and design

Parameter-free probabilistic API mining across GitHub

API deprecation: a retrospective analysis and detection method for code examples on the web

When should internal interfaces be promoted to public?

POLLUX: safely upgrading dependent application libraries

Extracting instruction semantics via symbolic execution of code generators

Efficient generation of inductive validity cores for safety properties

Correctness witnesses: exchanging verification results between verifiers

SMT-based verification of parameterized systems

On-the-fly decomposition of specifications in software model checking

On well-separation of GR(1) specifications

Lightweight specification and analysis of dynamic systems with rich configurations

Gray links in the use of requirements traceability

Understanding and detecting wake lock misuses for Android applications

DiagDroid: Android performance diagnosis via anatomizing asynchronous executions

Minimizing GUI event traces

Causal impact analysis for app releases in google play

Static DOM event dependency analysis for testing web applications

On-demand strong update analysis via value-flow refinement

Call graph construction for Java libraries

Revamping JavaScript static analysis via localization and remediation of root causes of imprecision

What would users change in my app? summarizing app reviews for recommending software changes

API code recommendation using statistical learning from fine-grained changes

TIPMerge: recommending experts for integrating changes across branches

Interactive and guided architectural refactoring with search-based recommendation

Can testedness be effectively measured?

A large-scale empirical comparison of static and dynamic test case prioritization techniques

Analyzing the validity of selective mutation with dominator mutants

An extensive study of static regression test selection in modern software evolution

PerfGuard: binary-centric application performance monitoring in production environments

Python probabilistic type inference with natural language support

Detecting and fixing precision-specific operations for measuring floating-point errors

Deep API learning

Build system with lazy retrieval for Java projects

iGen: dynamic interaction inference for configurable software

CacheOptimizer: helping developers configure caching frameworks for hibernate-based database-centric web applications

BinGo: cross-architecture cross-OS binary search

Relationship-aware code search for JavaScript frameworks

Code relatives: detecting similarly behaving software

Understanding and generating high quality patches for concurrency bugs

Anti-patterns in search-based program repair

Semi-supervised verified feedback generation

WATERFALL: an incremental approach for repairing record-replay tests of web applications

Efficiency of projectional editing: a controlled experiment

ECHO: instantaneous in situ race detection in the IDE

Detecting table clones and smells in spreadsheets

Flow-sensitive composition of thread-modular abstract interpretation

A deployable sampling strategy for data race detection

Online shared memory dependence reduction via bisectional coordination

Parallel data race detection for task parallel programs with locks

Paradise unplugged: identifying barriers for female participation on stack overflow

Why we refactor? confessions of GitHub contributors

Effectiveness of code contribution: from patch-based to pull-request-based tools

Isomorphic regression testing: executing uncovered branches without test augmentation

Directed test generation to detect loop inefficiencies

Field-exhaustive testing

SESSION: Visions and Reflections

Sustainable software design

Designing for dystopia: software engineering research for the post-apocalypse

Disrupting developer productivity one bot at a time

Training the future workforce through task curation in an OSS ecosystem

Reaching the masses: a new subdiscipline of app programmer education

Studying developer gaze to empower software engineering research and practice

DeepSoft: a vision for a deep model of software

Budgeted testing through an algorithmic lens

Reasoning with imprecise privacy preferences

SESSION: Industrial Papers

Bing developer assistant: improving developer productivity by recommending sample code

Cluster-based test suite functional analysis

A portable interface for runtime energy monitoring

Learning for test prioritization: an industrial case study

Combinatorial generation of structurally complex test inputs for commercial software applications

Automated test input generation for Android: are we really there yet in an industrial case?

SESSION: Tool Demonstrations

NonDex: a tool for detecting and debugging wrong assumptions on Java API specifications

TIPMerge: recommending developers for merging branches

Time-travel debugging for JavaScript/Node.js

PUMConf: a tool to configure product specific use case and domain models in a product line

T2API: synthesizing API code usage templates from English texts with statistical translation

JBSE: a symbolic executor for Java programs with complex heap inputs

ARdoc: app reviews development oriented classifier

Hunter: next-generation code reuse for Java

BigDebug: interactive debugger for big data analytics in Apache Spark

Visualizing code and coverage changes for code review

End-to-end memory behavior profiling with DINAMITE

Validate your SPDX files for open source license violations

FSX: a tool for fine-grained incremental unit test generation for C/C++ programs

SESSION: Doctoral Symposium

Refactoring and migration of cascading style sheets: towards optimization and improved maintainability

Developing a reusable control-based approach to build self-adaptive software systems with formal guarantees

Automating repetitive code changes using examples

Understanding and improving continuous integration

Guided code synthesis using deep neural networks

Generating interactive web pages from storyboards

Data structure synthesis

Understanding behavioural patterns in JavaScript

Regression testing of web applications using Record/Replay tools

Supporting change in product lines within the context of use case-driven development and testing

Input-sensitive performance testing

On the utility of dominator mutants for mutation testing

SESSION: Graduate Submissions

Effective assignment and assistance to software developers and reviewers

RABIEF: range analysis based integer error fixing

Fine-grained binary code authorship identification

Identifying participants for collaborative merge

Cozy: synthesizing collection data structures

Constraint-based event trace reduction

Automatic trigger generation for end user written rules for home automation

Hotspot symbolic execution of floating-point programs

Evaluation of fault localization techniques

How should static analysis tools explain anomalies to developers?

Repairing test dependence

Combining bug detection and test case generation

SmartDebug: an interactive debug assistant for Java

Static loop analysis and its applications

Social health cues developers use when choosing open source packages

Finding and breaking test dependencies to speed up test execution

Automatic performance testing using input-sensitive profiling

SESSION: Undergraduate Submissions

Enforcing correct array indexes with a type system

Discovering additional violations of Java API invariants

Preventing signedness errors in numerical computations in Java

Bounded model checking of state-space digital systems: the impact of finite word-length effects on the implementation of fixed-point digital controllers based on state-space modeling

Atlas: an intelligent, performant framework for web-based grid computing