Towards "Traceability as a By-product": Bridging Gaze and Logic

TL;DR

Software traceability—the map connecting requirements to code—is essential for safety but notoriously expensive to maintain. This research proposes moving away from manual documentation and noisy IR-based guessing. Instead, it captures the natural attention of engineers. By fusing eye-tracking data with interaction logs (scrolling, clicking), the paper outlines a framework that identifies trace links simply by watching where an expert looks and how they navigate between documents.

Problem & Motivation: The Dynamic Content Barrier

The "Grand Challenge of Traceability" is to make it ubiquitous and effortless. While Information Retrieval (IR) and Machine Learning (ML) can suggest links, they lack the cognitive context of a human solver.

Eye tracking offers a window into this context, but it faces a technical wall: The Dynamic Environment Problem. Modern software development isn't static; developers scroll through thousands of lines of code, switch between PDFs and IDEs, and edit text. Traditional eye-traing software treats the screen as a static image. Once a developer scrolls, the $(x,y)$ coordinates of their gaze no longer point to the same line of code, rendering the data useless without manual re-alignment.

Methodology: Fusing Gaze with Metadata

The core innovation lies in the Eye Tracking Framework, which doesn't just record "where you look," but "what the world looks like when you look there."

1. The Multi-Log Architecture

The framework records three distinct streams of data simultaneously:

• Application Log: Tracks pixel positions and active window timestamps.
• Stimuli Log: Captures document-level changes (e.g., switching from a UML diagram to a Java file).
• Interaction Log: Records the "micro-movements" within a document—scrolling offsets, zoom levels, and edits.

2. Heuristics for "Meaningful" Links

Simply looking at two things doesn't mean they are linked. The author utilizes specific heuristics to filter noise:

• Temporal Weighting: Gaze paths recorded later in a task are weighted more heavily (assuming the developer has gained deeper comprehension).
• Fixation Intensity: Frequent and long fixations imply complexity and importance, highlighting relevant artifacts.
• Interaction Context: If a developer looks at a requirement and then edits a specific function, the link strength is boosted.

Experiments & Results: Outperforming the Baselines

The paper integrates findings from preliminary studies. In code maintenance tasks within mock IDEs, visual cues derived from gaze data (heatmaps) significantly helped developers identify relevant areas.

In link recovery tasks (e.g., bug localization), the gaze-based approach demonstrated:

• Precision/Recall: Reaching 55% / 67% on average.
• Competitive Edge: It consistently outperformed traditional IR methods like Vector Space Models (VSM) and Latent Semantic Indexing (LSI), largely because eye tracking captures the intent of the developer, which text-similarity alone cannot grasp.

Fig: A heatmap visualization of developer focus within an IDE, used to validate artifact relevance.

Critical Analysis & Conclusion

Takeaways

This work marks a shift from active documentation (forcing developers to write down links) to passive capture. By solving the technical hurdle of dynamic document mapping, it brings eye tracking out of the lab and into the real production environment.

Limitations & Future Work

• The Privacy Trade-off: Recording every pixel of a developer's screen poses massive privacy risks in industrial settings. Future iterations need to focus on recording only "Area of Interest" (AOI) metadata rather than full video.
• "Attention $eq$ Intention": As the author notes, "what you see is not always what you are looking for." Future heuristics must better distinguish between a developer being confused by a file vs. that file being relevant to the task.

The next frontier for this research is the Survey on Stakeholder Needs, ensuring the automated links generated by this gaze-framework actually serve the specific workflows of safety analysts and maintainers in the real world.