Using Information Flow to estimate interference between developers same method contributions

TL;DR

The paper investigates whether Information Flow Control (IFC) can indicate dynamic semantic conflicts that arise when developers merge contributions, by focusing on interference between same-method edits and using JOANA to analyze information flow via System Dependence Graphs. It formalizes a strategy to detect interference as a proxy for potential conflicts, combining automatic IFC analysis across multiple configurations with manual inspection to assess false positives. Through a large-scale empirical study over 157 merge scenarios from 52 Java projects, the authors find that direct information flow between same-method contributions occurs in about 64% of cases, and about 42.86% of those flows correspond to actual interference; they also identify major sources of false positives including annotation limitations, change nature, and JOANA conservativeness. The study demonstrates that IFC can be a practical signal for interference during merges and offers concrete recommendations (e.g., prefer instance-based SDG without exceptions for better scalability) and avenues to reduce false positives, thereby informing future merge tooling and code-review workflows.

Abstract

This work's main goal is to understand if Information Flow Control (IFC), a security technique used for discovering leaks in software, could be used to indicate the presence of dynamic semantic conflicts between developers contributions in merge scenarios. However, as defining if a dynamic semantic conflict exists involves understanding the expected behaviour of a system, and as such behavioural specifications are often hard to capture, formalize and reason about, we instead try to detect a code level adaptation of the notion of interference from Goguen and Meseguer. We limit our scope to interference caused by developers contributions on the same method. Therefore, we conduct an evaluation to understand if information flow may be used to estimate interference. In particular, we use Java Object-sensitive Analysis (JOANA) to do the IFC for Java programs. JOANA does the IFC of Java programs by using a System Dependence Graph (SDG), a directed graph representing the information flow through a program. Additionally, we bring evidence that information flow between developers same-method contributions occurred for around 64% of the scenarios we evaluated. Finally, we conducted a manual analysis, on 35 scenarios with information flow between developers same-method contributions, to understand the limitations of using information flow to estimate interference between same-method contributions. From the 35 analysed scenarios, for only 15 we considered that an interference in fact existed. We found three different major reasons for detecting information flow and no interference: cases related to the nature of changes, to excessive annotation from our strategy and to the conservativeness of the flows identified by JOANA. We conclude that information flow may be used to estimate interference, but, ideally, the number of false positives should be reduced.

Figures (14)

• Figure 1: Merge scenario containing dynamic semantic conflict
• Figure 2: Merge scenario containing interference, but not necessarily dynamic semantic conflicts
• Figure 3: Merge scenario with indirect information flow
• Figure 4: Original (a) and amplified (b) boxplots of number of flows (violations) identified between source code lines for Instance Based sdg with (left boxes labeled as "Yes") and without (right boxes labeled with "No") exceptions
• Figure 5: Amplified boxplots of number of flows identified between source code lines for sdg with (left boxes) and without (right boxes) exceptions for all precisions