Abstract Understanding how software systems evolve over time is a key challenge in software engineering. While traditional tools like GitHub offer detailed access to project history, their interface can be fragmented and cognitively demanding. Immersive environments, by contrast, offer new opportunities to visualize software evolution in ways that leverage spatial reasoning and embodied interaction. In this paper, we present a controlled experiment comparing an immersive virtual reality (VR) visualization with a conventional GitHub-based interface for analyzing software evolution across releases. Using the BabiaXR framework and the city metaphor, we built parallel environments where 32 participants explored two real-world Java projects and completed a set of analytical tasks related to structure, activity, and system core identification. Our findings show that participants in VR were not more accurate on average, but engaged more deeply with the data, took more time, and often relied on spatial cues to formulate richer insights. In contrast, participants using the on-screen interface completed tasks faster but occasionally reverted to external tools or skipped complex questions. Qualitative analysis revealed that immersive exploration supported deliberate reasoning, especially in open-ended and structural tasks. Notably, prior experience with VR or software visualization had no significant impact on performance, underscoring the accessibility of immersive tools even for novice users. These results suggest that immersive visualizations may not universally outperform traditional interfaces, but they offer unique cognitive benefits for specific types of software comprehension tasks. We discuss the implications for visualization design and outline future directions involving hybrid analytical environments and extended longitudinal studies.

Software visualization, which uses data from dynamic program analysis, can help to explore and understand the behavior of software systems. It is common that large software systems offer a web interface for user interaction. Usually, available web interfaces are not regarded in software visualization tools. This paper introduces additions to the web-based live tracing software visualization tool ExplorViz: We add an embedded web view for instrumented applications in the 3D visualization to ease interaction with the given applications and enable the exploration of the thereby displayed HTML content. Namely, the Document Object Model (DOM) is visualized via a three-dimensional representation of the HTML structure in same-origin contexts.Our visualization approach is evaluated in a preliminary user study. The study results give insights into the potential use cases, benefits, and shortcomings of our implemented approach. Based on our study results, we propose directions for further research to support the visual exploration of web interfaces and explore use cases for the combined visualization of software cities and HTML structure.Video URL: https://youtu.be/wBWKlbvzOOE

As software grows in size and complexity, developers struggle to understand structural and metric relationships. We present CodeXR, a lightweight Visual Studio Code plugin that extends the IDE with real-time eXtended Reality (XR) visualizations of software metrics. By mapping properties such as lines of code, parameters, and cyclomatic complexity to 3D metaphors, developers can explore entire projects as interactive cities and monitor changes live as they code. CodeXR integrates directly with the IDE, updating visualizations continuously without requiring external dashboards. Additionally, it offers an optional XR representation of HTML DOM hierarchies to support web development tasks. Built on BabiaXR and leveraging concepts validated in prior work like CodeCity, this approach aims to enhance comprehension, reduce cognitive load, and promote spatial reasoning about code quality. We describe the design, capabilities, and use cases, and outline future directions to empirically evaluate its impact on developer workflows. Video URL: https://youtu.be/GFrGDt2BOW0

The Code City metaphor stands as a prominent and widely recognized technique for visualizing software projects. This paper explores the application of the Code City metaphor within the context of Scratch, the most prevalent block-based programming language employed in educational settings. By leveraging the Code City metaphor and its implementation in BabiaXR, we have developed a prototype that renders Scratch projects in a visually intuitive urban landscape. We posit that the integration of the Code City metaphor with Scratch projects holds significant potential for enhancing learning environments by providing novel perspectives on project structure and potential areas for improvement.

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, the FlameGraph 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 as native_write_msr, indicating intensified low-level CPU interactions. In addition, functions such as intel_pmu_enable_all and 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, including fpregs_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.Video URL: https://vimeo.com/1092935027/7d09676a83

