VISSOFT 2014 Call For Papers

Image

http://vissoft.iro.umontreal.ca/

The second IEEE Working Conference on Software Visualization (VISSOFT 2014) builds upon the success of the first edition of VISSOFT in Eindhoven, which in turn followed after six editions of the IEEE International Workshop on Visualizing Software for Understanding and Analysis (VISSOFT) and five editions of the ACM Symposium on Software Visualization (SOFTVIS). In 2014, VISSOFT will again be co-located with ICSME in Victoria, BC, Canada.

Software Visualization is a broad research area encompassing techniques that assist in a range of software engineering activities, such as, specification, design, programming, testing, maintenance, reverse engineering and reengineering. Covered methods contain the development and evaluation of approaches for visually analyzing software and software systems, including their structure, execution behavior, and evolution.

In this conference, we focus on visualization techniques that target aspects of software maintenance and evolution, program comprehension, reverse engineering, and reengineering, i.e., how visualization helps programmers to understand, analyze, and evolve software. We aim to gather tool developers, users and researchers from software engineering, information visualization, and human-computer interaction to discuss theoretical foundations, algorithms, techniques, tools, and applications related to software visualization. We seek theoretical, as well as practical papers on applications, techniques, tools, case studies, and empirical studies.

Topics of interest include, but are not limited to:- Program visualization- Visual software analytics- Network visualizations in software engineering- Visualization of software documentations- Visualization of parallel programs- Visualization-based software in computer science and software engineering education- Visualization of workflow and business processes- Integration of software visualization tools and development environments- Visualization of web services- Visualization of software evolution- Visualization of database schemes- Protocol and log visualization (security, trust)- Graph algorithms for software visualization- Layout algorithms for software visualization- Visual debugging- Software visualization on the internet- Empirical evaluation of software visualization- Visualization to support program comprehension- Visualization to support software testing- Visualization of software repositories- Social media visualization Papers are solicited that present original, unpublished research results and will be rigorously reviewed by an international program committee. In addition to full papers, VISSOFT features a New Ideas or Emerging Results (NIER) track and a tool demo track related to the same list of topics suggested above. All accepted submissions will appear in the conference proceedings and the IEEE Digital Library. Hints for writing Software Visualization research papers are available online (http://www.st.uni-trier.de/~diehl/softvis/org/softvis06/hints.html).

Submission Information

Authors should prepare and electronically submit their papers or abstracts via the EasyChair submission site (https://www.easychair.org/conferences/?conf=vissoft2014). Take care that you provide all required information in EasyChair. At least one author of an accepted paper must attend the conference to present the work. The review process will be single-blind.

All papers must conform, at time of submission, to the IEEE Formatting Guidelines. Make sure that you use this MS Word template (http://www.conference-publishing.com/templates/MSW_USltr_format.doc) and this LaTeX class (http://www.ctan.org/tex-archive/macros/latex/contrib/IEEEtran/IEEEtran.cls updated January 3rd, 2013). Submissions must be in PDF format. Make sure that you are using the correct IEEE style file: the title should be typeset in 24pt font and the body of the paper should be typeset in 10pt font. Latex users: please use \documentclass[conference]{IEEEtran} (without option compsoc or compsocconf).

Submission Types

Technical papers (up to 10 pages): These contributions describe in-depth mature research results in the above-mentioned areas of interest. The submission of a video (up to 5 minutes in length) to accompany the paper is highly encouraged to show interaction possibilities. Authors who wish to submit such video should provide a URL to the video at the end of the abstract input box in EasyChair (not in the submitted paper itself!).

NIER papers (up to 5 pages): The NIER contributions describe work-in-progress and preliminary exciting results. Authors should include open questions and even provocative hypotheses to get early feedback on their research ideas or even support through new research collaborations.

Tool papers (up to 4 pages): Tool contributions describe the design or actual utilization of software visualization tools, with a focus on relevant tool construction aspects or the use of the tool for gaining new insights. Authors should be prepared to demonstrate their tool at the conference.

Challenge paper (up to 4 pages): In the software visualization challenge, authors are to demonstrate the usefulness of their visualization tools on the data provided. The paper should first provide an introduction to the problem, data used, methods and tools used, results and their implications, and conclusions.

Important Dates

Main track (technical papers)

Abstract Submission: May 9, 2014
Paper Submission: May 16, 2014
Author Notification: June 20, 2014
Camera-ready Copies: July 14, 2014

NIER, Tool Demo, and Tool Challenge tracks:

Abstract Submission: June 24, 2014
Paper Submission: July 1, 2014
Author Notification: July 25, 2014
Camera-ready Copies: August 7, 2014

Organizing Committee

General Chair: Houari Sahraoui (University of Montreal, CA)

Program Co-Chairs: Bonita Sharif (Youngstown State University, US) and Andy Zaidman (Delft University of Technology, NL)

NIER & Tool-Demo Track Co-Chairs: Fabian Beck (University of Stuttgart, DE) and Mircea Lungu (University of Bern, CH)

Publicity & Web Chair: Daniel Limberger (Hasso Plattner Institute, DE)

Posted in Announcements, Conferences | Tagged , , , | Leave a comment

Survey on the Use of Sketches and Diagrams

This is a guest post by Sebastian Baltes, University of Trier. Please consider taking part in his short study (details see below).

Over the last decade, studies have shown that, despite the dominance of source code, sketches and diagrams play a major role in software engineering practice.

The focus of our current research is to expand our knowledge on the use of sketches and diagrams in software engineering practice. We are particularly interested in how these visual artifacts are related to source code. We do not exclusively focus on software developers, but on all “software practitioners” including testers, architects, project managers, but also researchers and consultants.

If you think that you belong to this group of software practitioners, please help us gaining deeper insights into your work practice by participating in our short survey. It just takes five to ten minutes of your valuable time:

http://www.st.uni-trier.de/survey

For more information, don’t hesitate to contact me.
Thanks in advance for your participation!

Posted in Announcements | Tagged , | Leave a comment

Software Visualization Highlights at EuroVis 2013

eurovis13In mid June 2013, the European visualization community spent a hot and, at the same time, refreshing week (both contentwise and weatherwise) in Leipzig meeting for EuroVis 2013. Since the scope of EuroVis is rather broad and covers all kinds of visualization problems, I was surprised to find a couple of works on software visualization there. A feature that connects these works (and even may be one of the current main challenges in information visualization in general) is scalability: software systems are large and complex systems that are difficult to understand. Managing size and complexity becomes a key to success for a software visualization approach.

Hierarchical Organization of Software Systems

A modularization usually structures a software system hierarchically. This hierarchy helps to abstract from the specific source code entities: it reduces the scalability requirements for a visualization technique. However, the levels of abstraction do not necessarily map to the levels of the modularization hierarchy: importance (with respect to a specific task at hand) of hierarchy elements might not be distributed uniformly within one level. Karloff and Shirley address this issue and propose an approach which partly collapses the hierarchy while trying to preserves most of the entropy within the data. Though the approach is not specifically directed at software visualization, it can be applied in this context, for example, as described in their paper, for visualizing webpage visits or directory trees. The paper of Rufiange et al., in contrast, uses the hierarchical modularization to extend NodeTrix (a salable graph visualization approach mixing node-link and matrix elements) to represent compound graphs (a graph plus a hierarchy). As demonstrated in the paper, the extended technique is applicable to show the couplings and the modularization of a software system; hierarchy elements can be collapsed to increase the level of abstraction.

  • Maximum Entropy Summary Trees. Howard Karloff and Kenneth Shirley [pdf] [webpage]
Maximum Entropy Summary Tree; Karloff and Shirley

Maximum Entropy Summary Tree; Karloff and Shirley

  • Tree Matrix: A Hybrid Visualization of Compound GraphsSébastien Rufiange, Michael J. McGuffin, Christopher P. Fuhrman [PDF] [video]
Tree Matrix; Rufiange et al.

Tree Matrix; Rufiange et al.

Performance Visualization

A second focal point was the visualization of software performance. The two visualization approaches presented at EuroVis in particular address the question how to deal with many parallel processes. In the context of high-performance computing, Sigovan et al. propose an animated visualization technique that plots the execution times of function calls on a logarithmic scale; the calls “climb” the scale until they are completed. Discerning multiple parallel processes and function types allows detecting interesting execution patterns. For CUDA programming, Rosen studies the execution of parallel processes based on memory behavior instead of function calls; he employs a family of visualization techniques varying in level of abstraction.

  • Visualizing Large-scale Parallel Communication Traces Using a Particle Animation TechniqueCarmen Sigovan, Chris Muelder, Kwan-Liu Ma [PDF]
  • A Visual Approach to Investigating Shared and Global Memory Behavior of CUDA Kernels. Paul Rosen [PDF]
Posted in Conferences, Papers, Research, Uncategorized | Tagged , , , , | Leave a comment

Software Visualization Highlights at ICPC and ICSE 2013

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.

DSC04952

ICPC 2013

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 ViewpointsKenichi 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 AwarenessMichele 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.

ICSE 2013

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.

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.

Posted in Conferences, Uncategorized | Tagged , , , , , , | Leave a comment

Visualizing Code Couplings: Node-Link Diagrams

From an abstract point of view, software systems can be considered as a set of entities connected by dependencies or code couplings such as method calls. We might also consider that entities inherit or aggregate, that they are changed together, that they are covered by the same code clone, etc. Since code couplings can be modeled as a graph consisting of vertices and edges, graph visualization provides the right tools for depicting this kind of information. The visualization of graphs is a very active discipline and provides a broad spectrum of visualization approaches. Usually, graphs of code couplings consist of a large set of vertices. This premise somewhat limits the number of appropriate graph visualization approaches because many approaches run into scalability problems for an increasing number of vertices.

Von Landesberger et al. survey graph visualizations that are particularly applicable to large graphs:

Von Landesberger, Tatiana, et al. “Visual Analysis of Large Graphs: State‐of‐the‐Art and Future Research Challenges.Computer graphics forum. Vol. 30. No. 6. Blackwell Publishing Ltd, 2011.

Simple Node-Link Diagrams

nl

Most of the approaches that visualize code couplings are based on node-link diagrams where the code entities are represented by node connected through lines (i.e., links). The central design decision in such diagrams is the layout of the nodes and links because overlapping visual elements could significantly decrease their readability. The question of laying out a graph based on node-link diagrams has been studied in detail by the graph drawing community and a set of aesthetic criteria conceptualize the readability of node-link layouts: for example, the number of edge crossings should be minimized. Moreover, maximizing symmetries and reducing the number of edge bends are said to support the readability of node-link diagrams. Graph layout algorithms usually try to optimize one or a set of these criteria.

Besides aesthetic criteria, a hierarchical organization of the nodes may also help to create readable graph visualizations. In software systems, a hierarchy is usually provided by the modularization such as a package or directory structure; in other scenarios or if required, a hierarchy can be created by applying hierarchical graph clustering. When visualizing large graphs, the hierarchy can be used for structuring the nodes or for increasing the level of abstraction: hierarchy nodes aggregate sets of graph nodes and thereby reduce complexity.

Software Tools:

The following tools have integrated a simple node-link visualization of code couplings, among many other features.

UML Diagrams

uml

A quite established standard for modeling and depicting object-oriented systems is the Unified Modeling Language (UML). This visual language defines a set of diagrams modeling the structure and behavior of software systems. Relational information is a central part of most of these diagrams and usually represents a sort of code coupling. Although the different types of UML diagrams may look quite different, all diagrams are based on the node-link metaphor. For instance, a UML class diagram as sketched above describes the classes and interfaces of a software system as rectangular boxes connected by a set of possible couplings like inheritance, composition, aggregation, or association. These couplings are distinguished by using different stroke styles and different types of arrow heads for drawing the links.

Software Tools:

Wikipedia maintains an extensive list of UML tools.

Enriched Node-Link Diagrams

UML class diagrams depict the design of a system at class level focusing more on the classes than on the couplings between them. Other approaches exist that apply the node-link approach to software visualization and add further information to the diagram. Many of these approaches target a high level of abstraction or larger excerpts of the system than class diagrams. For instance, SHriMP/Creole are visualization tools that integrate several views on a software system, among them node-link-based visualizations on package level. To reduce the complexity of such diagrams, DA4Java first hides the coupling information, but allows adding relevant couplings interactively. Without hiding any of the information, couplings can be visualized in a radial layout applying edge bundling as used in SolidSX.

enriched_nl

It is further possible to visualize software metrics along with the graph structure. E-Quality combines the visualization of different software metrics by shape and color and other attributes with the visualization of different concepts of coupling: it discerns seven concepts of static structural coupling by color, indicates direction with arrow heads, uses thickness as an indicator of frequency, and discerns inter-package edges from intra-package edges by stroke style. Other visualization techniques show more details including fine-grained coupling information below class level. For instance, Class Blueprints divide the fields and methods of each class into five categories, visualized in columns as parts of rectangular class representations. Links connect related fields and methods, within classes as well as between classes.

Software Tools:

  • SHriMP/Creole—Eclipse plugin for Java (free)
  • DA4Java—Eclipse plugin for Java (non-commercial use)
  • SolidSX—standalone tool for multiple environments (commercial)
  • Structure 101—standalone tool for multiple environments (commercial)

Map-Based Approaches

The layout of node-link diagrams is essential for creating a readable visualization. At higher level of abstraction, the hierarchical modularization of a system may help to come up with an appropriate layout. It can be used for subdividing the drawing area and for creating an underlying map for the system. The original graph can be drawn on that map, like sketched below, either in 2D or 3D. Developers might adapt much faster to a map-based layout because they are already familiar with the hierarchical structure of the system.

map

Some approaches exploit the map metaphor further and describe the software system as a city. Applying this metaphor, following more or less a real-world model, promises a more efficient code exploration. The map itself, however, just visualizes the structure of the system, for instance, the package structure.  Software cities are often used for visualizing (non-relational) software metrics and their evolution such as in Software Cities and Landscapes or CodeCity. Drawing links onto a map, in 2D as well as in 3D, leads to occlusion. If the coupling information is only sparse, this problem is not severe. Hence, showing a small selection of links in the visualizations does not significantly decrease their readability. Typically, those links are only shown for a particular entity on demand when interactively selecting the entity. When considering a non-filtered coupling graph, the coupling information often is not sparse anymore. Again, edge bundling can be applied in 3D on top of a map-based code visualization in this scenario. This approach still provides readable images when visualizing all couplings at once, not only a selection of couplings.

Related to drawing links on top of a map-based representation of the software system is the idea of drawing links on top of a source code editor—the code representation in multiple editor views can be considered as a partial map of the system. In the IDE prototype Code Bubbles and the visual debugging tool Debugger Canvas, the editor views are connected themselves by links indicating method calls. Code Canvas uses the idea of a code map as the basic layout of an IDE; similar to software cities, excerpts of coupling information such as stack traces are laid over on demand.

Software Tools:

Posted in Research, Summary, Tools | Tagged , , , , , , , | 1 Comment

VISSOFT 2013 Call For Papers

Call for Papers

http://icsm2013.tue.nl/VISSOFT/

Research paper submission deadline: May 6, 2013

The first IEEE Working Conference on Software Visualization (VISSOFT 2013) follows six editions of the IEEE International Workshop on Visualizing Software for Understanding and Analysis (VISSOFT) and five editions of the ACM Symposium on Software Visualization (SOFTVIS). In 2013, these two events will be united in a single top-tier conference on software visualization which is co-located with ICSM 2013.

Software Visualization is a broad research area encompassing techniques that assist in a range of software engineering activities, such as, specification, design, programming, testing, maintenance, reverse engineering and reengineering. Covered methods contain the development and evaluation of approaches for visually analyzing software and software systems, including their structure, execution behavior, and evolution.

In this conference, we focus on visualization techniques that target aspects of software maintenance and evolution, program comprehension, reverse engineering, and reengineering, i.e., how visualization helps programmers to understand, analyze, and evolve software. We aim to gather tool developers, users and researchers from software engineering, information visualization, and human-computer interaction to discuss theoretical foundations, algorithms, techniques, tools, and applications related to software visualization. We seek theoretical, as well as practical papers on applications, techniques, tools, case studies, and empirical studies. Topics of interest include, but are not limited to:

  • Program visualization
  • Visual software analytics
  • Network visualizations in software engineering
  • Visualization of software documentations
  • Visualization of parallel programs
  • Visualization-based software in computer science and software engineering education
  • Visualization of workflow and business processes
  • Integration of software visualization tools and development environments
  • Visualization of web services
  • Visualization of software evolution
  • Visualization of database schemes
  • Protocol and log visualization (security, trust)
  • Graph algorithms for software visualization
  • Visual debugging
  • Software visualization on the Internet
  • Empirical evaluation of software visualization
  • Visualization to support program comprehension

Papers are solicited that present original, unpublished research results and will be rigorously reviewed by an international program committee. In addition to full papers, VISSOFT features a New Ideas or Emerging Results (NIER) track and a tool demo track related to the same list of topics suggested above. All accepted submissions will appear in the conference proceedings and the IEEE Digital Library. More information on how to submit a paper including paper formatting as well as more information on the NIER and tool demo tracks can be found here:

http://icsm2013.tue.nl/VISSOFT/

Important Dates

  • Full Paper submission deadline: May 6, 2013
  • Author notification: June 17, 2013
  • Camera ready paper deadline: July 12, 2013
  • Deadline for submissions to NIER and tool demo tracks: June 28, 2013
  • Notification for NIER and tool demo tracks: July 18, 2013
Posted in Announcements | Tagged , , | Leave a comment

Software Problems in the News

Andy Ko from the University of Washington and one of his undergraduate RAs has created a neat little visualization highlighting software problems in the news. The data from the visualization is based on over 300,000 news articles over 33 years. Click the link below for the visualization.

Software Problems in the News, 1980-2012

Posted in Research | Tagged , | Leave a comment