MOVis: A Visual Analytics Tool for Surfacing Missed Patches Across Software Variants

Abstract: Clone-and-own development produces families of related software variants that evolve independently. As variants diverge, important fixes applied in one repository are often missing in others. PaReco has shown that thousands of such missed opportunity (MO) patches exist across real ecosystems, yet its textual output provides limited support for understanding where and how these fixes should be propagated. We present MOVis, a lightweight, interactive desktop tool that visualizes MO patches between a source and target variant. MOVis loads PaReco's MO classifications and presents patched and buggy hunks side-by-side, highlighting corresponding regions and exposing structural differences that hinder reuse. This design enables developers to quickly locate missed fixes, understand required adaptations, and more efficiently maintain consistency across software variants. The tool, replication package, and demonstration video are available at https://zenodo.org/records/18356553 and https://youtu.be/Ac-gjBxHJ3Y.

• The paper introduces MOVis, a visual analytics tool that surfaces missed patches by aligning patched and buggy code regions for efficient inspection.
• It leverages a modular C++/Qt interface with synchronized diff views, reducing the cognitive load in manually correlating changes across software variants.
• The tool bridges static analysis outputs from PaReco with practical, developer-centric workflows to enhance consistency and maintainability in diverse software forks.

MOVis: Visual Analytics for Surfacing Missed Patches in Software Variant Maintenance

Introduction

Clone-and-own development induces a proliferation of related software variants evolving independently, a phenomenon widespread in open-source ecosystems. Maintenance of such divergent forks is complicated by the failure to propagate critical bug fixes and improvements, resulting in missed opportunity (MO) patches where downstream variants retain obsolete, buggy, or unnecessarily complex code even after fixes upstream. PaReco identifies MO patches at scale using static analysis, but its utility is limited by an entirely textual output that requires developers to manually locate, align, and interpret behavioral divergence across repo boundaries, especially as structural drift accumulates over time. MOVis is introduced as a specialized, visual analytic tool designed to operationalize the actionable insights produced by PaReco, focusing on efficient developer-centric inspection and propagation of missed fixes.

Motivation: Limitations of Existing MO Surfacing Practices

Large-scale empirical evidence demonstrates the rarity with which patches and bug fixes propagate across variant forks, despite significant overlap in functionality and code structure. Textual reporting pipelines such as PaReco's create a high barrier to actionable reuse, as developers must mentally reconstruct mappings between patched and buggy hunks, track contextual drift, and manually align changes across repositories with non-trivial file histories. Even for simple MO patches (e.g., deletion of obsolete API methods), misalignment in line numbers or local context exacerbates the risk that essential patches are overlooked or misapplied.

MOVis addresses the acute cognitive and logistical overhead of acting on such reports. By explicitly externalizing the source–target alignment, MOVis directly supports practical reasoning about where and how a missed patch should be integrated, filtering out irrelevant changes and surfacing actionable divergences for the developer.

Figure 1: MOVis interface showing the metadata panel (top), Hunks Viewer (lower-left), and target variant file (lower-right).

Tool Design and Workflow

MOVis is architected as a lightweight, C++/Qt-based desktop application. Its workflow is tightly coupled to the PaReco pipeline but is architecturally decoupled, enabling both direct invocation of PaReco and visualization of pre-computed classification results. The workflow is as follows:

• MOVis imports MO classifications and hunk-level diff boundaries from PaReco, retrieving file snapshots from source and target repositories via the GitHub API.
• Developers select a pull request of interest, after which the tool renders all impacted hunks for inspection.
• In the Hunks Viewer, patched code from the source variant is displayed side-by-side with the corresponding, still-buggy code region from the target variant.
• Semantic alignments are highlighted: red for deleted lines, green for insertions, blue for shared context.
• Developers can interactively examine changes, with navigation synchronized across both source and target regions to expose drift and highlight missing or outdated logic.

This interactive paradigm enables not only the localization of single missed patches but also supports inspection of multi-hunk, multi-file pull requests. Aggregated and file-contextualized visualization further facilitates consistent patch application in divergent, large-scale fork networks.

Interface and Interaction

The interface is organized into four coordinated panels:

• Metadata Panel: Allows direct navigation among classified PaReco pull requests, presenting metadata such as classification type and PR title.
• Hunks Viewer: Aggregates all code hunks associated with the selected PR/file, rendering explicit diff artifacts and contextual lines with color-coded emphasis.
• Target Viewer: Displays the corresponding files from the target variant, with algorithmic alignment and synchronized highlighting based on PaReco metadata.
• File Navigation Controls: Enable efficient context switching, critical for PRs modifying multiple files.

By aggregating related hunks and maintaining synchronized navigation, MOVis ensures developers can isolate actionable differences, investigate propagation feasibility, and avoid manual re-implementation or redundant analysis.

Figure 2: High-level architecture of MOVis.

Architecture and Implementation

MOVis' implementation is modular, with four primary architectural layers:

• Orchestration Layer: Manages configuration, PaReco invocation, and result selection.
• Data Layer: Parses and manages MO opportunity/effort-duplication output, exposing it as queryable metadata artifacts.
• Mapping Layer: Computes source–target code region alignments, supporting robust navigation across structurally divergent files and explicit source–target localization.
• Presentation Layer: Implements the Qt-based user interface, including side-by-side code viewers with semantic highlighting, navigation controls, and metadata presentation.

Qt's widget and rendering infrastructure is leveraged to implement custom code viewers, line-number alignment, and dynamic highlighting. The tool is cross-platform deployable via qmake and Docker, facilitating adoption in diverse development ecosystems.

Practical and Theoretical Implications

MOVis directly addresses the scalability gap inherent in clone-and-own maintenance by bridging the backend analytics of PaReco with actionable developer workflows. The explicit surfacing of actionable MOs is expected to:

• Improve variant consistency and code quality by lowering the threshold for patch re-use.
• Accelerate maintenance operations in large-scale, fork-heavy codebases by reducing manual alignment and navigation effort.
• Provide a template for visual analytics in other consistency-related developer workflows, such as effort-duplication detection and variant-aware refactoring.

While MOVis does not automate patch application or reasoning about semantic integration risks, it establishes a foundation for future work in developer-in-the-loop propagation tooling, provenance tracking, and automated refactoring-aware patch transportation. The separation of alignment and presentation logic ensures future extensibility as MoVis could be extended to support richer semantic visualizations or integration with interactive merge and conflict resolution frameworks.

Conclusion

MOVis enables efficient, developer-facing exploration and inspection of missed opportunity patches across software variants by fusing static analysis output with interactive, synchronized code visualization. It substantially reduces the effort required to identify, localize, and propagate missed fixes in divergent repositories—a problem strongly correlated with maintenance redundancy and variant drift in social coding platforms. The modular architecture and extensible interface design position MOVis as a robust foundation for research and practice aimed at improving patch reuse, consistency, and maintainability in the broader fork-and-variant ecosystem.

For investigation into clone-based analysis and MO detection: "PaReco: patched clones and missed patches among the divergent variants of a software family" [poedja:fse:2022]. For empirical context on fork divergence and the challenges of patch propagation, see [businge:emse:2022], [businge:saner:2022], and for variant maintenance challenges, related work is extensively articulated in [Businge:chap:2023].