Contact: ICPC 2016      May 16-17, 2016      Renaissance Austin Hotel 9721 Arboretum Boulevard Austin, Texas 78759 USA


Next Event: ICPC’17

Program - ICPC 2016


Monday, May 16

9:00 - 10:30 am

ICPC 2016 Opening   Slides

Room: Trinity | Session Chairs: Jonathan I. Maletic and Gabriele Bavota

Keynote: Better Code   Info | Slides

Sean Parent, Adobe Systems

10:30 - 11:00 am

Coffee Break

11:00 - 12:30 pm

Technical Research 1: Code Quality   PDFLink

Room: Trinity | Session Chair: Michele Lanza

A Textual-based Technique for Smell Detection   | PDFLink

Fabio Palomba, Annibale Panichella, Andrea De Lucia, Rocco Oliveto, and Andy Zaidman

In this paper, we present TACO (Textual Analysis for Code Smell Detection), a technique that exploits textual analysis to detect a family of smells of different nature and different levels of granularity. We run TACO on 10 open source projects, comparing its performance with existing smell detectors purely based on structural information extracted from code components. The analysis of the results indicates that TACO’s precision ranges between 67% and 77%, while its recall ranges between 72% and 84%. Also, TACO often outperforms alternative structural approaches confirming, once again, the usefulness of information that can be derived from the textual part of code components.

Context-Based Code Smells Prioritization for Prefactoring   | PDFLink

Natthawute Sae-Lim, Shinpei Hayashi, and Motoshi Saeki

To find opportunities for applying prefactoring, several techniques for detecting bad smells in source code have been proposed. Existing smell detectors are often unsuitable for developers who have a specific context because these detectors do not consider their current context and output the results that are mixed with both smells that are and are not related to such context. Consequently, the developers must spend a considerable amount of time identifying relevant smells. As described in this paper, we propose a technique to prioritize bad code smells using developers’ context. The explicit data of the context are obtained using a list of issues extracted from an issue tracking system. We applied impact analysis to the list of issues and used the results to specify which smells are associated with the context. Consequently, our approach can provide developers with a list of prioritized bad code smells related to their current context. Several evaluations using open source projects demonstrate the effectiveness of our technique.

Do Code Smells Hamper Novice Programming? A Controlled Experiment on Scratch Programs   | PDFLink

Felienne Hermans and Efthimia Aivaloglou

Recently, block-based programming languages like Alice, Scratch and Blockly have become popular tools for programming education. There is substantial research showing that block-based languages are suitable for early programming education. But can block-based programs be smelly too? And does that matter to learners? In this paper we explore the code smells metaphor in the context of block-based programming language Scratch. We conduct a controlled experiment with 61 novice Scratch programmers, in which we divided the novices into three groups. One third receive a non-smelly program, while the other groups receive a program suffering from the Duplication or the Long Method smell respectively. All subjects then perform the same comprehension tasks on their program, after which we measure their time and correctness. The results of the experiment show that code smell indeed influence performance: subjects working on the program exhibiting code smells perform significantly worse, but the smells did not affect the time subjects needed. Investigating different types of tasks in more detail, we find that Long Method mainly decreases system understanding, while Duplication decreases the ease with which subjects modify Scratch programs.

LinkImproving Code Readability Models with Textual Features   | PDFLink

Simone Scalabrino, Mario Linares-Vásquez, Denys Poshyvanyk, and Rocco Oliveto

Code reading is one of the most frequent activities in software maintenance; before implementing changes, it is necessary to fully understand source code often written by other developers. Thus, readability is a crucial aspect of source code that may significantly influence program comprehension effort. In general, models used to estimate software readability take into account only structural aspects of source code, e.g., line length and a number of comments. However, source code is a particular form of text; therefore, a code readability model should not ignore the textual aspects of source code encapsulated in identifiers and comments. In this paper, we propose a set of textual features aimed at measuring code readability. We evaluated the proposed textual features on 600 code snippets manually evaluated (in terms of readability) by 5K+ people. The results demonstrate that the proposed features complement classic structural features when predicting code readability judgments. Consequently, a code readability model based on a richer set of features, including the ones proposed in this paper, achieves a significantly higher accuracy as compared to all of the state-of-the-art readability models.

12:30 - 2:00 pm

Lunch Break

2:00 - 3:30 pm

Technical Research 2: Program Comprehension   PDFLink

Room: Trinity | Session Chair: Romain Robbes

Multistaging to Understand: Distilling the Essence of Java Code Examples   | PDFLink

Huascar Sanchez, Jim Whitehead, and Martin Schaef

Programmers commonly search the Web to find code examples that can help them solve a specific programming task. While some novice programmers may be willing to spend as much time as needed to understand a found code example, more experienced ones want to spend as little time as possible. They want to get a quick overview of the example’s operation, so they can start working with it immediately. Getting this overview is often non-trivial and requires a tedious and manual inspection process. In this paper, we introduce a technique called Multistaging to Understand, which streamlines this inspection process by distilling the essence of code examples. The essence of a code example conveys the most important aspects of the example’s intended function. Our technique automatically decomposes the code in an example into code stages that can be explored non-sequentially; enabling fast exploratory learning. We discuss the key components of our technique and describe empirical results based on actual code examples on StackOverflow.

