This paper presents a study in which we compared the visualization of code smells in Code Cities with classical tabular representations. We conducted a controlled experiment with 20 participants who had to solve six tasks in both environments. We evaluated the results of our experiment statistically and came to the following conclusions: In four tasks the completion time was significantly lower when using Code Cities (the remaining two tasks did not show any statistically significant differences for any of the two environments). Also, the perceived effort was significantly lower in three tasks when the participants used Code Cities over the tabular representation (again, the remaining tasks did not show any statistically significant differences). However, with regard to the perceived usability (which was measured across all tasks) and the correctness of the supplied answers, the tabular representation performed better. In particular, in two tasks the correctness was significantly better in the tabular environment and in one task the correctness was significantly better in the Code Cities environment. Based on our results, our verdict is as follows: Code Cities are better suited to get a quick overview of the code smells of a software, whereas tabular representations are better suited to analyze code smells in more detail.Experiment data, evaluation scripts and supplemental material: https://github.com/uni-bremen-agst/VISSOFT2022/archive/ refs/tags/1.0.0.zip (see README.md in the ZIP archive)

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)

Software quality comprises different and interrelated aspects. One of them is maintainability, which in turn is made up of measurable attributes. Previous studies have shown that documentation, by contributing to the comprehensibility of software, may have a positive effect on maintainability and, hence, software quality. This paper presents a study in which we analyzed Javadoc comments from 163 different open-source projects. Javadoc is the de facto standard for documenting source code files in Java projects, and although its syntax is less strict than in other (programming) languages, documentation written with Javadoc may contain violations. Our study focuses on the detection of different types of Javadoc violations as well as the source code elements affected by them. Also, by utilizing software repository mining techniques, we examined the history of the subject systems to gain further insights into the evolution of Javadoc violations. According to our results, about half of the source code elements have no Javadoc whatsoever. Among the different components of Javadoc comments (if present), the description of exceptions, by far, has the highest average ratio of violations. With regard to the types of affected elements, constructors and methods show very high average ratios. Also, we found that, on average, violations live more than two years.Nowadays, most integrated development environments (IDEs) for Java are capable of detecting missing Javadoc comments as well as comments with syntactic errors. However, our results indicate that the documentation of source code might be considered less important to developers or that these tools alone may not be sufficient for maintaining consistent documentation.

NURBS, B-Splines, and Bézier curves have a wide range of applications. One of them is software visualization, where these kinds of splines are often used to depict relations between objects in a visually appealing manner. For example, several visualization techniques make use of hierarchical edge bundles to reduce the visual clutter that can occur when drawing a large number of edges. Another example is the visualization of software in 3D, virtual reality, and augmented reality environments. In these environments edges can be drawn as splines in 3D space to overcome the natural limitations of the two-dimensional plane-e.g., the collision of edges with other objects. While Bézier curves are supported quite well by most UI frameworks and game engines, NURBS and B-Splines are not. Hence, spline-based visualizations are considerably more difficult to implement without in-depth knowledge in the area of splines.In this paper we present TinySpline, a general purpose library for NURBS, B-Splines, and Bézier curves that is well suited for implementing advanced edge visualization techniques-e.g., but not limited to, hierarchical edge bundles. The core of the library is written in ANSI C with a C++ wrapper for an object-oriented programming model. Based on the C++ wrapper, auto-generated bindings for C#, D, Go, Java, Lua, Octave, PHP, Python, R, and Ruby are provided, which enables TinySpline to be integrated into a large number of applications.

Studying software visualization often includes the evaluation of paths collected from participants of a study (e.g., eye tracking or movements in virtual worlds). In this paper, we explore clustering techniques to automate the process of grouping similar paths. The heart of the evaluated approach is a distance metric between paths that is based on dynamic time warping (DTW). DTW aligns two paths based on any given distance metric between their data points so as to minimize the distance between those paths-alignment may stretch or compress time for best fit. With a data set of 127 paths of professional software developers exploring code cities in virtual reality, we evaluate the clustering based on objective quality indices and manual inspection.

Mining version control systems, such as Git, Mercurial, and Subversion, is a good way to analyze different aspects of software evolution. Several previous studies, for example, analyzed how cloning in software evolves by tracking findings through the change history of source code files. By linking in issues (reported and discussed in issue tracking systems), results can be further refined—for instance, identifying commits that removed long-lived clones and fixed known issues. However, due to the absence of suitable tools, most of these studies implemented their own data extraction approaches. In this paper we present LibVCS4j, a Java programming library which can be integrated into existing analysis tools—for example, tools that detect code smells in source code files—to i) iterate through the history of software repositories, ii) run the desired analysis on a selected set of revisions, and iii) fetch additional information (commit messages, file differences, and so on) while processing a repository. The library unites different version control systems and issue tracking systems under a common interface and, thus, is well suited to decouple data analysis from data extraction.

