Software Visualization Research

Project Mission

Managing large-scale software development and the understanding of large software systems present many research opportunities for information visualization. How can visualization help understand the relationship betweeen the communication between developers and the evolution of the source code? Furthermore, program comprehension is key to software maintenance. How can visualization help understand programs in a way not complicated by scale and contextuality?


Michael Ogawa, Ph.D. student, VIDI

Kwan-Liu Ma, Professor, VIDI

Software Evolution Storylines
Michael Ogawa and Kwan-Liu Ma
In Proceedings of ACM Symposium on Software Visualization (SoftVis 2010)
October, 2010
This paper presents a technique for visualizing the interactions between developers in software project evolution. The goal is to produce a visualization that shows more detail than animated software histories, like code_swarm, but keeps the same focus on aesthetics and presentation. Our software evolution storylines technique draws inspiration from XKCD's "Movie Narrative Charts" and the aesthetic design of metro maps. We provide the algorithm, design choices, and examine the results of using the storylines technique. Our conclusion is that the it is able to show more details when compared to animated software project history videos. However, it does not scale to the largest projects, such as Eclipse and Mozilla.

[ Project Page ] [ PDF ] [ Source Code ]
code_swarm: A Design Study in Organic Software Visualization
Michael Ogawa and Kwan-Liu Ma
In IEEE Transactions on Visualization and Computer Graphics
Nov/Dec, 2009 (vol. 15 no. 6)
This visualization, called code_swarm, shows the history of commits in a software project. A commit happens when a developer makes changes to the code or documents and transfers them into the central project repository. Both developers and files are represented as moving elements. When a developer commits a file, it lights up and flies towards that developer. Files are colored according to their purpose, such as whether they are source code or a document. If files or developers have not been active for a while, they will fade away. A histogram at the bottom keeps a reminder of what has come before.

[ Project Page & Videos ] [ PDF ] [ Source Code ]
StarGate: A Unified, Interactive Visualization of Software Projects
Michael Ogawa and Kwan-Liu Ma
In Proceedings of IEEE PacificVis 2008
March, 2008
With the success of open source software projects, such as Apache and Mozilla, comes the opportunity to study the development process. In this paper, we present StarGate: a novel system for visualizing software projects. Whereas previous software project visualizations concentrated mainly on the source code changes, we literally place the developers in the center of our design. Developers are grouped visually into clusters corresponding to the areas of the file repository they work on the most. Connections are drawn between people who communicate via email. The changes to the repository are also displayed. With StarGate, it is easy to look beyond the source code and see trends in developer activity. The system can be used by anyone interested in the project, but it especially benefits project managers, project novices and software engineering researchers. The StarGate construct can be used to visualize not only software projects, but also music catalogues, online forums, and generally any complex system that features a network connected to a hierarchy.

[ PDF ] [ Flash Video ]
Visualizing Social Interaction in Open Source Software Projects
Michael Ogawa, Kwan-Liu Ma, Christian Bird, Premkumar Devanbu, and Alex Gourley
In Proceedings of Asia-Pacific Symposium on Visualization (APVIS)
February, 2007, pp. 25-32
Open source software projects such as Apache and Mozilla present an opportunity for information visualization. Since these projects typically require collaboration between developers located far apart, the amount of electronic communication between them is large. Our goal is to apply information visualization techniques to assist software engineering scientists and project managers with analyzing the data. We present a visualization technique that provides an intuitive, time-series, interactive summary view of the the social groups that form, evolve and vanish during the entire lifetime of the project ...
[ PDF ] [ BibTeX ]
Visualizing the Eclipse Bug Data
Michael Ogawa, Kwan-Liu Ma and Zhendong Su
demo image
We have created a simple treemap visualization of the Saarland University Eclipse bug data.

[ Project Page & demos ]
Stable, Flexible, Peephole Pretty-Printing
Stoney Jackson, Premkumar Devanbu and Kwan-Liu Ma
(To appear in the Journal "Science of Computer Programming", 2008)
Pretty-printers reduce the time programmers spend reading and understanding code. Pretty-printers found in modern development environments are hand crafted for responsiveness, an imperative property for interactive environments. However, these pretty-printers are language specific, tightly integrated into development environments, and have limited customizability. The literature describes how to generate pretty-printers that are customizable and reusable, and that are make efficient use of the presentation space. However, these pretty-printers only provide a global rendering capacity, i.e., they can only render entire files. This reduces responsiveness, preventing their use in modern development environments. We present a flexible, stable, peephole-efficient pretty-printing algorithm for generated pretty-printers. It is flexible in that it is capable of screen-optimized layouts, and also supports fisheye views. The algorithm is peephole-efficient, in that it performs work proportional to the size of the visible window and not the size of the entire file. Finally, the algorithm is stable, in that the rendered view is identical to that which would be produced by formatting the entire file.