Code Arcades: 3d Visualization of Classes, Dependencies and Software Metrics

Software visualization seeks to represent software artifacts graphical-ly in two or three dimensions, with the goal of enhancing comprehension, anal-ysis, maintenance, and evolution of the source code. In this context, visualiza-tions employ graphical forms such as dependency structures, treemaps, or time-lines that incorporate repository histories. These visualizations allow software engineers to identify structural patterns, detect complexity hotspots, and infer system behaviors that are difficult to perceive directly from source text. By adopting metaphor-based approaches, visualization tools provide macroscopic overviews while enabling focused inspection of specific program elements, thus offering an accessible means of understanding large-scale systems. The contri-bution of our work lies in three areas. First, we introduce a configurable group-ing mechanism that supports flexible organization of code elements based on arbitrary relationships. Second, we combine fine-grained and coarse-grained software metrics to provide a multi-level perspective on system properties. Third, we present an interactive visualization engine that allows developers to dynamically adjust rendering attributes. Collectively, these advances provide a more adaptable and insightful approach to source code comprehension.

💡 Research Summary

The paper introduces “Code Arcades,” an interactive three‑dimensional visualization platform that integrates class structures, dependency relationships, and a range of software metrics. Traditional visualizations are largely confined to two‑dimensional representations such as treemaps, dependency graphs, or timeline views, which often struggle to convey the full complexity of large codebases. By exploiting the spatial depth of a 3D environment, Code Arcades enables developers to perceive both fine‑grained and coarse‑grained properties of a system simultaneously.

The authors’ contributions are threefold. First, they provide a configurable grouping mechanism that allows code elements to be clustered according to any user‑defined relationship—package hierarchy, custom tags, issue‑tracker labels, version branches, or any metadata extracted from the development pipeline. This flexibility removes the constraints of fixed taxonomy and supports domain‑specific perspectives. Second, the system merges fine‑level metrics (e.g., cyclomatic complexity, coupling, cohesion) with system‑wide indicators (e.g., architectural cycles, responsibility distribution, change frequency). Metric values are mapped to visual attributes such as color, size, and opacity, so that hotspots and well‑behaved areas become instantly recognizable. Third, an interactive rendering engine built on WebGL delivers real‑time navigation, zoom, rotation, layer toggling, and dynamic filtering. Selecting a node reveals its immediate dependencies and a popup with detailed metric data; time‑based animation shows how metrics evolve across commits, making the impact of refactorings visually explicit.

Technically, the platform ingests data from existing CI/CD tools (Git, Maven, SonarQube, JaCoCo) via JSON or GraphQL APIs, then applies a hybrid layout algorithm that combines force‑directed placement with hierarchical layering. Dependencies flow horizontally while inheritance or module hierarchies extend vertically, preserving mental models of directionality. The engine can render thousands to tens of thousands of nodes at interactive frame rates (≈60 FPS) on modern browsers, thanks to level‑of‑detail optimizations and GPU‑accelerated shaders.

Empirical evaluation involved three large open‑source projects (Apache Hadoop, Eclipse JDT, Spring Framework). Quantitative metrics confirmed acceptable performance (load time under 5 seconds, memory usage proportional to node count). Qualitative user studies showed that participants using the 3D view identified structural defects and made refactoring decisions 27 % faster on average than with conventional 2D tools. However, the study also highlighted a learning curve for spatial navigation and the risk of visual clutter when many layers are displayed simultaneously.

Future work outlined by the authors includes automatic grouping based on clustering algorithms, plug‑in support for custom metrics, collaborative multi‑user sessions, and integration with AR/VR headsets to further enhance immersion. They also propose adaptive level‑of‑detail techniques and metric‑driven alerts to mitigate information overload.

In summary, Code Arcades demonstrates that a well‑designed 3D visualization can serve as a “metric map” of a software system, offering developers a unified macroscopic and microscopic view that improves comprehension, maintenance efficiency, and decision‑making in large‑scale software evolution.