Navigating the WordPress Plugin Landscape   | PDFLink

Mark Hills

WordPress includes a plugin mechanism that allows user-provided code to be executed in response to specific system events and input/output requests. The large number of extension points provided by WordPress makes it challenging for new plugin developers to understand which extension points they should use, while the thousands of existing plugins make it hard to find existing extension point handler implementations for use as examples when creating a new plugin. In this paper, we present a lightweight analysis, supplemented with information mined from source comments and the webpages hosted by WordPress for each plugin, that guides developers to the right extension points and to existing implementations of handlers for these extension points. We also present empirical information about how plugins are used in practice, providing guidance to both tool and prospective plugin developers.

A Case Study of Program Comprehension Effort and Technical Debt Estimations   | PDFLink

Vallary Singh, Lori Pollock, Will Snipes, and Nicholas A. Kraft

This paper describes a case study of using developer activity logs as indicators of a program comprehension effort by analyzing temporal sequences of developer actions (e.g., navigation and edit actions). We analyze developer activity data spanning 109,065 events and 69 hours of work on a medium-sized industrial application. We examine potential correlations between different measures of developer activity, code change metrics and code smells to gain insight into questions that could direct future technical debt interest estimation. To gain more insights into the data, we follow our analysis with commit message analysis and a developer interview. Our results indicate that developer activity as an estimate of program comprehension effort is correlated with both change proneness and static metrics for code smells.

On Method Ordering   | PDFLink

Yorai Geffen and Shahar Maoz

As the order of methods in a Java class has no effect on its semantics, an engineer can choose any order she prefers. Which code conventions regarding methods ordering are common in practice, if any? Are some orders better than others in making the code easier to understand? Can good orders be computed and applied automatically?

3:30 - 4:00 pm

Coffee Break

4:00 - 5:30 pm

Technical Research 3: Supporting Software Developers   PDFLink

Room: Trinity | Session Chair: Denys Poshyvanyk

Identifying Modularization Patterns by Visual Comparison of Multiple Hierarchies   | PDFLink

Fabian Beck, Jan Melcher, and Daniel Weiskopf

Software is modularized to make its high complexity manageable. However, a multitude of modularization criteria exists and is applied. Hence, to extend, reuse, or restructure a system, it is important for developers to understand which criteria have been used. To this end, we provide an interactive visualization approach that compares the current modularization of a system to several software clustering results. The visualization is based on juxtaposed icicle plot representations of the hierarchical modularizations, encoding similarity by color. A detailed comparison is facilitated by an advanced selection concept. Coupling graphs, which form the basis for software clustering, can be explored on demand in matrix representations. We discuss typical modularization patterns that indicate criteria used for structuring the software or suggest opportunities for partial remodularization of the system. We apply the approach to analyze 16 open source Java projects. The results show that identifying those modularization patterns provides valuable insights and can be done efficiently.

Glyph-Based Software Component Identification   | PDFLink

Ignacio Fernandez, Alexandre Bergel, Juan Pablo Sandoval Alcocer, Alejandro José Infante Rica, and Tudor Girba

Glyphs are automatically generated visual icons, commonly employed as an object identification technique. Although popular in the Human Computer Interaction community, glyphs are rarely employed to address software engineering problems.

We extended the VisualID glyph technique to cope with structural software elements and used it to address two issues in software maintenance: identify classes with the same dependencies and classes with a similar set of methods. We have compared VisualID against three visual representations: textual, graph (nodes and edges), and dependency structural matrix. Our experiments indicate that VisualID significantly helps identify classes with the same dependencies and classes with similar methods when compared with visual techniques commonly used in software maintenance.

Taming the IDE with Fine-grained Interaction Data   | PDFLink

Roberto Minelli, Andrea Mocci, Romain Robbes, and Michele Lanza

Integrated Development Environments (IDEs) lack effective support to browse complex relationships between source code elements. As a result, developers are often forced to exploit multiple user interface components at the same time, bringing the IDE into a complex, “chaotic” state. Keeping track of these relationships demands increased source code navigation and cognitive load, leading to productivity deficits documented in observational studies. Beyond small-scale studies, the amount and nature of the chaos experienced by developers in the wild is unclear, and more importantly it is unclear how to tame it.

Based on a dataset of fine-grained interaction data, we propose several metrics to characterize and quantify the “level of chaos” of an IDE. Our results suggest that developers spend, on average, more than 30% of their time in a chaotic environment, and that this may affect their productivity. To support developers, we devise and evaluate simple strategies that automatically alter the UI of the IDE. We find that even simple strategies may considerably reduce the level of chaos both in terms of effective space occupancy and time spent in a chaotic environment.

Learning to Rank for Bug Report Assignee Recommendation   | PDFLink

Yuan Tian, Dinusha Wijedasa, David Lo, and Claire Le Goues

Projects receive a large number of bug reports, and resolving these reports take considerable time and human resources. To aid developers in the resolution of bug reports, various automated techniques have been proposed to identify and recommend developers to address newly reported bugs. Two families of bug assignee recommendation techniques include those that recommend developers who have fixed similar bugs before (a.k.a. activity-based techniques) and those recommend suitable developers based on the location of the bug (a.k.a. location-based techniques). Previously, each of these techniques has been investigated separately.

