Conference PaperPDF Available

Visualizing Software Systems as Cities

Authors:

Abstract and Figures

This paper presents a 3D visualization approach which gravitates around the city metaphor, i.e., an object-oriented software system is represented as a city that can be traversed and interacted with: the goal is to give the viewer a sense of locality to ease program comprehension. The key point in conceiving a realistic software city is to map the information about the source code in meaningful ways in order to take the approach beyond beautiful pictures. We investigated several concepts that contribute to the urban feeling, such as appropriate layouts, topology, and facilities to ease navigation and interaction. We experimented our approach on a number of systems, and present our findings.
Content may be subject to copyright.
A preview of the PDF is not available
... In this paper, we present our device-heterogeneous and collaborative SV approach for program comprehension. Our resulting tool ExplorViz enables location-independent coexploration of 3D software cities [9], [10]. Users can employ our on-screen, virtual reality (VR), or augmented reality (AR) modes using common of-the-shelf devices. ...
... Therefore, related work can be divided into different categories. For example, there are various SV approaches that employ or originally introduced the same visualization metaphor [10], [30], [31]. Other works use comparable hardware, e.g., extended reality headsets [18], [24], [32], or similar data sources for the visualizations [33]- [35]. ...
... Powered by WebXR, this mode should also be ready-to-use with for example Microsoft's HoloLens. 10 SEE is developed in C# and built upon the Unity game engine, 11 a common pick for SV approaches. The ExplorViz frontend component uses WebGL and WebXR such that the complete SV interaction can be executed in standard web browsers such as Google Chrome or Mozilla Firefox. ...
Conference Paper
Full-text available
In the context of program comprehension, learning and working in teams, e.g., via pair programming, shared documentation, and discussions, can facilitate the comprehension tasks. So far, team collaboration is a relatively unexplored aspect in software visualizations, in particular approaches which are designed and explored to enable collaborative program comprehension.In this paper, we introduce our collaboratively usable software visualization environment for program comprehension. Related approaches are often limited to single-user modes, therefore neglect the advantages of multi-user collaboration, or allow only the use of a single type of device. Our approach addresses this topic and allows users to collaboratively explore software visualizations in a device-heterogeneous environment. User events, e.g., sharable pop-up information windows, are synchronized between each session participant, regardless of the employed device.To the best of our knowledge, this is one of the first approaches that combines on-screen, virtual reality, and augmented reality modes in a single web-based SV tool for program comprehension. We conducted a user study to collect initial results regarding the perceived usefulness and enjoyment of co-explored software cities In that study, 20 participants collaboratively solved program comprehension tasks while using each mode consecutively. The results indicate that the majority of participants find our approach useful and enjoyable, with AR being the least favored mode. We provide each participant’s video recording, the study’s raw results, Jupyter Notebooks, and all steps to reproduce our evaluation as supplementary package. Furthermore, a live demo of our tool is available online. 1 We invite other researchers to extend our open-source software and jointly research this novel approach.Video URL: https://youtu.be/MYAkRMWLVD8
... We decided to develop a web-based SV tool to strive for our design's heterogeneous environment of different devices. The actual SV follows the city metaphor to visualize applications' internals [12] and uses a UML deployment diagram alike visualization to depict the overall SL. This can be seen in Figure 3. ...
... VI. RELATED WORK In the context of program comprehension, there are various SV approaches that are related to our submission. For example, some related works follow the same visualization metaphor [12], [14], [15], employ comparable hardware, e.g., extended reality headsets [16], [17], or use similar data sources for the visualizations [18], [19]. Due to the large amount of work in this field, we only discuss two related approaches in the present paper by focusing on comparable architectures and collaboration abilities. ...
Conference Paper
Full-text available
Software visualizations are used by software developers, for instance, for program comprehension. In this context, a less researched aspect is the collaborative use of online visualization services. This paper presents the conceptual design and a prototype implementation of our approach for a collaborative software visualization service for program comprehension. The central idea is an online available software-as-a-service application that analyzes, persists, and visualizes software applications which users intend to explore and comprehend via software visualization. The resulting implementation is a redevelopment of our live trace visualization tool ExplorViz. In comparison to other approaches, ExplorViz utilizes WebGL and other browser technologies instead of a game engine to render its visualizations. As a result, we achieve a platform-independent interoperability that is crucial for (remote) collaboration. Here, users can explore the same visualization via our collaboratively usable desktop, virtual reality, and also augmented reality modes. Our prototype follows the Twelve-Factor App methodology to build a cloud-native application that comprises multiple scalable microservices. Thanks to horizontal scaling, our implementation is capable to analyze a large amount of visualization data; thus, allowing multiple users to simultaneously use the software visualization service. We conducted a set of preliminary performance experiments to benchmark our prototype’s scalability. Results show that the evaluated service scales linearly with increasing load.
... Regardless of which aspects are visualized, to make the abstract software artifacts easier to understand for humans, they are often mapped to familiar real-world metaphors [3]. Several controlled experiments have shown that the metaphor of a city is well suited [4][5][6]. It mainly focuses on the static aspects and represents components (e.g., classes) as buildings and shows containers of components (e.g., packages or modules) as city districts. ...
... The TreeMap Layout [4][5][6][19][20][21] is the most common layout for Software Cities. It uses binpacking to place rectangles (i.e., buildings and districts) into the smallest possible common rectangle and sorts them in descending order of their width, depth, or base area. ...
Article
Full-text available
A Software City is an established way to visualize metrics such as the test coverage or complexity. As current layouting algorithms are mainly based on the static code structure, dependencies that are orthogonal to this structure often clutter the visualization and are hard to grasp. This paper applies layered graph drawing to layout a Software City in 3D. The proposed layout takes both the dependencies and the static code structure into account. While having the static dependencies encoded in the layout, we can additionally display dynamic dependencies as arcs atop the city in the night view of the Layered Software City. By applying a trace clustering technique we can further reduce the number of shown arcs. We evaluate the advantages of our layout over a classic layouting algorithm in a controlled study on a real-world project and also report on a short study that evaluates the visualization of dynamic dependencies. The source code of the layouting algorithm and the raw data of the quantitative evaluations are available from https://github.com/qaware/holoware-software-city.
... Additionally, Lanza's et al., present CodeCrawler [14] that supports the understanding of program structure via polymeric views. Wettel's et al., present CodeCity [15] that displays software classes as buildings and packages as the ground foundation on which they are built [34]. Another city metaphor is the SArF map [16] clustering technique, which groups together classes with the same features on the same grounds, separated by a street representing the relevance between these features. ...
Conference Paper
Full-text available
In object-oriented programming, classes are the primary abstraction mechanism used by and exposed to developers. Understanding classes is key for the development and evolution of object-oriented applications. The fundamental problem faced by developers is that while classes are intrinsically structured entities, in IDEs they are represented as a blob of text. The idea behind the original CLASS BLUEPRINT visualization was to represent the internal structure of classes in terms of fields, their accesses, and the method call flow. Additional information was depicted using colors. The thus created visualization proved to be an effective means to support program comprehension. However, a number of omissions rendered it only partially useful. We propose CLASS BLUEPRINT V2 (in short BLUEPRINTV2), which in addition to the information depicted by CLASS BLUEPRINT also supports dead code identification, methods under tests, and calling relationships between class and instance level methods. In addition, BLUEPRINTV2 enhances the understanding of fields by showing how fields of super/subclasses are accessed. We present the enhanced visualization and report on a first validation with 26 developers and 18 projects.
... Then the system maps software characteristics, mainly through metrics, to this environment. Possibly the most well-known SNE used for software visualization is the city metaphor popularized by Wettel and Lanza [23], where the authors developed a tool called CodeCity [7] to implement this metaphor. ...
Article
Full-text available
Context: Code annotations is a widely used feature in Java systems to configure custom metadata on programming elements. Their increasing presence creates the need for approaches to assess and comprehend their usage and distribution. In this context, software visualization has been studied and researched to improve program comprehension in different aspects. Objective: This study aimed at designing a software visualization approach that graphically displays how code annotations are distributed and organized in a software system and developing a tool, as a reference implementation of the approach, to generate views and interact with users. Methods: We conducted an empirical evaluation through questionnaires and interviews to evaluate our visualization approach considering four aspects: (i) effectiveness for program comprehension, (ii) perceived usefulness, (iv) perceived ease of use, and (iv) suitability for the intended audience. The resulting data was used to perform a qualitative and quantitative analysis. Results: The tool identifies package responsibilities providing visual information about their annotations at different levels. Using the developed tool, the participants achieved a high correctness rate in the program comprehension tasks and performed very well in questions about the overview of the system under analysis. Finally, participants perceived that the tool is suitable to visualize the distribution of code annotations. Conclusion: The results show that the visualization approach using the developed tool is effective in program comprehension tasks related to code annotations, which can also be used to identify responsibilities in the application packages. Moreover, it was evaluated as suitable for newcomers to overview the usage of annotations in the system and for architects to perform a deep analysis that can potentially detect misplaced annotations and abnormal growths on their usage.
Conference Paper
Full-text available
An important aspect in software visualization is the visualization of relations between elements. Examples include function calls across source-code files, software clones, and the like. A popular means of visualizing such relations are edges depicted as lines visually connecting the related elements. To diminish the visual clutter that can occur when drawing a large number of edges, hierarchical edge bundles, based on B-Splines, have proven suitable. In addition to a purely static view of software, animations, both of the elements and the edges, can contribute to the usability of a visualization by making changes easier to track for users. In this paper we discuss how B-Splines can be used as a basis for a variety of edge layouts and how edges represented as B-Splines can be animated using B-Spline morphing. We also discuss the challenges of morphing B-Splines, especially of those whose shape does not result solely from the positions of the connected elements (e.g., straight lines), but whose structure depends on multiple aspects (e.g., hierarchical edge bundles) and provide a solution to make arbitrary B-Splines compatible for morphing. The practicality of edge animation is demonstrated by use cases which we already implemented or plan to implement in the future in our software visualization tool SEE. Supplemental material: https://github.com/tinyspline/vissoft2022/archive/refs/tags/1.0.0.zip (see README.md in the zip archive)
Article
Full-text available
Dominance analysis from graph theory allows one to locate subordinated software elements in a rooted dependency graph. It identifies the nesting structure for a dependency graph as a dominance tree, and, hence, adds information not immediately visible irn large and complex graphs. Moreover, the subordination (or locality) can be leveraged for drawirng dependency graphs. This paper envisions ways to leverage the dominance relation for structurirng and presenting large dependency graphs. To explore the feasibility of these kinds of visualization, we measure dominance trees for large software systems written in different programming languages. These measurements give us the necessary information to design a usable visualization.
Conference Paper
Full-text available
Evolutionary information about software systems has proven to be a good resource to complement existing reverse engineering approaches, because it helps in giving a historical perspective of the system to be reverse engineered. Moreover, it provides additional types of information that are not present when only one version of a system is considered. Logical coupling, the implicit dependency between artifacts which changed together, is one example of such information. However, the recurrent problem is that such information comes in large amounts and must be processed to be useful for the reverse engineering of a system. In this paper we propose an approach to use logical coupling information at different levels of abstraction to detect areas in the system which may lead to maintenance problems. They represent a good starting point to decrease the coupling in the system. Our approach uses an interactive visualization technique called the Evolution Radar, which can effectively break down the amount and complexity of the logical coupling information. We present our technique in detail and apply it on a large open-source software system
Conference Paper
Full-text available
Many of the existing approaches to reverse architecting - the reverse engineering of the architecture of software systems - are based on software exploration tools which provide interactive ways of exploring the system. These tools start with high-level views of the system and refine them with drill-down techniques applied on the high-level entities such as modules and packages, leaving aside valuable information contained in the dependencies between them. In this article we argue that the visualization of inter-module relations bears great potential for supporting the understanding of large evolving software systems. We present two concrete examples of such visualizations. The first, the semantic dependency matrix is a technique for displaying details about a dependency between two modules which groups together classes with similar behavior. The second, the edge evolution film-strip presents the evolution of an inter-module relation through multiple versions of the system. Based on our experience with the edge evolution film strip, we propose a pattern language for inter-module relationships. We exemplify both the visualizations and the pattern language with examples from two large open source software systems
Conference Paper
Full-text available
Software systems are complex and difficult to analyze. Reengineering is a complex activity that usually involves combining different techniques and tools. MOOSE is an reengineering environment designed to provide the necessary infrastructure for building new tools and for integrating them. MOOSE centers on a language independent meta-model, and offers services like grouping, querying, navigation, and meta-descriptions. Several tools have been built on top of MOOSE dealing with different aspects of reengineering like: visualization, evolution analysis, semantic analysis, concept analysis or dynamic analysis.
Article
From the Publisher:Object-Oriented Design Heuristics offers insight into object-oriented design improvement. The more than sixty guidelines presented in this book are language-independent and allow you to rate the integrity of a software design. The heuristics are not written as hard and fast rules; they are meant to serve as warning mechanisms which allow the flexibility of ignoring the heuristic as necessary. This tutorial-based approach, born out of the author's extensive experience developing software, teaching thousands of students, and critiquing designs in a variety of domains, allows you to apply the guidelines in a personalized manner. The heuristics cover important topics ranging from classes and objects (with emphasis on their relationships including association, uses, containment, and both single and multiple inheritance) to physical object-oriented design. You will gain an understanding of the synergy that exists between design heuristics and the popular concept of design patterns; heuristics can highlight a problem in one facet of a design while patterns can provide the solution. Programmers of all levels will find value in this book. The newcomer will discover a fast track to understanding the concepts of object-oriented programming. At the same time, experienced programmers seeking to strengthen their object-oriented development efforts will appreciate the insightful analysis. In short, with Object-Oriented Design Heuristics as your guide, you have the tools to become a better software developer.
Conference Paper
DependencyViewer helps to control package dependencies to avoid degeneration of package designs. To this end it computes design quality metrics including stability and abstractness for each Java package and draws the package graph in a way, such that violations of various design principles are immediately visible. In addition DependencyViewer provides several features to inspect the packages at various levels of details including at the level of source code
Conference Paper
The problem of trying to view and comprehend large amounts of data is a well-known one. A specialised variant of this problem is the visualisation of software code and components for the purposes of understanding, decision-making, reuse and even integration. In particular the visualisation of software components, at a much higher level than source code, has received very little research. Visualisation is a powerful tool in situations such as this. This paper presents the application of real world metaphor based visualisations that address this problem. The application of visualisation to selecting software components is especially novel. It seeks to decrease the effort required by system integrators when locating suitable components in what is an increasingly crowded marketplace. Accurate information and understanding are vital if correct and informed decisions and judgements are to be made.
Conference Paper
DependencyViewer helps to control package dependencies to avoid degeneration of package designs. To this end it computes design quality metrics including stability and abstractness for each Java package and draws the package graph in a way, such that violations of various design principles are immediately visible. In addition DependencyViewer provides several features to inspect the packages at various levels of details including at the level of source code. 1