Performance analysis is essential to identify bottlenecks and improve software responsiveness. Flame graphs are widely used for this purpose, offering compact summaries of stack traces and execution times. However, as applications grow, flame graphs become large and dense, competing for space within IDEs already crowded with code editors and panels. We propose FlameGraph AR, a tool that offloads flame graph visualizations from the IDE to the physical environment using augmented reality. By integrating a Visual Studio Code extension with an AR application, developers can arrange interactive flame graphs on desks, walls, or in peripheral view. This immersive setup expands visualization space, supports gesturebased interaction, and enables parallel performance analysis without disrupting the coding flow.Video URL: https://vimeo.com/1089364433/e41cfa13c4

With security threats increasing in frequency and severity, it is critical that we consider the important role of threat hunters. These highly-trained security professionals learn to see, identify, and intercept security threats. Many recent works and existing tools in cybersecurity are focused on automating the threat hunting process, often overlooking the critical human element. Our study shifts this paradigm by emphasizing a human-centered approach to understanding the lived experiences of threat hunters. By observing threat hunters during hunting sessions and analyzing the rich insights they provide, we seek to advance the understanding of their cognitive processes and the tool support they need. Through an in-depth observational study of threat hunters, we introduce a model of how they build and refine their mental models during threat hunting sessions. We also present 23 themes that provide a foundation to better understand threat hunter needs and suggest five actionable design propositions to enhance the tools that support them. Through these contributions, our work enriches the theoretical understanding of threat hunting and provides practical insights for designing more effective, human-centered cybersecurity tools.

Understanding the Document Object Model (DOM) is crucial for web development, yet traditional 2D representations can obscure the hierarchical complexity and spatial relationships of HTML elements. This paper introduces babia-html, a component of BabiaXR, which offers a novel approach to visualizing the DOM in 3D and XR for the web. Utilizing A-Frame, we develop a tool that provides real-time, three-dimensional representations of HTML structures. Additionally, we present a plugin for Visual Studio Code (VSCode) that integrates this 3D visualization directly into the development environment. Our goal is to explore how this visualization can enhance the comprehension of HTML structures, improve debugging processes, and facilitate more effective communication of structural changes within development teams. We outline the standalone capabilities of babia-html, its integration as a VSCode extension, and various use cases demonstrating its practical applications. This work provides preliminary insights into the potential benefits of 3D DOM visualization and its implications for modern web development practices, considering the potential impact on developer productivity and cognitive load, and proposing directions for future research and development. Video URL: httos://voutu.be/RFX22blBNss

Abstract Context Current data visualization interfaces predominantly rely on 2-D screens. However, the emergence of virtual reality (VR) devices capable of immersive data visualization has sparked interest in exploring their suitability for visualizing software development data. Despite this, there is a lack of detailed investigation into the effectiveness of VR devices specifically for interacting with software development data visualizations. Objective Our objective is to investigate the following question: “How do VR devices compare to traditional screens in visualizing data about software development?” Specifically, we aim to assess the accuracy of conclusions derived from exploring visualizations for understanding the software development process, as well as the time required to reach these conclusions. Method In our controlled experiment, we recruited N=32 volunteers with diverse backgrounds. Participants interacted with similar data visualizations in both VR and traditional screen environments. For the traditional screen setup, we utilized a commercially available set of interactive dashboards based on Kibana, commonly used by Bitergia customers for data insights. In the VR environment, we designed a set of visualizations, tailored to provide an equivalent dataset within a virtual room. Participants answered questions related to software evolution processes, specifically code review and issue tracking, in both VR and traditional screen environments, for two projects. We conducted statistical analyses to compare the correctness of their answers and the time taken for each question. Results Our findings indicate that the correctness of answers in both environments is comparable. Regarding time spent, we observed similar durations, except for complex questions that required examining multiple interconnected visualizations. In such cases, participants in the VR environment were able to answer questions more quickly. Conclusion Based on our results, we conclude that VR immersion can be equally effective as traditional screen setups for understanding software development processes through visualization of relevant metrics in most scenarios. Moreover, VR may offer advantages in comprehending complex tasks that require navigating through multiple interconnected visualizations. However, further experimentation is necessary to validate and reinforce these conclusions.