In this work, we propose a unified model that combines information from both developers’ previous activities and suspicious program locations associated with a bug report in the form of similarity features. We have evaluated our proposed approach on more than 11,000 bug reports from Eclipse JDT, Eclipse SWT and ArgoUML projects. Our experiments show that our unified model can outperform a location-based baseline by Anvik et al. and an activity-based baseline by Shokripour et al. In terms of correct recommendations at top-1 position, our unified model outperforms the activity-based baseline 50.0%-100.0%, and the location-based baseline by 11.1%-27.0%.

6:30 - 7:00 pm

Meet for walk to Banquet

7:00 pm

Banquet: North By Northwest Stonelake, 10010 N Capital of TX Hwy, Austin, TX 78759

Tuesday, May 17

9:00 - 10:15 am

Most Influential Paper Slides

Room: Trinity | Session Chairs: Jonathan I. Maletic and Gabriele Bavota

What's in a Name? A Study of Identifiers (ICPC’06)   | Info | PDFLink | Slides

Dawn Lawrie, Christopher Morrell, Henry Feild, and David Binkley

ICPC’06 Abstract

Readers of programs have two main sources of domain information: identifier names and comments. When functions are uncommented, as many are, comprehension is almost exclusively dependent on the identifier names. Assuming that writers of programs want to create quality identifiers (e.g., include relevant domain knowledge) how should they go about it? For example, do the initials of a concept name provide enough information to represent the concept? If not, and a longer identifier is needed, is an abbreviation satisfactory or does the concept need to be captured in an identifier that includes full words? Results from a study designed to investigate these questions are reported. The study involved over 100 programmers who were asked to describe twelve different functions. The functions used three different "levels" of identifiers: single letters, abbreviations, and full words. Responses allow the level of comprehension associated with the different levels to be studied. The functions include standard algorithms studied in computer science courses as well as functions extracted from production code. The results show that full word identifiers lead to the best comprehension; however, in many cases, there is no statistical difference between full words and abbreviation

10:15 - 10:30 am

Tool Demonstration Introduction

10:30 - 11:00 am

Coffee Break

11:00 - 12:30 pm

Tool Demonstrations   PDFLink

Room: Trinity | Session Chair: Felienne Hermans

FeedBaG: An Interaction Tracker for Visual Studio   | PDFLink

Sven Amann, Sebastian Proksch, and Sarah Nadi

Integrated Development Environments (IDEs) provide a convenient standalone solution that supports developers during various phases of software development. In order to provide better support for developers within such IDEs, we need to understand how developers use them. To infer useful conclusions, such information should be gathered for different types of IDEs, for different programming languages, and in different development settings.

In this paper, we present FEEDBAG, an extension for Visual Studio that tracks developers’ interactions with the IDE. FEED-BAG generates a rich stream of interaction events and provides means for developers to review and submit the data to a server. We recently used the tool in a study, recording more than 6,300 hours of work time. Future studies with different user groups are needed to explore and compare IDE-usage aspects, like code-comprehension assistance, in detail. Therefore, we publish FEEDBAG and encourage other researchers to use it as well.

InfectoMeter: A Tool that Helps to Place Bug Fixes   | PDFLink

Mohammad Azadmanesh and Matthias Hauswirth

Given different ways to fix a failure in a program run, you may want to fix it such that future runs of the same

LinkInline: Now You're Coding with Portals   | PDFLink

Alexander Breckel and Matthias Tichy

Programmers use diverse tools for code understanding to access various types of context information like interface definitions, revision histories, and debugging values. Integrated development environments support specialized visualization mechanisms for such context types. While these mechanisms in principle enable programmers to access required information, the diversity of visualizations as well as the distance between code locations and related information may slow down development. We present a generic approach to embed various types of context uniformly into the main source code view in close proximity to the relevant source code by using a concept called code portals. Furthermore, embedded content can be organized and manipulated directly using operations already familiar to programmers. We illustrate the approach using different types of context, and present preliminary results of a qualitative study indicating that our approach is usable and improves program comprehension and productivity in general. The approach is implemented in a prototypical source code editor.

WAVI: A Reverse Engineering Tool for Web Applications   | PDFLink

Jonathan Cloutier, Sègla Kpodjedo, and Ghizlane El Boussaidi

Web developers face some unique challenges when trying to understand, modify and document the structure of their web applications. The heterogeneity and complexity of the underlying technologies and languages heighten comprehension problems. In particular, JavaScript, as an essential part of the Web ecosystem, is a language that offers a flexibility that can make its code hard to grasp, when it comes to comprehension and documentation tasks. In this paper, we present the first iteration of WAVI (WebAppViewer), a reverse engineering tool that uses static analysis and a filter-based mechanism to retrieve and document the structure of a Web application. WAVI is able to extract elements coming from essential web languages and frameworks such as HTML, JavaScript, CSS and Node.js. The tool makes use of some simple, effective heuristics to accurately retrieve dependency links for files and methods. WAVI also offers the visualisation of the extracted information as force-directed graphs and customized class diagrams. The effectiveness of WAVI is evaluated with experiments that demonstrate that (i) it can resolve JavaScript calls better than a recent technique, and (ii) its visualisation modules are intuitive and scalable.

