Browsing by Author "Rojas-Stambuk, Tiara"

Now showing 1 - 2 of 2
  • Thumbnail Image
    Item
    An Eye-Tracking Study on the Use of Split/Unified Code Change Views for Bug Detection
    (2023) Sandoval Alcocer, Juan Pablo; Cossio-Chavalier, Alejandra; Rojas-Stambuk, Tiara; Merino Del Campo, Leonel Alejandro
    Software developers often use comparison tools to identify bugs in source code by comparing two versions of the code. These tools display the code in either a split view or unified manner, yet there is limited understanding of how developers interact with them when analyzing changes in the source code. Consequently, the advantages and disadvantages of each approach are still unknown. We explored the usefulness, limitations, and potential for improvement of split and unified views of GitHub. To do this, we conducted a user study with 12 participants who were tasked with analyzing source code in two commits to detect bugs. We used a within-subjects approach, and the participants were monitored with an eye-tracking device while using the split and unified views. The results of our study showed that participants experienced less visual strain when using the unified view. This implies that a lower effort can facilitate a more thorough analysis of the code, which can often result in the discovery of more bugs. Additionally, we noticed that participants mainly focused on conditionals, class/instance variables, and code changes. Nevertheless, we did not find any statistically significant differences among the variables examined when using split or unified views. The findings of this study are pertinent to both practitioners and researchers. Practitioners can use the results to make informed decisions when selecting a view, while researchers can use them to identify potential areas for improvement in code comparison tools.
  • Thumbnail Image
    Item
    Visualizing The Linux Kernel Performance with FlameGraph AR
    (IEEE Computer Society, 2025) Rojas-Stambuk, Tiara; Gil-Gareca, Luis Fernando; Sandoval Alcocer, Juan Pablo; Merino Del Campo, Leonel Alejandro; Moreno-Lumbreras, David
    In this challenge, we explore the evolution of the Linux kernel’s performance during compilation by comparing versions 5.19.17 and 6.14 through sampling-based CPU profiling. We collect profiling data using perf, transform into Chromecompatible .cpuprofile format, and analyze through a novel spatial visualization called FlameGraph AR. FlameGraph AR extends traditional flamegraphs beyond the limitations of IDE panels and conventional screens by rendering visualizations with augmented reality on a Microsoft HoloLens 2 device. By offloading the flamegraph to physical space, theFlameGraph AR tool enables developers to walk through wide and deeply nested call stacks, examine function frames through gesture-based interactions, and gain spatial awareness of the runtime behavior of a software system. In effect, we found immersive visualization especially valuable for analyzing architectural changes between the two kernel versions. We found that version 6.14 exhibits a significantly higher number of samples in several functions, such asnative_write_msr, indicating intensified low-level CPU interactions. In addition, functions such as intel_pmu_enable_alland x86_pmu_enable also increased in frequency, suggesting increased reliance on performance monitoring. The stack depth analysis revealed that certain functions in version 6.14, includingfpregs_assert_state_consistent and account_user_time, appear at significantly deeper levels than in earlier versions. Indeed, some reach the maximum stack trace depth of the profiling tool. The results indicate a growth in both modularity and the depth of instrumentation within the kernel execution paths. Multiple performance changes become visible and interactive with Flamegraph AR. For example, time-consuming functions show up as wide frames that span over desks or walls, and deep call stacks are explored physically by approaching or gazing upward. By mapping performance traces into the spatial domain, our tool provides a compelling method for understanding systemic evolution in large-scale software like the Linux kernel.