Context: Especially with the rise of microservice architectures , software is hard to understand when just the static dependencies are known. The actual call paths and the dynamic behavior of the application are hidden behind network communication. To comprehend what is going on in the software the vast amount of runtime data (traces) needs to be reduced and visualized. Objective: This work explores more effective visualizations to support program comprehension based on runtime data. The pure DynaCity visualization supports understanding normal behavior, while DynaCity rc supports the comprehension of faulty behavior. Method: DynaCity uses the city metaphor for visualization. Its novel trace visualization displays dynamic dependencies as arcs atop the city. To reduce the number of traces, DynaCity aggregates all requests between the same two components into one arc whose brightness reflects both the number and the total duration of the requests. DynaCity also encodes dynamic trace data in a heatmap that it uses to light up the building: the brighter a building is, the more active it is, i.e., the more and the longer the requests are that it receives and/or spawns. An additional color scheme reflects any error/status codes among the aggregated traces. In a controlled experiment, we compare our approach with a traditional trace visualization built into the same Software City but showing all dependencies (without aggregation) as individual arcs and also disabling the heatmap. We also report on a second study that evaluates if an error-based coloring of only the arcs is sufficient or if the buildings should also be colored. We call this extension DynaCity rc as it is meant to support r oot c ause analyses. The source code and the raw data of the quantitative evaluations are available from https://github.com/qaware/dynacity . Results: We show quantitatively that a group of professional software developers who participated in a controlled experiment solve typical software comprehension tasks more correctly (11.7%) and also saved 5.83% of the total allotted time with the help of DynaCity and that they prefer it over the more traditional dynamic trace visualization. The color scheme based on HTTP error codes in DynaCity rc supports developers when performing root cause analyses , as the median of them stated that the visualization helped them much in solving the tasks. The evaluation also shows that subjects using DynaCity rc with colored arcs and buildings find the responsible component 26.2% and the underlying root cause 33.3% more correctly than the group with just colored arcs. They also ranked it 40% more helpful to color both. Conclusion: The DynaCity visualization helps professional software engineers to understand the dynamic behavior of a software system better and faster. The color encoding of error codes in DynaCity rc also helps them with root cause analyses .

Especially with the rise of microservice architectures, software is hard to understand when just the static dependencies are known. The reason is that the actual call paths and the dynamic behavior of the application is hidden behind network communication. To comprehend what is going on in the software the vast amount of runtime data (traces) needs to be reduced and visualized.DynaCity uses the city metaphor for visualization. Its novel trace visualization displays dynamic dependencies as arcs atop the city. To reduce the number of traces, DynaCity aggregates all requests between the same two components into one arc whose brightness reflects both the number and the total duration of the requests. DynaCity also encodes dynamic trace data in a heatmap that it uses to light up the building: the brighter a building is, the more active it is, i.e., the more and the longer the requests are that it receives and/or spawns.In a controlled experiment, we compare our approach with a traditional trace visualization built into the same Software City but showing all dependencies (without aggregation) as individual arcs and also disabling the heatmap. The study shows that professional software developers can solve typical software comprehension tasks faster (5.84%) and more correctly (11.7%) with the help of DynaCity and that they prefer our approach over the more traditional dynamic trace visualization.