PORBS: A Parallel Observation-based Slicer   | PDFLink

Syed Islam and Dave Binkley

This paper presents PORBS, a parallelised observation-based slicing tool. The tool itself is written in Java making it platform independent and leverages the build chain of the system being sliced to avoid the need to replicate complex compiler analysis. The target audience of PORBS is software engineers and researchers working with and on tools and techniques for software comprehension, debugging, re-engineering, and maintenance.

STAC: A Tool for Static Textual Analysis of Code   | PDFLink

Saket Khatiwada, Michael Kelly, and Anas Mahmoud

Static textual analysis techniques have been recently applied to process and synthesize source code. The underlying tenet is that important information is embedded in code identifiers and internal code comments. Such information can be analyzed to provide automatic aid for several software engineering activities. To facilitate this line of work, we present STAC, a tool for supporting Static Textual Analysis of Code. STAC is designed as a light-weight stand-alone tool that provides a practical one-stop solution for code indexing. Code indexing is the process of extracting important textual information from source code. Accurate indexing has been found to significantly influence the performance of code retrieval and analysis methods. STAC provides features for extracting and processing textual patterns found in Java, C++, and C# code artifacts. These features include identifier splitting, stemming, lemmatization, and spell-checking. STAC is also provided as an API to help researchers to integrate basic code indexing features into their code.

Hey! Are You Injecting Side Effect?: A Tool for Detecting Purity Changes in Java Methods   | PDFLink

Naoto Ogura, Jiachen Yang, Keisuke Hotta, Yoshiki Higo, and Shinji Kusumoto

Methods not having side effects (pure methods) are beneficial in some situations. For example, data race does not occur among pure methods in multi-thread programs. Another example is that there are some cases where developers expect methods are pure, such as equals, hashCode, and getter methods in Java. This paper presents a tool finding code changes where methods become pure/impure. This tool can prevent developers from inducing purity-related bugs to methods. The authors have applied the tool to two open source systems and found (1) a dozen of methods moved to pure/impure repeatedly and (2) there were many cases where purity of methods had changed without code changes.

WB4SP: A Tool to Build the Word Base for Specific Programs   | PDFLink

Weisong Sun, Xiaobing Sun, Hui Yang, and Bin Li

Software becomes increasingly complex with its continuous maintenance activities. Given a system under maintenance, developers used to employing code search techniques to locate the code of their interests. However, they may have difficulties in understanding the source code elements and the relationship among them in the searching results. If there is a word base for a specific system, the developers can refer it to help locate and recover the source code elements and their relationships, which can improve the maintenance efficiency. In this paper, we present a tool, WB4SP(Word Base for Specific Programs), which focuses on building the word base for a specific system. WB4SP can retrieve the words, recover the relationship between them, and display the evolution of these words during the software evolution.

Short Papers 1: Getting Deep Insight into Your Software   PDFLink

Room: Pecos | Session Chair: Bogdan Dit

Investigating the Android Apps' Success: An Empirical Study   | PDFLink

Latifa Guerrouj and Olga Baysal

Measuring the success of software systems was not a trivial task in the past. Nowadays, mobile apps provide a uniform schema, i.e., the average ratings provided by the apps’ users to gauge their success. While recent research has focused on examining the relationship between change- and fault- proneness and apps’ lack of success, as well as qualitatively analyzing the reasons behind the apps’ users dissatisfaction, there is little empirical evidence on the factors related to the success of mobile apps. In this paper, we explore the relationships between the mobile apps’ success and a set of metrics that not only characterize the apps themselves but also the quality of the APIs used by the apps, as well as user attributes when they interact with the apps. In particular, we measure API quality in terms of bugs fixed in APIs used by apps and changes that occurred in the API methods. We examine different kinds of changes including changes in the interfaces, implementation, and exception handling. For user-related factors, we leverage the number of app’s downloads and installations, and users’ reviews. Through an empirical study of 474 free Android apps, we find that factors such as the number of users’ reviews provided for an app, app’s category and size appear to have an impact on the app’s success.

Retrofitting Automatic Testing through Library Tests Reusing   | PDFLink

Lei Ma, Cheng Zhang, Bing Yu, and Jianjun Zhao

Test cases are useful for program comprehension. Developers often understand dynamic behavior of systems by running their test cases. As manual testing is expensive, automatic testing has been extensively studied to reduce the cost. However, without sufficient knowledge of the software under test, it is difficult for automated testing techniques to create effective test cases, especially for software that requires complex inputs.

In this paper, we propose to reuse existing test cases from the libraries of software under test, to generate better test cases. We have the observation that, when developers start to test the target software, the test cases of its dependent libraries are often available. Therefore, we propose to perform program analysis on these artifacts to extract relevant code fragments to create test sequences. We further seed these sequences to a random test generator GRT to generate test cases for target software. The preliminary experiments show that the technique significantly improves the effectiveness of GRT. Our in-depth analysis reveals that several dependency metrics are good indicators of the potential benefits of applying our technique on specific programs and their libraries.

