Last week, the software engineering community met in San Francisco for ICSE 2013 to discuss recent advances in the field. Co-located to this big event, ICPC 2013 provided a forum for discussing specific questions on program comprehension. In this post, I summarize the most interesting papers and talks of the two conference from the perspective of software visualization.
ICPC started off with an interesting Keynote by Brad Myers on “Improving Program Comprehension by Answering Questions” [slides]. He argued for making the programming experience more natural and presented a list of tools that address different issues in this context. He concluded that developers often have very specific questions for which they need tool support. While the code editor is usually the main view for the developer, visualizations mainly help for effectively navigating the code (which is very important as he pointed out). A further key feature of software engineering tools should be search.
The largest session at ICPC containing four papers was related to visualization, The Role of Visualization in Program Comprehension. Thanks to session chair Andrian Marcus, the session was split into two halfs with separate discussions so that the session did not become too long (ICPC had the mode of doing the main discussion at the end of each session, which usually worked quite well).
Whether a software visualization for requirements comprehension outperforms a textual representation was investigated by Sharafi et al. While the results of their user study are hard to interpret as they are ambivalent pro and contra visualization, the paper is a good example for empirical justification that is certainly required more in the context of software visualization.
- An Empirical Study on the Efficiency of Graphical vs. Textual Representations in Requirements Comprehension. Zohreh Sharafi, Alessandro Marchetto, Angelo Susi, Giuliano Antoniol, and Yann-Gaël Guéhéneuc
Extending the city metaphor, Kobayashi et al. visualize software clustering results and architectural layers within a given package structure. Using this approach, software architectures can be understood and evaluated.
- SArF Map: Visualizing Software Architecture from Feature and Layer Viewpoints. Kenichi Kobayashi, Manabu Kamimura, Keisuke Yano, Koki Kato, and Akihiko Matsuo [PDF]
The two other papers addressed the dynamic runtime behavior of software systems: Trümper et al. introduced a visualization technique to compare stack traces for contrasting multiple runs of a program. This technique helps understanding the effect of a code change or different behavior of a program applied to different data sets.
- Multiscale Visual Comparison of Execution Traces. Jonas Trümper, Jürgen Döllner, and Alexandru Telea [PDF] [Video]
Quite related to that, Beck et al. target the problem of understanding runtime bottlenecks and propose to integrate miniature visualizations into the source code editor showing the runtime consumption of methods.
- In Situ Understanding of Performance Bottlenecks through Visually Augmented Code. Fabian Beck, Oliver Moseler, Stephan Diehl, and Günter Daniel Rey [PDF]
Also two short papers report research on visualization methods: an approach for simplifying UML class diagrams and a case study on the integration of the software cities metaphor into IDEs.
- OnionUML: An Eclipse Plug-In for Visualizing UML Class Diagrams in Onion Graph Notation (Tool Demo). Michael Falcone and Bonita Sharif
- Manhattan: Supporting Real-Time Visual Team Activity Awareness. Michele Lanza, Marco D’Ambros, Alberto Bacchelli, Lile Hattori, and Francesco Rigotti [PDF]
As the most influential paper from 10 years ago, “An XML-Based Lightweight C++ Fact Extractor” by Michael L. Collard, Huzefa Kagdi, and Jonathan I. Maletic was awarded. It was one of the first works of series of papers on srcML, an XML representation of source code accompanied with many tools. The project was not only successfully applied in many projects in the past, but is still actively maintained and even seriously extended. It is a very interesting technology for anybody doing source code analysis, for instance, visualizing source code or aggregates thereof.
Being one of the major software engineering events, ICSE had more than 1000 attendees, lots of parallel sessions, many workshops before and after, and covers nearly every topic related to software development. Maybe two people visiting ICSE may have experienced two largely different conferences. From my personal perspective, I want to highlight a few papers and talks that have are related to visualization or present interesting user interfaces.
Among the three very interesting keynotes, I particularly liked the one by Tony DeRose from Pixar on “The Connection between Movie Making and Software Development“. He talked about the pitfalls and lessons learned developing the new in-house animation software of Pixar, a project as complex and expensive as producing a new blockbuster movie. While the first two tries failed, only applying the movie making metaphor reusing roles and workflow from that domain brought success. People at Pixar directly knew what to do and had strategies to deal with problems. While this approach is probably not directly generalizable to other (non-movie related) businesses, I think specifically the focus on user interfaces and interaction by using sketches and storyboards can be transferred to other software projects.
While none of the papers at ICSE can be rated as a pure software visualization approach, some papers covered certain visualization aspects. For instance, simple graph visualization methods are used for showing clone dependencies between different spreadsheets. Somewhat more complex graph structures help analyzing the flow of domain knowledge in project teams or the clarification process of requirements.
- Data Clone Detection and Visualization in Spreadsheets. Felienne Hermans, Ben Sedee, Martin Pinzger, and Arie van Deursen [publisher] [PDF]
- The Role of Domain Knowledge and Cross-Functional Communication in Socio-Technical Coordination. Daniela Damian, Remko Helms, Irwin Kwan, Sabrina Marczak, and Benjamin Koelewijn [publisher]
- V:ISSUE:LIZER: Exploring Requirements Clarification in Online Communication over Time. Eric Knauss and Daniela Damian [publisher]
From the user interface point of view, a very interesting approach is to use simple drag-and-drop operations for triggering code refactorings. Quite intuitive interactions are proposed for indicating, for instance, move or extract operations.
- Drag-and-Drop Refactoring: Intuitive and Efficient Program Transformation. Yun Young Lee, Nicholas Chen, and Ralph E. Johnson [publisher] [PDF]
Further, sketching in the context of software engineering seems to get a wider attention of the community. Two of the following papers present tools embedding digital sketching into software engineering workflow. Further, Socha and Tenenberg describe an experiment for analyzing the sketching behavior of software developers in the wild. Being reported as work in progress, unfortunately results could not be presented so far.
- Dynamic Injection of Sketching Features into GEF Based Diagram Editors. Andreas Scharf and Till Amma [publisher]
- Enabling a Classroom Design Studio with a Collaborative Sketch Design Tool. Dastyni Loksa, Nicolas Mangano, Thomas D. LaToza, and André van der Hoek [publisher]
- Sketching Software in the Wild. David Socha and Josh Tenenberg [publisher]
Related to using sketches in the wild, the same questions arise for using UML in the wild. As extracted from 50 interviews, many developers actually do not use UML in general while others only apply it informally or partial. UML seems to be more en vogue among academics than in industry.
- UML in Practice. Marian Petre [publisher] [PDF]
also blog post by Tim Lethbridge on UML in Practice talk at ICSE: And How Umple Could Help
What is More
Last but not least, some impressions from the beautiful city of San Francisco and Hyatt Hotel where the conference took place. While ICPC conference dinner was in a nice restaurant just around the corner, ICSE dinner was on a boat providing the great opportunity to see San Francisco’s skyline by night. What I learned in both occasions is that, no matter how warm the weather has been during the day, San Francisco can be quite chilly in the evenings.