The city metaphor is widely used in software visualization to represent complex systems as buildings and structures, providing an intuitive way for developers to understand software components. Various software visualization tools have utilized this approach. Identify the influence of the city metaphor on software visualization research, determine its state-of-the-art status, and identify derived tools and their main characteristics. Conduct a systematic mapping study of 406 publications that reference the first paper on the use of the city metaphor in software visualization and/or the main paper of the CodeCity tool. Analyze the 168 publications from which valuable information could be extracted, and build a complete categoric analysis. The field has grown considerably, with an increasing number of publications since 2001, and a changing research community with evolving interconnections between groups. Researchers have developed more tools that support the city metaphor, but less than 50% of the tools were referenced in their papers. Moreover, 85% of the tools did not use extended reality environments, indicating an opportunity for further exploration. The study demonstrates the active and continually growing presence of the city metaphor in research and its impact on software visualization and its derivatives. Editor’s note: Open Science material was validated by the Journal of Systems and Software Open Science Board.

Modern JavaScript development relies heavily on using Node Package Manager (NPM) modules. These modules are related by dependency relationships, possibly requiring dozens or hundreds of modules to build a complete JavaScript web application. Studying dependencies, in terms of their sustainability, vulnerability, size, defects, etc., is fundamental for the deployment and maintenance of JavaScript web applications. We use a 3D metaphor based on presenting dependencies as an “elevated city”, mapping both dependency relationships and characteristics of interest of each module. We developed a VR (virtual reality) scene representing the dependencies of several web applications using the elevated city metaphor, and exposed industrial experts to it to check its suitability. They explored a medium-sized project, with more than 200 dependencies, sharing their insights. The results highlight different aspects of our approach and how the combination of metrics helps experts to obtain insights from the ecosystem. The feedback shows the usefulness of the visualization to check and explore several aspects of the dependencies of an application, helping to identify problems related to maintainability, license usage, or vulnerabilities, and to design strategies to address them.

Over the past decades, researchers proposed numerous approaches to visualize source code. A popular one is CodeCity, an interactive 3D software visualization representing software system as cities: buildings represent classes (or files) and districts represent packages (or folders). Building dimensions represent values of software metrics, such as number of methods or lines of code. There are many implementations of CodeCity, the vast majority of them running on-screen. Recently, some implementations using virtual reality (VR) have appeared, but the usefulness of CodeCity in VR is still to be proven. Our comparative study aims to answer the question “Is VR well suited for CodeCity, compared to the traditional on-screen implementation?” We performed two experiments with our web-based implementation of CodeCity, which can be used on-screen or in immersive VR. First, we conducted a controlled experiment involving 24 participants from academia and industry. Taking advantage of the obtained feedback, we improved our approach and conducted a second controlled experiment with 26 new participants. Our results show that people using the VR version performed the assigned tasks in much less time, while maintaining a comparable level of correctness. VR is at least equally well-suited as on-screen for visualizing CodeCity, and likely better.

Over the past decades, researchers proposed numerous approaches to visualize source code. A prominent one is CodeCity, an interactive 3D software visualization that leverages the "city metaphor" to represent software system as cities: buildings represent classes (or files) and districts represent packages (or folders). Building dimensions represent values of software metrics, such as the number of methods or the lines of code. There are many implementations of CodeCity, the vast majority of them running on-screen. Recently, some implementations visualizing CodeCity in virtual reality (VR) have appeared. While exciting as a technology, VR’s usefulness remains to be proven.The question we pose is: Is VR well suited to visualize CodeCity, compared to the traditional on-screen implementation?We performed an experiment in our interactive web-based application to visualize CodeCity. Users can fetch data from any git repository and visualize its source code. Our application enables users to navigate CodeCity both on-screen and in an immersive VR environment, using consumer-grade VR headsets like Oculus Quest. Our controlled experiment involved 24 participants from academia and industry. Results show that people using the VR version performed the assigned tasks in much less time, while still maintaining a comparable level of correctness.Therefore, our results show that VR is at least equally well-suited as on-screen for visualizing CodeCity, and likely better.