Measuring Energy Footprint of Software Features   | PDFLink

Syed Islam, Adel Noureddine, and Rabih Bashroush

With the proliferation of Software systems and the rise of paradigms such the Internet of Things, Cyber-Physical Systems and Smart Cities to name a few, the energy consumed by software applications is emerging as a major concern. Hence, it has become vital that software engineers have a better understanding of the energy consumed by the code they write. At software level, work so far has focused on measuring the energy consumption at function and application level. In this paper, we propose a novel approach to measure energy consumption at a feature level, cross-cutting multiple functions, classes and systems. We argue the importance of such measurement and the new insight it provides to non-traditional stakeholders such as service providers. We then demonstrate, using an experiment, how the measurement can be done with a combination of tools, namely our program slicing tool (PORBS) and energy measurement tool (Jolinar).

Human-Machine Resolution of Invisible Control Flow   | PDFLink

Suraj Kothari, Ahmed Tamrawi, and Jon Mathews

Abstract—Invisible Control Flow (ICF) results from dynamic binding and asynchronous processing. For modern software replete with ICF, the ability to analyze and resolve ICF is crucial for verifying software. A fully automated analysis to resolve ICF suffers from imprecision and high computational complexity. As a practical alternative, we present a novel solution of interactive human-machine collaboration to resolve ICF.

Our approach is comprised of interactive program analysis and comprehension to systematically capture and link the clues crucial for resolving ICF. We present the tool support we have developed using the query language and visualization capabilities of the Atlas Platform. We illustrate the approach using examples where resolving ICF is crucial to verify software and show a complex bug in the Linux kernel discovered by resolving ICF.

Extracting Configuration Parameter Interactions using Static Analysis   | PDFLink

Chelsea Metcalf, Farhaan Fowze, Tuba Yavuz, and Jose Fortes

Complex software systems come with a huge number of configuration parameters for tuning their performance as well as functionality. It is a challenge for the users of such systems to understand how various parameters interact, and causing them to use the default configuration settings to avoid problems. Studies show that a lot of performance optimization opportunities are missed when complex software systems are run with the default configuration settings. This paper proposes a graph-based representation of configuration parameter interactions that are extracted using a scaleable static analysis approach. Experimental results obtained with a case study on a data analysis framework, Apache Hadoop, suggest that the proposed approach is effective in capturing some of the interactions at the component level.

Android Build Dependency Analysis   | PDFLink

Bo Zhang, Vasil Tenev, and Martin Becker

In order to derive executable software artefacts, the build system needs to be maintained properly along with the evolution of source code. However, in large software projects the building process often becomes effort-consuming, and sometimes the building process contains defects or even fails. To cope with these challenges, the first step is to understand the build process. In this paper, we take Android as the example system, and propose an automated approach to analyzing the Android build dependency structure (including extraction of building jobs, related artefacts, duration, etc.). Moreover, the analysis results of Android 5 and 6 are compared in order to identify build differences between these two releases. The extracted build dependencies and comparison results are also visualized with tool support. As the analysis approach and tools are not limited to Android, it can be also used for extracting the build dependency structure of other systems.

12:30 - 2:00 pm

Lunch Break

2:00 - 3:30 pm

Technical Research 4: Language Usage   PDFLink

Room: Trinity | Session Chair: Collin McMillan

Can We Find Stable Alternatives for Unstable Eclipse Interfaces?   | PDFLink

Simon Kawuma, John Businge, and Engineer Bainomugisha

The Eclipse framework is a popular and widely adopted framework that has been evolving for over a decade. Like many other evolving software systems, the Eclipse framework provides both stable and supported interfaces (APIs) and unstable, discouraged, and unsupported interfaces (non-APIs). However, despite being discouraged by Eclipse, the usage of bad interfaces is not uncommon. Our previous research has confirmed that as Eclipse states, indeed APIs are stable while non-APIs are unstable. Applications using non-APIs face compatibility challenges in new Eclipse releases. Furthermore, our previous studies further revealed that the reason why application developers use the unstable interfaces is because they cannot find stable interfaces with the functionality that they require. Moreover, in a study we conducted, Eclipse application developers stated that they manually find the functionality from Eclipse. Eclipse being a very large complex software system with a large number of committers, we hypothesize that as developers manually search for the functionality they they require, it is possible that they miss stable interfaces offering the same functionality. To this end, using code clone detection techniques, we analyzed 18 major releases of Eclipse for possible clones. Our findings are three fold: i) we discover that indeed there exist clones in Eclipse, ii) we also discovered that some of the identified clones originate from different Eclipse projects, iii) our findings reveal that there is no significant number of APIs (less than 1%) offering the same or similar functionality as the non-APIs in all Eclipse releases we studied. This reveals that there are very few syntactic clones between API and non-API, thus developers were forced to either use non-API or find an API that exists, that is similar in functionality, but not in syntax.

A Cooperative Approach for Combining Client-based and Library-based API Usage Pattern Mining   | PDFLink

Mohamed Aymen Saied and Houari Sahraoui

