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.