When analyzing software systems, a large amount of data accumulates. In order to assist developers in the preparation, evaluation, and understanding of findings, different visualization techniques have been developed. Due to recent progress in immersive virtual reality, existing visualization tools were ported to this environment. However, three-dimensional and virtual reality environments have different advantages and disadvantages, and by transferring concepts, such as layout algorithms and user interaction mechanisms, more or less one-to-one, the characteristics of these environments are neglected. In order to develop techniques adapting to the circumstance of a particular environment, more research in this field is necessary. In previously conducted case studies, we compared EvoStreets deployed in three different environments: 2D, 2.5D, and virtual reality. We found evidence that movement patterns—path length, average speed, and occupied volume—differ significantly between the 2.5D and virtual reality environments for some of the tasks that had to be solved by 34 participants in a controlled experiment. In this paper, we analyze the results of this experiment in more details, to study if not only movement is affected by these environments, but also the way how EvoStreets are observed. Although we could not find enough evidence that the number of viewpoints and their duration differ significantly, we found indications that in virtual reality viewpoints are located closer to the EvoStreets and that the distance between viewpoints is shorter. Based on our previous results and the findings of this paper, we present visualization and user interaction concepts specific to the kind of environment.

Analyzing and maintaining large software systems is a challenging task due to the sheer amount of information contained therein. To overcome this problem, Steinbrückner developed a visualization technique named EvoStreets. Utilizing the city metaphor, EvoStreets are well suited to visualize the hierarchical structure of a software as well as hotspots regarding certain aspects. Early implementations of this approach use three-dimensional rendering on regular two-dimensional displays. Recently, though, researchers have begun to visualize EvoStreets in virtual reality using head-mounted displays, claiming that this environment enhances user experience. Yet, there is little research on comparing the differences of EvoStreets visualized in virtual reality with EvoStreets visualized in conventional environments. This paper presents a controlled experiment, involving 34 participants, in which we compared the EvoStreet visualization technique in different environments, namely, orthographic projection with keyboard and mouse, 2.5D projection with keyboard and mouse, and virtual reality with head-mounted displays and hand-held controllers. Using these environments, the participants had to analyze existing Java systems regarding software clones. According to our results, it cannot be assumed that: 1) the orthographic environment takes less time to find an answer, 2) the 2.5D and virtual reality environments provide better results regarding the correctness of edge-related tasks compared to the orthographic environment, and 3) the performance regarding time and correctness differs between the 2.5D and virtual reality environments.

Software visualization is a growing field of research, in which developers are assisted in understanding and analyzing complex applications by mapping different aspects of a software system onto visual attributes. Under the assumption that virtual reality, due to the higher degree of immersion, may enhance user experience, researchers have begun to port existing visualization techniques to this environment. Oftentimes, layout algorithms and user interaction methods are more or less transferred one-to-one, though little is known about the effect of virtual reality in visual analytics and program comprehension. Moreover, little research on the behavior of developers in different three-dimensional visualization environments has been done yet. This paper extends the results of a previous controlled experiment, in which the EvoStreets visualization technique was compared in different two-and three-dimensional environments. In the original experiment, we could not find evidence that any of the environments, namely, 2D, 2.5D, and virtual reality, effects the time required to find an answer or the correctness of the given answer. However, we found indications that movement patterns differ between the 2.5D and the virtual reality environments. For this paper, we analyzed and refined the movement trajectories that have been recorded in the previous experiment. We found significant differences for some of the tasks that had to be solved by the participants. In particular, we found evidence that the path length, average speed, and occupied volume differ. Though we could find significant correlations between these metrics and correctness, we found indications that there is a correlation with time, which, in turn, differs significantly between the 2.5D and the VR environments for many tasks. These findings may have implications on the design of visualizations, interactions, and recommendation systems for these different environments.

Code smells are indicators of design flaws that may have negative effects on software comprehensibility and changeability. In recent years several detection tools have been developed that are supposed to help in revealing code smells in large size software systems. However, usually a subset of the detected code smells are suitable for refactorings only. Previous studies on software clones have shown that visualization of findings may assist developers in identifying relevant refactoring opportunities by highlighting peculiarities and, thus, is useful to enhance a software's maintainability. Nevertheless, techniques to visualize code smells in general are rare, though, being an interesting field of research to bridge the gap between code smell detection and code smell refactoring. This paper presents a visualization approach that is supposed to help in assessing the dispersion and extent of arbitrary code smells by combining different existing techniques. The core of our approach consists of several Treemaps that are arranged on a circle in order to obtain a better integration of additional visualizations. Furthermore, the presented technique provides various interaction mechanisms that allow users to adjust the visualization to target elements of interest.