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.
The lifecycle and development of software systems are strongly dependent on time: A critical dimension that must be considered when analyzing software evolution. Many visualization approaches have been proposed to support developers in analyzing software systems. Yet, most of these focus on static representations, which struggle to convey evolution in time, and leverage only vision. In contrast, hearing—although underutilized—is well suited for processing sequential information, making sound a powerful medium to convey changes chronologically.We present a multimodal approach, implemented in a tool named SonicSight, that combines software sonification and visualization to analyze the development pace of software repositories interactively. A pulse synthesizer modulates its speed based on daily commits, while frequencies represent individual developers and their contribution activity. To support interpretation, the sonification is paired with a real-time interactive visual representation of software-related information. We illustrate such sonified visualization approach through case studies and discuss the underlying time model we employed, crucial for representing both sound and the temporal nature of software evolution.
The popularity of microservices has grown significantly over the past decade. This architectural style is praised for its ability to ease software evolution, particularly due to the modular, heterogeneous, and dynamic communication nature of microservices. This new way of designing applications has also impacted how databases are integrated. Practitioners generally opt for polyglot persistence, meaning that each microservice manages its own database(s). Decoupling, heterogeneity, and distribution introduce implicit dependencies and multiply data access endpoints. This results in added complexity and challenges in understanding change propagation, which can only be addressed through manual browsing of the codebase, a time-consuming, error-prone, and cumbersome process. A holistic view of such architectures is essential, especially for enabling developers to understand, maintain, and optimize the complex interactions across microservices, particularly from a data perspective.We extend a visualization-based approach to support both a high-level view and fine-grained inspection of microservices. Based on static analysis, we generate an interactive treemap for an entire microservices architecture, providing both an overview and the means for more detailed exploration.We evaluated our approach by assessing the scalability and effectiveness of our visualization. First, we generated interactive treemaps for 10 non-trivial microservices architectures. Then, in a qualitative user study, we asked 6 professional developers to perform specific exploration and understanding tasks (e.g., understanding architectural structure, assessing concept spreading, evaluating technology breakdown, comparing versions, identifying anti-patterns). Our results show that interactive treemaps provide the holistic view needed to aid in evolution tasks.
Classes are the fundamental building blocks of object-oriented software systems, making their comprehension critical for effective software maintenance and evolution. Traditional source code views provide detailed information but often lack intuitive representations that reveal the structural and behavioral roles of a class at a glance. This is even harder for an overview of multiple classes in large and complex codebases. Moreover, identifying patterns and anomalies within classes remains challenging through conventional inspection.We propose Class Contours, a novel visualization metaphor that portrays individual classes as simple 2D architectural structures. Our approach visually encodes key class properties (e.g., lines of code, attributes, accessors) into customizable building features (e.g., windows, door frames, doors), supporting pattern recognition and task-specific visual exploration. With ZION, the tool we developed to exemplify our approach, we investigate how common class types correspond to recurring visual archetypes, allowing developers to swiftly recognize typical roles and structures within software systems.Our initial findings suggest that the simple but effective metaphor can enhance the understanding of class semantics in large codebases and support the identification of design issues and code smells.
Software visualization tools assist developers in understanding programs by presenting static, dynamic, and evolutionary aspects of software. In this poster manuscript, we present our ongoing work on enabling snapshot-based visualizations of runtime behavior for debugging. Developers can manually create snapshots at breakpoints during a debugging session to precisely visualize execution traces within custom-defined intervals. This fine-grained approach is intended to reduce cognitive load and support program comprehension.
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
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
The Linux Kernel consists of thousands of interrelated subsystems that can be challenging to grasp for developers or curious users. We are presenting an interactive 3D graph visualization tool built in Unity that facilitates the comprehension of the cloned Linux kernel Git repository. The visualization creates an undirected graph representing files or folders of desired subsystems consisting of nodes and edges as connections between them. It includes a canvas with slider filters, where the minimum and maximum years allow for more time-specific visualization, while the intensity represents the total lines of code changed in a diff for the given time frame. The user can also navigate in different directions, move closer to the main file or any other area, as well as move and drag the visualization of the subsystem nodes for a better overview of the subsystem network. The current implementation uses a file-writing script which transfers cleaned data from the cloned respiratory, generating a file in the Unity project folder, later used for the file-reading script for Unity graph rendering. The 3D graph representation can be helpful for newcomers, developers, and researchers seeking to explore and learn the complex structure of Linux Kernel subsystems and draw insights about the commit activity on a chosen time frame. Demo link - https://youtu.be/pL97TxFhsq8.
The Linux kernel is one of the largest and longest-maintained open-source projects in existence. With tens of thousands of source code files, understanding the program’s internal structure and behavior is a great challenge. In this paper, we present an approach to visualize the Linux kernel using our software visualization tool ExplorViz. We analyze commits from the Linux Git repository using srcML and our custom backend service for static analysis. We visualize the folder structure and included source code files using the city metaphor. Users can visually compare the structure of different commits to gain insight into the kernel’s software evolution.In addition to the visualization of the structure of the Linux kernel, ExplorViz processes traces that provide runtime information about the kernel’s behavior. Therefore, we employ the function tracer ftrace and convert the gathered traces to the OpenTelemetry format. The accumulated traces are displayed as arcs between communicating files.When combined with the numerous configuration options of ExplorViz for customizing its visualization, our approach offers new and versatile perspectives on the Linux kernel.Video URL: https://youtu.be/cBouE5eQOjE
Microservices have become a prevalent architectural style over the past decade, emphasizing the modular and dynamic nature of heterogeneous and distributed units that communicate with each other. Moreover, they promote polyglot persistence, meaning that each microservice is responsible for managing its own database(s), often with heterogeneous technologies. One of the downsides is the increase of the number and diversity of data access endpoints and exchanges. Additionally, the decomposition introduces implicit dependencies that affect code and data understanding and co-evolution. Maintaining a comprehensive high-level view of this kind of architecture is challenging, yet essential for software evolution tasks. Previous works have already proposed holistic representations and visualizations of data access in microservices. However, these are mainly based on structural and fixed snapshots, neglecting the dynamic perspective.We present an approach to enhance static visualizations. First, we record data-access-centered execution traces in microservices architectures through a static analysis-based refinement of dynamic instrumentation. Then, we replay scenarios over an existing static treemap, animating the sequence of data accesses and highlighting hotspots in the codebase through time. Our contribution, the animated heat treemap, helps developers to understand how data management operates inside microservices. We validated our approach on Overleaf, a popular online collaborative LATEX authoring platform, with a real-world scenario. We discuss the results obtained and provide insights and reflections.
It is challenging to incorporate game elements into software visualization. To achieve this, we propose a new method that generates a shooting game. The difficulty varies based on the number of methods and fields in the modules. Preliminary analysis suggests that the proposed method is expected to help developers grasp the complexity of modules.
With its remarkably extensive code base, uniquely long lifespan, and undeniable importance to modern society, the Linux kernel is trivially hard to maintain. However, its decentralized development spread over many git trees and mailing lists makes empirically assessing the health of its maintainership model nothing short of a challenge. Off-the-shelf data analysis tools fail to capture crucial nuances exclusive to the kernel development model, such as the current authors who take part in every patch submitted, or how the commit flow between trees changes as new release candidates are created for every merge and stabilization window. We propose the Dashboard for Unified Kernel Statistics (DUKS), an innovative framework that supports multiple visualizations and data analyses previously unsupported for the Linux kernel. Using the Linux kernel mainline as an example, we demonstrate how DUKS could provide valuable insights for understanding the health of the kernel maintainership model. By coupling information from the kernel git trees collected from the Software Heritage repository alongside authorship information shared in mailing lists, we envision DUKS as a cornerstone open-access utility to support analyses on the Linux kernel evolution and maintenance. DUKS demo video: https://youtu.be/2RvUgzdr1fo
Gaining an in-depth understanding of the structure of software systems can be overwhelming, time-consuming, and unappealing. Since people play a key role in software development, human factors, such as motivation, must be considered when designing software development tools. We investigated this concept by using “gamification” for software visualization. We developed a gamified visualization tool for object-oriented software architectures, added gamification elements using a user-centered design approach, and evaluated it based on qualitative feedback from software developers. Our results suggest that gamification meaningfully enhances software understanding via visualization. However, further design iterations are needed to improve gamified visualization, as well as a quantitative study to evaluate it.
Enhancing students’ comprehension of bytecode generation and its interpretation is crucial, yet challenging, in compiler construction courses. Traditional approaches often emphasize theoretical concepts, making it difficult for students to grasp the inner workings of bytecode interpreters.To bridge this gap, we introduce a web-based tool for trace-based bytecode interpreter visualization, designed to enhance comprehension by providing an interactive and visually enriched learning experience. Our tool provides a side-by-side view that aligns the original high-level source code and its corresponding low-level bytecode, with arrows indicating jumps and method calls. Users can step through the executed bytecode (forwards and backwards) to see the effect of each operation. A dynamic memory visualization utilizes animations to illustrate changes in the interpreter’s various memory regions and its registers. To further increase the flexibility of our tool, we developed a lightweight metalanguage that enables educators to define visualizations for arbitrary bytecode formats.Our tool aims to bridge the gap between abstract theory and concrete execution. We demonstrate its effectiveness in various educational settings, e.g., how it can help educators improve their live teaching and how it facilitates student self-study.
As software systems evolve, users and developers are responsible for identifying and reporting bug fixes. Addressing these issues is vital to ensuring the health, security, and performance of the system, as well as providing a positive user experience. Analyzing bug resolution times within large-scale open source systems such as Linux is important to understand the overall health of the project, long-term maintenance, and different factors affecting bug resolution. In this paper, we perform an analysis of resolved bugs within the Debian distribution of Linux. We collected a data set of 466 bugs from the Ultimate Debian Database (UDD) for this project.In this paper, we present a collection of interactive visualizations of bug fix data in the Debian distribution of Linux. Namely, (1) bar charts showing distributions of bug fix durations, (2) a line graph of reported and resolved bugs per year, (3) a box plot relating bug severity with resolution time, (4) a bar chart identifying the most frequently affected packages, and (5) a scatter plot tracking how fix durations have changed over time. These visualizations reveal patterns in bug management and resolution, providing insight into long-term maintenance strategies and bug triage response times. These tools can be used to inform decisions related to real-world bug processing behavior in the Linux kernel environment and other large open-source projects. Challenge Demo Video: https://youtu.be/3rL0YWmiRl0
Linux is a large open-source operating system. Its size makes it difficult for developers to fully grasp the system as a whole. Visualizations of the Linux kernel can provide developers with better program comprehension and understanding of evolution processes. This paper presents a visualization of Linux commit activity using a hierarchical, heat-map based graph. Using a large data set of commit data from Zenodo, we model the Linux structure as a directed hierarchy. Each node in the graph represents a subsystem, and edges show a parent-child relationship within the Linux architecture. The graph is rendered radially in Unity with a color gradient applied to nodes to indicate the volume of commits made to each subsystem. The result is an interactive, intuitive view of development hot-spots in the Linux kernel, aimed at supporting further software evolution analysis. Challenge video link: https://youtu.be/5rNFFZl16v4
Software visualization tools can facilitate program comprehension by providing visual metaphors, or abstractions that reduce the amount of textual data that needs to be processed mentally. One way they do this is by enabling developers to build an internal representation of the visualized software and its architecture. However, as the amount of displayed data in the visualization increases, the visualization itself can become more difficult to comprehend. The ability to display small and large amounts of data in visualizations is called visual scalability. In this paper, we present two approaches to address the challenge of visual scalability in 3D software cities. First, we present an approach to semantic zoom, in which the graphical representation of the software landscape changes based on the virtual camera's distance from visual objects. Second, we augment the visualization with a miniature two-dimensional top-view projection called mini-map. We demonstrate our approach using an open-source implementation in our software visualization tool ExplorViz. ExplorViz is web-based and uses the 3D city metaphor, focusing on live trace visualization. We evaluated our approaches in two separate user studies. The results indicate that semantic zoom and the mini-map are both useful additions. User feedback indicates that semantic zoom and mini-maps are especially useful for large software landscapes and collaborative software exploration. The studies indicate a good usability of our implemented approaches. However, some shortcomings in our implementations have also been discovered, to be addressed in future work.
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
Modern software systems have grown increasingly complex, necessitating the collaborative efforts of diverse teams comprised of multiple developers. The combined efforts and collaboration of distributed teams create underlying networks within which these teams operate. This project presents a Java-based visualization tool that analyzes and depicts collaborative patterns within the Linux kernel development community. We extract contributor information from the Linux kernel repository to construct a network graph where nodes represent individual contributors and edges indicate shared contributions on the same commits. By showing which contributors tend to work together, the tool helps identify likely points of contact for bug triage, code maintenance, and understanding subsystem ownership. It also lays the groundwork for a deeper analysis of team structure and collaboration patterns.
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