Software developers need to cope with the complexity of Application Programming Interfaces (APIs) of external libraries or frameworks. Typical APIs provide thousands of methods to their client programs, and these methods are not used independently of each other. Much existing work has provided different techniques to mine API usage patterns based on client programs in order to help developers understanding and using existing libraries. Other techniques propose to overcome the strong constraint of clients’ dependency and infer API usage patterns only using the library source code. In this paper, we propose a cooperative usage pattern mining technique (COUPminer) that combines client-based and library-based usage pattern mining. We evaluated our technique through four APIs and the obtained results show that the cooperative approach allows taking advantage at the same time from the precision of client-based technique and from the generalizability of library-based techniques.

A Novel Approach for Estimating Truck Factors   | PDFLink

Guilherme Avelino, Leonardo Passos, Andre Hora, and Marco Tulio Valente

Truck Factor (TF) is a metric proposed by the agile community as a tool to identify concentration of knowledge in software development environments. It states the minimal number of developers that have to be hit by a truck (or quit) before a project is incapacitated. In other words, TF helps to measure how prepared is a project to deal with developer turnover. Despite its clear relevance, few studies explore this metric. Altogether there is no consensus about how to calculate it, and no supporting evidence backing estimates for systems in the wild. To mitigate both issues, we propose a novel (and automated) approach for estimating TF-values, which we execute against a corpus of 133 popular project in GitHub. We later survey developers as a means to assess the reliability of our results. Among others, we find that the majority of our target systems (65%) have TF ≤ 2. Surveying developers from 67 target systems provides confidence towards our estimates; in 84% of the valid answers we collect, developers agree or partially agree that the TF’s authors are the main authors of their systems; in 53% we receive a positive or partially positive answer regarding our estimated truck factors.

Can We Enforce a Benefit for Dynamically Typed Languages in Comparison to Statically Typed Ones? A Controlled Experiment   | PDFLink

Sebastian Okon and Stefan Hanenberg

There are a number of experiments that show a benefit for statically typed programming languages. However, it is unclear whether these results are mainly driven by the expectations that developers do benefit from static type systems, i.e. whether the results reflect on the experimenters’ bias. From that perspective, it seems consequent to design an experiment that tries to reveals the opposite: to enforce a benefit for dynamically typed languages. This paper describes an experiment that tries to enforce such a benefit for dynamically typed languages in an experimental setting. Four (quite artificial) tasks were designed from which the experimenters expected to measure a clear benefit for dynamically typed languages. However, only in two cases such a benefit could be measured. What is even more interesting is that two other tasks (again, explicitly designed to show a benefit for dynamically typed languages) showed the opposite.

Short Papers 2: Comprehension You Can Use   PDFLink

Room: Pecos | Session Chair: Latifa Guerrouj

Software Development and Tool Usability   | PDFLink

Brian Dillon and Richard Thompson

Tools are used at every stage of the software life cycle with particular recent emphasis on the maintenance period. Evidence shows that maintenance tools are underused, even by the developers who create them. Integrated development environments were created to empower developers, but they have remained virtually unchanged since the late 1990s. This paper examines the challenges of creating development tools, analyzes the usability of two frequently used tools, and suggests that poor tool usability may be inhibiting more efficient software development.

Detecting Exploratory Programming Behaviors for Introductory Programming Exercises   | PDFLink

Erina Makihara, Hiroshi Igaki, Norihiro Yoshida, Kenji Fujiwara, and Hajimu Iida

Developers often perform the repeating cycle of implementation and evaluation when they need to deal with the unfamiliar portion of the source code. This cycle is named as exploratory programming. We regard exploratory programming as an effective way not only to improve novice’s programming skill but also to support educators in programming exercise in University. Because when novices often use the exploratory programming, it means novices struggle to solve their assignments. Therefore, educators should grasp which elements, APIs or blocks novices often used exploratory programming for. In this paper, firstly we propose the definition of novice’s exploratory programming to collect logs of exploratory based on various granularity by novices. Secondly, we propose an algorithm based on our proposed definition to automatically detect exploratory programming behaviors. We also conducted a small case study. As a result of automatic detection, our proposed algorithm allows us to know what elements of program novices often feel difficult and struggle for.

Embedding Programming Context into Source Code   | PDFLink

Alexander Breckel and Matthias Tichy

Programmers use diverse tools for code understanding to access various types of context information like interface definitions, revision histories, and debugging values. Integrated development environments support specialized visualization mechanisms for such context types. While these mechanisms in principle enable programmers to access required information, the diversity of visualizations as well as the distance between code locations and related information may slow down development. We present a generic approach to embed various types of context uniformly into the main source code view in close proximity to the relevant source code by using a concept called code portals. Furthermore, embedded content can be organized and manipulated directly using operations already familiar to programmers. We illustrate the approach using different types of context, and present preliminary results of a qualitative study indicating that our approach is usable and improves program comprehension and productivity in general. The approach is implemented in a prototypical source code editor.

Synchronized Static and Dynamic Visualization in a Web-Based Programming Environment   | PDFLink

Jeong Yang, Young Lee, and David Hicks

