VISSOFT 2011 Paper Highlights

VISSOFT 2011, the 6th IEEE International Workshop on Visualizing Software for Understanding and Analysis, took place in Williamsburg, Virginia, USA, September 29-30, 2011 and was co-located with ICSM 2011. The proceedings are available in the IEEE Xplore Digital Library. Of the 21 full papers submitted to the workshop, nine were accepted (acceptance rate: 42%).

This post is by Fabian Beck a new contributor to the SoftVis blog and presents the nine full papers of VISSOFT 2011 in form of a structured review.

Code Dependencies

Dependencies between source code artifacts provide insights in the structure of a software system. Visualizing them is challenging because of the sheer quantity of dependencies usually included in a system. Often the hierarchical organization of the system (e.g., a hierarchical package structure) helps to structure or simplify these dependencies. Among the papers presented at VISSOFT 2011, many involve the visualization of code dependencies, the following three, however, having them in particular focus.

Caserta et al. use the hierarchical organization to map the source code artifacts to a two-dimensional plane exploiting a city metaphor. On top of this plane, in the third dimension, they draw the dependencies that link the artifacts. The authors reduce the visual complexity of the diagram by bundling the dependencies, again using the hierarchical structure of the artifacts. Such hierarchical edge bundling is also used in the approach by Beck F. et al., which focuses on comparing different types of code dependencies. They arrange the hierarchically structured artifacts linearly from top to bottom. Each type of dependency is depicted in a narrow stripe. By arranging the stripes side-by-side these types can be visually compared. The idea of depicting different types of dependencies is also present in the approach by Erdemir et al. They link those dependencies to different quality metrics by encoding them in the shape, color, texture, etc., of the nodes. A distinguishing feature of their approach is the intuitive mapping between metrics and visual attributes.

Dynamic Program Behavior

The analysis of the dynamic behavior of software systems is usually facing even larger sets of data than the analysis of static code dependencies. Visualization approaches depicting such dynamic data, hence, have to apply some form of aggregation to handle the data. As the following two examples show, this aggregation can be realized in different ways.

Code Dependencies can be enriched by dynamic information, for instance, as demonstrated by Deng et al.: They enforce structural dependencies if the connected code entities are covered by the same set of test cases. This dynamic relational information is only used to arrange a large set of code entities onto a two-dimensional plane. For reasons of scalability, their visualization shows these entities as color-coded dots, but does not depict dependencies. Choudhury and Rosen introduce an animated visualization technique for representing runtime memory transactions of a program. Elements of accessed data, visually encoded as glyphs, move between levels of a simulated cache. These glyphs form abstract visual structures that provide insights into the composition and eviction of the cache. The authors suggest that their approach fosters program comprehension with respect to the dynamic behavior of the program.

Visual Analytics Tools & Case Studies

Over the last decade, many software visualization approaches have been proposed, but only very few of them reached wide impact in practice. A reason could be that academia did not sufficiently embed those visualizations into real-world scenarios and development processes. The following analytics tools and case studies might lessen this gap.

When gaining information by visually analyzing a software system, a software developer wants to react to these new insights. Beck M. et al. introduce a tool for planning the reengineering of a software system, that is, changing the software design at a high level. Their tool is also based on a visualization of code dependencies attached with a hierarchy. The innovative features of their approach are the flexible interaction techniques for changing the hierarchy (i.e., the software design). Also Broeksema and Telea target at supporting developers in changing a software system: They investigate the effort to port a system from an older version of a library to a newer one. Their visualization, which they implemented as an IDE plug-in for KDevelop, provides an overview on the necessary changes and guide the developer to realize them.

Neu et al. study not only single software projects, but the ecosystems the individual projects are embedded in. They developed a web application that visualizes the evolution of such ecosystems. As an extensive case study, the GNOME project is analyzed. Long practiced but only recently considered as a serious development method, sketches are explored by Walny et al. In semi-structured interviews they evaluated how software developers in academia use these ad-hoc software visualizations. The interviews reveal that sketches are applied in a broad spectrum of scenarios and are often saved and reused in later stages of development.

This entry was posted in Conferences, Papers, Summary and tagged , , , , , , . Bookmark the permalink.

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s