This paper presents an approach of static and dynamic visualizations synchronized along with source code in a web-based programming environment, JavelinaCode. Using JavelinaCode, student programmers can write Java programs directly in a frontend web browser without any software or plug-in installation. They are provided with a view of the static state of a Java program in UML class diagrams and the dynamic runtime state of the program by stepping forwards and backwards through program execution. A case study has revealed that our approach is useful, in particular, to trace and detect an object flow anomaly caused by method overriding and polymorphism. A preliminary comparison test result also has shown that through our web-based platform-independent environment, student programmers are freed from concern with continuous version changes and evolutions of the Java language, plug-ins, and operating systems.

Case Studies of Optimized Sequence Diagram for Program Comprehension   | PDFLink

Madhusudan Srinivasan, Jeong Yang, and Young Lee

In large project, source code becomes increasing complex and lengthy so program comprehension plays an important and significant role for developers. Sequence diagram generated using static source code or dynamic only approach provides limited execution coverage, additionally contains redundant, dead and fault driven methods, which increase the size of the diagram and complexity. In this paper, to address the problems, optimized sequence diagrams were developed by combining static source code and dynamic only approach, also incorporating various levels of abstraction in order to reduce complexity and provide complete behavior of the system. Case studies determined from the sequence diagram for three systems generated based on source code only and fully dynamic approach proved that the proposed optimized sequence diagrams were less complex and provided more detailed description of the functionality of the system.

Comprehending Source Code of Large Software System for Reuse   | PDFLink

Aniket Kulkarni

Comprehending source code of large software system for code reuse is an important problem. It is due to very high cost of software maintenance. In this paper, the author shares the experience on comprehending code-base of PRISM - a model-based program analysis tool developed by Tata Consultancy Services - containing in total more than 500 KLOC. During this activity, the author not only detected two bugs in existing PRISM software system while comprehending more than half of the total code (approximately 300 KLOC), but also added feature of Application Programming Interface (API) for Intermediate Representation (IR) transformation utility for ’C’ language consisting of 1 KLOC. The author applied combination of key techniques such as lexical and dynamic analyses, models such as Brook, Soloway to understand code-base and, mixed top-down and bottom-up approaches for comprehension. The author observed that speed of comprehension and reuse later increased multi-fold because half of code-base (approximately 250 KLOC) is automatically generated from specification and thus by focusing on understanding less than 25 KLOC.

3:30 - 4:00 pm

Coffee Break

4:00 - 5:30 pm

Technical Research 5: Assessing Code   PDFLink

Room: Trinity | Session Chair: Lori Pollock

LinkIdentifying Functionally Similar Code in Complex Codebases   | PDFLink

Fang-Hsiang Su, Jonathan Bell, Gail Kaiser, and Simha Sethumadhavan

Identifying similar code in software systems can assist many software engineering tasks such as program understanding and software refactoring. While most approaches focus on identifying code that looks alike, some techniques aim at detecting code that functions alike. Detecting these functional clones — code that functions alike — in object oriented languages remains an open question because of the difficulty in exposing and comparing programs’ functionality effectively. We propose a novel technique, In-Vivo Clone Detection, that detects functional clones in arbitrary programs by identifying and mining their inputs and outputs. The key insight is to use existing workloads to execute programs and then measure functional similarities between programs based on their inputs and outputs, which mitigates the problems in object oriented languages reported by prior work. We implement such technique in our system, HitoshiIO, which is open source and freely available. Our experimental results show that HitoshiIO detects more than 800 functional clones across a corpus of 118 projects. In a random sample of the detected clones, HitoshiIO achieves 68+% true positive rate with only 15% false positive rate.

On Automatically Detecting Similar Android Apps   | PDFLink

Mario Linares-Vasquez, Andrew Holtzhauer, and Denys Poshyvanyk

Detecting similar applications is a challenging problem, since it implies that similar high-level features and their low-level implementations can be detected and matched automatically. We propose an approach for automatically detecting Closely reLated applications in ANdroid (CLANdroid) by relying on advanced Information Retrieval techniques and five semantic anchors: identifiers, Android APIs, intents, permissions, and sensors. To evaluate CLANdroid we created a benchmark consisting of 14,450 apps along with information on similar apps provided by Google Play. We also compared effectiveness of different semantic anchors for detecting similar apps as perceived by 27 users. The results show that using Android-specific semantic anchors are useful for detecting similar Android apps across different categories. We also measured the impact of third-party libraries and obfuscated code when identifying similar Android apps, and our results suggest that there is significant difference in the accuracy when third-party libraries are excluded.

Rule-Directed Code Clone Synchronization   | PDFLink

Xiao Cheng, Hao Zhong, Yuting Chen, Zhenjiang Hu, and Jianjun Zhao

Code clones are prevalent in software systems due to many factors in software development. Detecting code clones and managing consistency between them along code evolution can be very useful for reducing clone-related bugs and maintenance costs. Despite some early attempts at detecting code clones and managing the consistency between them, the state-of-the-art tool can only handle simple code clones whose structures are identical or quite similar. However, existing empirical studies show that clones can have quite different structures with their evolution, which can easily go beyond the capability of the state-of-the-art tool. In this paper, we propose CCSync, a novel, rule-directed approach, which paves the structure differences between the code clones and synchronizes them even when code clones become quite different in their structures. The key steps of this approach are, given two code clones, to (1) extract a synchronization rule from the relationship between the clones, and (2) once one code fragment is updated, propagate the modifications to the other following the synchronization rule. We have implemented a tool for CCSync and evaluated its effectiveness on five Java projects. Our results shows that there are many code clones suitable for synchronization, and our tool achieves precisions of up to 92% and recalls of up to 84%. In particular, more than 76% of our generated revisions are identical with manual revisions.

Are Unreachable Methods Harmful? Results from a Controlled Experiment   | PDFLink

Simone Romano, Christopher Vendome, Giuseppe Scanniello, and Denys Poshyvanyk

In this paper, we present the results of a controlled experiment conducted to assess whether the presence of unreachable methods in source code affects source code comprehensibility and modifiability. A total of 47 undergraduate students at the University of Basilicata participated in this experiment. We divided the participants in two groups. The participants in the first group were asked to comprehend code base containing unreachable methods and implement five change requests in that code base. The participants in the second group were asked to accomplish exactly the same tasks as the participants in the first group, however, the source code provided to them did not contain any unreachable methods. The results of the study indicate that code comprehensibility is significantly higher when source code does not contain unreachable methods. However, we did not observe a statistically significant difference for code modifiability. From these results, we distill lessons and implications for practitioners as well as possible avenues for further research.

Short Papers 3: Attack of the Development Team   PDFLink

Room: Pecos | Session Chair: Lingxiao Jiang

Defending Against the Attack of the Micro-clones   | PDFLink

Rijnard van Tonder and Claire Le Goues

Micro-clones are small pieces of redundant code, such as repeated subexpressions or statements. In this paper, we establish the considerations and value toward automated detection and removal of micro-clones at scale. We leverage the Boa software mining infrastructure to detect micro-clones in a data set containing 380,125 Java repositories, and yield thousands of instances where redundant code may be safely removed. By filtering our results to target popular Java projects on GitHub, we proceed to issue 43 pull requests that patch micro-clones. In summary, 95% of our patches to active GitHub repositories are merged rapidly (within 15 hours on average). Moreover, none of our patches were contested; they either constituted a real flaw, or have not been considered due to repository inactivity. Our results suggest that the detection and removal of micro-clones is valued by developers, can be automated at scale, and may be fixed with rapid turnaround times.

LinkTowards Quality Gates in Continuous Delivery and Deployment   | PDFLink

Gerald Schermann, Jürgen Cito, Philipp Leitner, and Harald Gall

Quality gates, steps required to ensure the reliability of code changes, are supposed to increase the confidence stakeholders have in a release. In today’s fast paced environments, we have less time to perform the necessary precautions to minimize the risk of a faulty release. This leads to an inherent trade-off between risk of lower release quality and time to market. We provide a model for this trade-off of release “confidence” and “velocity” that led to the formulation of 4 categories (cautious, balanced, problematic, madness), in which companies can be classified in. We showcase real examples of these categories as case studies based on previous empirical studies. We close by presenting possible transitions between categories that guide future research.

Revisiting the Relationship Between Code Smells and Refactoring   | PDFLink | Slides

Norihiro Yoshida, Tsubasa Saika, Eunjong Choi, Ali Ouni, and Katsuro Inoue

Refactoring is a critical technique in evolving software systems. Martin Fowler presented a catalogue of refactoring patterns that defines a list of code smells and their corresponding refactoring patterns. This list aimed at supporting programmers in finding suitable refactoring patterns that remove code smells from their systems. However, a recent empirical study by Bavota et al. shows that refactoring rarely removes code smells which do not align with Fowler’s catalog. To bridge the gap between them, we revisit the relationship between code smells and refactorings. In this study, we investigate whether developers apply appropriate refactoring patterns to fix code smells in three open source software systems.

Generating Clone References with Less Human Subjectivity   | PDFLink

Yusuke Yuki, Yoshiki Higo, Keisuke Hotta, and Shinji Kusumoto

In evaluating code clone detection tools, a benchmark is created to measure their precision and recall. Benchmarks in previous research have either of the following issues: the first one is that they depend on the code clone definitions of benchmark creators; the second one is that they are not code clones occurring in actual development process. To get rid of both the two issues, we propose a methodology that creates code clone references based on code clones occurring in development process without any human judgements. More concretely, we use multiple revisions included in the source code repository of target software to identify merged methods in the past development process. We regard merged methods as real code clones. The authors’ benchmark can evaluate detection accuracy of code clone detection tools more objectivity.

Understanding Interactive Debugging with Swarm Debug Infrastructure   | PDFLink

Fabio Petrillo, Zéphyrin Soh, Foutse Khomh, Marcelo Pimenta, Carla Freitas, and Yann-Gaël Guéhéneuc

Debugging is a laborious activity in which developers spend lot of time navigating through code, looking for starting points, and stepping through statements. In this paper, we present the Swarm Debug Infrastructure (SDI) with which researchers can collect and share data about developers’ interactive debugging activities. SDI allows collecting and sharing debugging data that are useful to answer research questions about interactive debugging activities. We assess the effectiveness of the SDI through an experiment to understand how developers apply interactive debugging.

5:30 - 6:30 pm

Open Steering Committee Meeting with Presentation of ICPC 2017

Room: Trinity