VISSOFT 2021 – Summary

For the 9th instalment of the IEEE Working Conference on Software Visualization (VISSOFT) 2021 we virtually visited Luxemburg. Co-located on the Morressier platform with SCAM and ICSME, we listened to a provoking keynote by Michele Lanza and an inspiring capstone talk by Daniel Weiskopf. In between the many exciting research presentations, we escaped an Arctic ice station during our social event. Split over two days, the conference featured nine full papers, 14 new and emerging results, two journal-first presentations and two additional tool demos.

Keynote: Singularity

Michele Lanza kicked off the conference with his keynote (or monlogue) “Singularity”, whose content he kept super secret up until the start. He took a critical look at the position VISSOFT currently takes in comparison to other big SE and Viz conferences an imagined the kind of conference we should move (back) to. Have a look at the full keynote on YouTube.

Session 1: Software Architecture

The first session on the topic of Software Architecture was chaired by Richard Müller who gave us an impression of the backstage view in the Morressier Platform:

Samuel Beck presented an approach to support transient behavior in microservice systems through visualizations and and chatbots [1]. Casper Weiss Bang presented Codoc [2], a system for continuous architectural documentation. It enables architectural specifications that are code-driven and therefore updated whenever the system changes. Then, we heard about React-bratus [3] by Mircea Lungu, a prototype to interactively visualize web-based component hierachies in React Projects. Finally, Van Tuan Tran introduced us to the “SECO Storms Maker” [4], a tool that uses word-clouds and graphs to help users traverse software ecosystems by comparing and relating different software projects.

Session 2: Software Comprehension

The second session was focused around software comprehension and chaired by Wilhelm Hasselbring. David Moreno-Lumbreras presented a VR version of CodeCity, which makes it faster but less accurate at first to complete tasks [5]. Carlos Gonzales explained how an architecture visualization for CubeSat Nanosatellites can be used to uncover commits that disruppt the intended architecture [6]. Next, Artturi Tilanterä introduced us to JAAL, a JSON-based Algorithm Animation Language, that can record a students’ actions while learning and manually executing an algorithm on a visualized data structure [7]. Lastly, Dorian Vandamme presented a visualization of excution traces in a program, based on animated light traces that can be filtered with respect to the called components or timestamp in the execution [8].

Session 3: City Metaphor

After our second, well needed break, we kicked off a whole session of city metaphor papers! Including detailed question by our session chair Alexandre Bergel. It started off with a presentation by Veronika Dashuber on DynaCity, a visualization of call traces between components, that manages the large amount of data by aggregating requests between components and brigthening up more heavily used compoenents and connections [9]. Johann Mortara leveraged the code city metaphor to represent dense variability implementations, which are often only implicit in object-oriented code bases [10]. In the following presentation, Susanna Ardigò illustrated a novel approach to visualize the data that drives software systems as clouds above a code city [11]. With a heat map overlay, Alexander Krause adds another dimension to conventional code cities. Their web-tool ExplorViz allows the user to interactively choose different runtime-dependent metric for visualization, even in augmented reality [12].

Session 4: Software Process Management

The last session of the day was headed by Houari Sahraoui and featured four great presentations on visualizations for software process management. Anja Kleebaum explained how continuous software engineering and the constant changes it embodies could be improved by connecting the rationale for a change with all associated software artifacts [13]. Up next, we heard about DiscOrDance, a visual analytics tool by Marco Raglianti for understanding the content, structure and community of volatile and informal communication platforms such as Discord servers [14]. Aron Fiechter introduced the idea of issue tales, a visual representation of the events and actors involved with a GitHub issue over its lifespan [15]. Finishing off the session, Andreas Schreiber presents a visualization of the provenance of a software artifact: the origin, activities and responsibilities that impacted it up to this point in the software project [16].

Social Event: Arctic Survival (Escape Game)

At the end of the first conference day, a small energetic group of participants stayed for the social event: a virtual escape game in the arctic cold! In two groups, we had to decipher pictures, sound fragments and video clips, connecting them to clues and pieces of information scattered throughout an arctic research station. On the way we collected numbers for the keycode of the final lock towards freedom. Both groups ended up super close, but unfortunately no one of them escaped in time…. Hopefully next year around 😄 Overall, it was a super fun event that gave ample opportunity to get to know the others better!

Day II:

Session 5: Software Maintenance

Day 2 of VISSOFT was started by another small opening from our program chair Leonel Merino.
Right after we jumped into the fifth session on Software Maintenance, chaired by Alexandru Telea. Taeyoung Kim presented the Coding Time-Machine which identifies separate development tasks within a commit and visualizes them together with their assoiciated code elements [17]. Next, we dived into the research field of source code editor augmentation with Matúš Sulír’s systematic mapping study that built a taxonomy to describe augmentation visualizations [18]. To support developers in understanding the impact of a code change during review, Lorenzo Gasparini developed ChangeViz: an addition to the GitHub interface that enables developers to navigate to the definitions and uses of the code they are reviewing [19]. Another support for code review was presented by Faruk Balcı. Their tool employes a UML-style visualization of the architecture involved in the changes, annotated with the churn of components and related tickets in the issue tracker [20]. In the last presentation, Davide Paolo Tua introduced us to Voronoi Evolving Treemaps, which visualize the evolution of hierachical structured in an organic and stable way [21].

Session 6: Software Quality

Matúš Sulír moderated the last paper presentation session of VISSOFT 2021, centered around software quality. Céline Deknop illustrated her adapted a visualization of COBOL refactorings to scale up with long chains of changes, only showing parts that really changed between iterations [22]. Then, Patric Genfer introduced Portfoliotrix, a tool that integrates data from a wide range of software quality metrics and visualizes them accross heterogenous software projects to help software quality engineers take decisions [23]. Hagen Tarner presented a visualization of dependencies and code quality metrics of web applications that are made up of components which are re-used throughot the system [24]. To help developers understand which methods are covered by which test cases in their system, and many more questions, Kaj Dreef developed a matrix-based visualization that lets developers drill down from a global interface to custom filtered views [25].

Session 7: Tool Demo

The second afternoon session was our tool demo, organized and moderated by Richard Müller. We could enjoy a more in-depth look at two tools presented earlier: VariCity [10] by Johann Mortara, which visualizes variability in object oriented projects as part of the code city metaphor, and LogDiffNG [22], which can find behavioural differences in software logs. Overall it was a super insightful session and we hope there are more extended demos in the coming year!

Session 8: Awards and Most Influential Paper Talk

Each year, VISSOFT is awarding a Most Influential Paper award to papers that project leading ideas into the community and influenced researchers and practitioners significantly throughout the years. The award was co-chaired by Alexandre Bergel and Craig Anslow. They were proud to name “Software Evolution Storylines” [26] by Michael Ogawa and Kwan-Liu Ma as the most influential paper from SOFTVIS 2010.

Ogawan and Ma introduced storylines to visualize developer’s interactions during a software projects. Inspired by an xkcd comic and metro maps, they aimed to create a more detailed view than animated software histories, while focusing on the asthetics and the presentation.

Katherine Isaacs received the Best Reviewer award for outstanding quality in her reviews for VISSOFT 2021 and Kaj Dreef, Vijay Krishna Palepu, and James Jones received the Best Paper award for their publication “Global Overviews of Granular Test Coverage with Matrix Visualizations” [25].

Capstone: Eye Tracking in (Software) Visualization

At the end of the second day of VISSOFT 2021, Daniel Weiskopf took us on a deep dive on Eye Tracking and how we can use it in our research. He presented visualizations that help analyze complex gaze recordings and introduced different possibilities to use eye tracking to more effectively evaluate software visualization approaches.

Thank you

A big thank you goes out to the hard work of the organization committee to make VISSOFT 2021 possible! With the leading support of our steering committee and the backing of the ICSME organizers and local chairs they gave their best to make this second virtual VISSOFT a success!

Thank you all for attending the conference and for reading our summary!
See you in Cyprus next year 👋🏼

Guest post by Carolin Brandt
PhD Student
Software Engineering Research Group (SERG)
Delft University of Technology
https://carolin-brandt.de/

Posted in Uncategorized | Leave a comment

Visualize Code with Software Architecture Diagrams

The source code is the design. This famous motto means that no matter how many diagrams you draw and discuss with your colleagues, what matters is how the existing source code is actually structured.

The need for visualizing code

It is important to distinguish between the static view of code (how classes depend on each other in source code) and the dynamic view of code (how objects reference each each other at runtime).

Designing clean architecture is related to the static view of code. Clean architecture leads to high maintainability, less error-prone code and overall it keeps developers both productive and motivated. On the other hand caring for the dynamic view is useful for performance and memory management purposes. In this post we’ll focus on the static view.

Any sufficiently large enough system cannot be mastered without some sort of visualization. Consequences of the lack of control on the code structure are entangled components, code smells and architecture erosion. The code base ends up being a mess (spaghetti code metaphor) and the cost of maintenance becomes prohibitive. Unfortunately this scenario is more the rule than the exception in the software industry.

I always had a passion for visualizing existing code and clean architecture. This is not surprising that I created the tool NDepend 15 years ago that now proposes several software architecture diagrams. In this post I will describe our code visualization choices.

The need for visualizing code

Software architecture relates to dependencies between the various elements of a code base: components, packages, namespaces, classes, methods, fields… All Object-Oriented Programming (OOP) concepts are somehow related to dependencies:

  • Encapsulation: Let decide which element the outside world can depend on and which element must be kept private within an implementation.
  • Abstraction: Avoid being dependent on implementation details that typically change more often than carefully thought-out abstraction.
  • Polymorphism: Avoid being dependent on implementation that is chosen at runtime, based on various criteria: type of the target object, generic type parameter (parametric polymorphism) or even type of the object passed as parameter (double dispatching in the visitor pattern)
  • Inheritance: It is not only a powerful way of reusing code, but it also lets the client code decides which level of specialization it should depend on, the lower the better. Depending on a base class or an interface means that the code can operate on a wider range of objects. For example relying on IEnumerable<T> only, means that the code can work with any collection of T (array, list, hashset…).

Dependency Graph

When it comes to dependencies visualization in a code base the usual boxes and arrows dependency graph is the royal kind of diagram to use. However for a long time we favored the Dependency Structure Matrix (DSM) shown in the next section. DSM is less intuitive but it scales better on large code base. For example in the picture below the DSM shows at a glance that the structure is layered because there is no cycle aggregated around the matrix diagonal. Also it shows that some elements are more used than others through horizontal blue lines. The graph on the right is quite unreadable and doesn’t provide such information.

Dependency Structure Matrix vs Dependency-Graph

We favored DSM over graph until we discovered in 2019 a way to draw meaningful and usable graphs made of hundreds or thousands of elements. This finding led to the NDepend version 2020.1 relifted graph released in April 2020. The graph improvements are:

  • Children graphs are nested within boxes of parent graph (recursive)
  • Boxes area is proportional to the size of the element represented (expressed in number of lines of code)
  • A color scheme does highlights dependents of the element selected or hovered
  • The graph scales on the largest code base and can displays live hundreds of thousands of elements (more on this below)
  • Many tools are proposed to navigate code through one-click graph generation.

The graph below shows the architecture of the code of the dependency graph itself. The class GraphController is selected. Mutually dependent classes are in red, classes used directly are in blue and classes used indirectly are in light blue. Edges are also colored accordingly and dashed edges are used to indicate indirect dependency. Here see this graph exported to SVG vector format, expanded till the method level.

Dependency Graph of our Dependency Graph implementation

There are many tools to visualize software architecture through dependency graphs but our implementation scales live on large code bases with thousands of elements. See below a graph made of the 15.000 classes of .NET 6.0 zoomed live.

Dependency Graph scaling on the 15.000 classes of .NET 6.0

Plenty of features are proposed to quickly obtain the right perspective the developer needs to study some code. One of my preferred is the search feature. For example below in the NopCommerce code base we search all namespaces related to the entity customer. Then we filter and expand them.

Search in a Dependency Graph

Visualizing the internal structure of components and how they interact each other is the natural way of using a dependency graph to visualize architecture. However several other useful graphs can be generated and then browsed.

Coupling Graph

Double clicking an edge between two components shows which classes and methods from both components are involved into the coupling.

Obtaining Coupling Graph

Call Graph

With a single click the user can generate a graph made of direct and indirect callers and callees of an element.

Obtaining a Call Graph

Graph of entangled code

Some heuristic are proposed to locate and then visualize entangled area in code.

Discovering Entangled Portions of Code

When Code Visualization leads to Code Navigation

With all these features the dependency graph is not just a tool to visualize code but also a tool to navigate code. Developers spend a significant portion of their days navigating code. Modern IDEs like Visual Studio offer plenty of ways to browse code (detailed in this post 10 Visual Studio Navigation Productivity Tips). Being able to generate any graph live in a few clicks from the code editor, the solution explorer or anywhere else in the IDE increases the developer productivity in many scenarios.

A lot more can be said about visualizing architecture through dependency graph but I want to keep some spaces in this post for other diagrams. You can refer to this documentation and watch this 6 minutes video:

Dependency Structure Matrix (DSM)

As explained above, DSM had been our favored way of visualizing architecture until we relifted the dependency graph that now makes it a better choice in most scenarios. DSM is less intuitive than graph but its strength is that it lets spot complex patterns at a glance. In the first screenshot above we saw that layered code, high level and low level components, can be easily identified. The same way the DSM relies on an heuristic to naturally group rows and columns to highlight dependency cycles. In the below matrix:

  • Black cells means that both elements in row and column are mutually dependent.
  • Blue cell means that the element in column uses the element in row. The weight on cell is the number of types involved.
  • Green cell means that the element in row uses the element in column.
A cycle visualized through a Dependency Structure Matrix

Below is the same structure visualized with graph. Clearly on such super-entangled structure the DSM view is more readable.

Same cycle visualized through a Dependency Graph

Here are some other scenarios where the DSM can help:

High-Cohesion and Low-Coupling

dentify areas in code with High-Cohesion and Low-Coupling. Such pattern provokes some squares aggregated around the diagonal.

High Cohesion and Low Coupling Visualized

Components that is using many other components

Such component is identified by the highlighted column with many blue cells. Typically such code can be dependency injection code: code that binds many classes from many components with their implementations.

A component using many other components

Popular components

A popular components is identified through the highlighted row. This can be the class String or the namespaces System used almost everywhere in code for example.

A Popular Component

To know more about the NDepend DSM you can watch this 5 minutes videos and refer to the DSM documentation.

Heat-Map and Treemap

When treemap was invented in the early 2K’s it fascinated me. Treemaping is a way to visualize metrics and hierarchical data. NDepend has been one of the first tool that uses treemap to visualize code. The tool can now display 2 code metrics at the same time. This is especially useful to visualize code coverage data. In the screenshot below:

  • Small rectangles are methods of the NDepend code base. The rectangle area is proportional to the method number of lines of code (the Size Metric).
  • Larger rectangle are the code hierarchy: classes, namespaces and projects that group their child elements.
  • The color of a method rectangle represents the percentage of code coverage ratio (the Color Metric).

This view instantly tells us that the overall coverage is quite high (actually 86.5%) and pinpoints areas that need more testing efforts.

Treemap and Code Coverage Visualization

This Code Metric View is also useful to pinpoint too complex code and to highlight code query result. You can refer to the documentation and watch this 4 minutes video:

The Abstractness vs. Instability Diagram

One great software book is Agile Software Development, Principles, Patterns, and Practices written by Robert C. Martin (Uncle Bob) in 2002. In this book R.Martin exposes the Dependency Inversion Principle (DIP), one of the famous SOLID principles. This principle states:

a. High-level modules should not depend on low-level modules. Both should depend on abstractions.
b. Abstractions should not depend on details (concrete implementation). Details should depend on abstractions.

From this defininition R.Martin deduces some metrics:

  • Abstractness within the range [0,1]: If a component contains many abstract types (i.e interfaces and abstract classes) and few concrete types, it is considered as abstract.
  • Instability also within [0,1]: A component is considered stable if its types are used by a lot of types from other components. In this context stable means painful to modify.

The Abstractness versus Instability Diagram helps to detect:

  • Which components are potentially painful to maintain (i.e concrete and stable). For example imagine modifying the implementation of the class string used by the entire world. The chances to break some clients is high and you would have to be super careful. Welcome to the Zone of Pain.
  • Which components are potentially useless (i.e abstract and instable). For example imagine an interface used and implemented by almost nobody. This is the Zone of Uselessness.
Abstractness vs Instability Diagram

Code Querying

During our researches in the early days of NDepend we quickly realized that code visualization is great and useful, but it cannot let the user browse all dimensions of the code. By code dimensions I mean artefacts like:

  • code size
  • code complexity
  • code coverage
  • code hierarchy (projects contain namespaces that contain classes that contain members)
  • code dependencies,
  • usage of OOP concepts (inheritance, virtual methods, encapsulation…)
  • state mutability (assigning a field, immutable class, pure method…)
  • identifiers and naming
  • delta between the actual snapshot and a baseline snapshot
  • source files organization
  • trending

The idea of considering code as data needed to be pushed a little more to imagine that all those dimensions could be queried the same way relational data is queried through SQL. This led first to CQL Code Query Language, that had been quickly refactored to CQLinq Code Query over C# LINQ shortly after the LINQ revolution era early in the 2010’s.

Mixing dimensions within a code query is quite useful. For example in the screenshot below we spot classes added or refactored since the baseline and not 100% covered by tests. This is quite useful information. More generally focusing on code smells introduced since the last release is a powerful way to get used to write better code.

NDepend List Coverage of Code Delta since Baseline

CQLinq quickly became the backbone of the tool and all architecture diagrams explained above are based on it. For example one useful feature is to export elements matched by a code query to the dependency graph or dependency matrix.

Most of code queries are generated so the user can be productive without learning CQLinq up-front. Also CQLinq makes possible many other use-cases than just code visualization including: code rulessmart technical-debt estimationquality gatesreportingtrend chartscode searchaudit legacy codeprioritize hot-spots to fix firstAPI breaking changes detection… This led the community to re-name the tool as the swiss-army-knife for the .NET developers.

Other Potential Ways to Visualize Software Architecture

One promising way to visualize code would be to use 3D. There exists some interesting initiatives like Code City by Richard Wettel in 2008 but these researches never led to an industry standard 3D tool.

CodeCity

Using circle visualization has been also an area of research but to my knowledge it has never been well suited to visualize code. The key is to really add value over existing software visualization technologies.

Circle Visualization

Conclusion

In this post I explained some key ideas and decisions we took within the last 15 years. Today our tool-belt helps thousands of developers worldwide to better understand what they do and thus, write better code. Moreover one of the most rewarding experience when developing a tool for developers is to dogfood it. Being the first users of all these features is quite an intresting position.

More than ever the development technology landscape is evolving quickly, especially in the .NET sphere. The challenge is to be present where the developers are and prepare where they will be. This will mean quite a lot of refactoring for us, like for example to adapt our UI to propose a web or a multi-platform experience. Fortunately thanks to abiding by our own advices during all these years mean that our code is now well fitted to let us handle these challenges confidently.

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

IEEE VISSOFT 2022 – Call for Papers

VISSOFT 2022 (10th IEEE Working Conference on Software Visualization)

Call for Papers

=======================================

VISSOFT 2022: 2-3 October 2022, Limassol, Cyprus.

https://vissoft.info/2022/

=======================================

Software visualization is a broad research area whose general goal is to enhance and promote the theory, realization, and evaluation of approaches to visually encode and analyze software systems, including software development practices, evolution, structure, and software runtime behavior. Software visualization is inherently interdisciplinary, drawing on theories and techniques from areas such as information visualization, human-computer interaction, computer graphics, and data science, and applying these in the software engineering domain.

The VISSOFT conference is principally a venue for publishing and discussing research related to software visualization. Consequently, VISSOFT brings together a community of researchers from software engineering, information visualization, human-computer interaction, computer graphics, and data science to discuss theoretical foundations, algorithms, techniques, tools, and applications related to software visualization.

VISSOFT, co-located with ICSME, encourages a variety of submissions that address outstanding challenges in software systems using visualization. This includes technical papers, evaluations, and papers that present novel ideas and tools.

Topics of interest

=======================================

  • Innovative visualization and visual analytics techniques for the analysis of software engineering data. This includes source code, dependencies, repositories, developer social networks like StackOverflow and GitHub, mobile app reviews, documentation, runtime logs, and DevOps data
  • Visualization to support software development activities, including design, requirements engineering, software maintenance, program comprehension, software performance, software testing, and debugging
  • Interaction techniques and algorithms for software visualization
  • Visualization-based techniques in software engineering education
  • Integration of software visualization tools with development environments
  • Empirical evaluation of software visualizations, including eye-tracking
  • Industrial experience with using software visualization
  • Applications of new technologies to enhance software visualization, including virtual reality, augmented reality, gamification, and machine learning
  • Analytical approaches to understanding software-related aspects based on data science concepts

We solicit papers that present original, unpublished research results. Papers will be rigorously reviewed by an international program committee. In addition to full technical papers, VISSOFT features a New Ideas and Emerging Results and Tool Demo (NIER/TD) track whose purpose is to present an idea still under development or to demonstrate the functionality of a newly developed tool. All accepted submissions will appear in the conference proceedings and the IEEE Digital Library.

Submission Types

=======================================

==== Technical Track

A technical paper contribution must describe an in-depth and mature research result relevant to software visualization. The content of a technical paper can be a maximum of 10 pages long (including all figures, tables, and appendices). However, the 10-page limit does not include the bibliography, which is limited by two additional pages.

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 a video should add a URL to the video at the end of the abstract (e.g., Video URL: https://youtu.be/XXX).

Authors of technical papers that do not receive an acceptance recommendation from reviewers can, eventually, be invited to adapt the paper and make it acceptable for the NIER/TD track.

Paper Awards: VISSOFT 2022 will award the best technical papers.

Artifact Evaluation: Paper authors are encouraged to submit research artifacts (e.g., tools, data repositories, frameworks, videos) for evaluation. For more details, please refer to the Artifact Track.

== Important Dates (23:59:59 AoE)

Paper Abstract: June 20, 2022

Paper Submission: June 27, 2022

Notification: July 25, 2022

Camera-Ready: August 1, 2022

Submission link: https://easychair.org/conferences/?conf=vissoft2022

==== NIER/TD Track

The NIER/TD Track of VISSOFT accepts two types of submissions: NIER (New Ideas and Emerging Results) and Tool Demonstrations (TD). Both NIER and TD contributions have a page limit of 5 (including bibliography).

NIER contributions describe work-in-progress and preliminary, exciting results. Authors are encouraged to include open questions and even provocative hypotheses to get early feedback on their research ideas. A sound evaluation is not required for NIER contributions. One of the goals of the NIER Track is to foster collaboration among different research groups.

Tool Demonstrations (TD) describe the design or actual utilization of software visualization tools, with a focus on the architecture of the tool or its use to gain new insights. During the conference, we will organize an informal tool demonstration session where authors of TD papers are invited to demonstrate their tools. The submission may also contain a link to a screencast (e.g., YouTube or Vimeo) to show the interaction possibilities offered by the tool.

== Important Dates (23:59:59 AoE)

Paper Abstract: June 20, 2022

Paper Submission: June 27, 2022

Notification: July 25, 2022

Camera-Ready: August 1, 2022

Submission link: https://easychair.org/conferences/?conf=vissoft2022

==== Artifact Evaluation Track

Also this year, ICSME, VISSOFT, and SCAM have joined forces and present a single Artifact Evaluation Track for all three venues. We invite authors of papers of all lengths accepted to VISSOFT 2022 to submit artifacts associated with those papers for evaluation. Papers with artifacts that meet the review criteria will be awarded badges, noting their contributions to open science in SE.

For more information please read the Call for Papers of the Joint Artifact Evaluation Track available at https://cyprusconferences.org/icsme2022/call-for-joint-artifact-evaluation-track-and-rose-festival-track/

==== Journal-first Track

A submission to the VISSOFT 2022 call for journal-first paper presentations must adhere to the following criteria:

  • The paper was accepted to a relevant journal and it is in the scope of the conference
  • The paper was published between July 1, 2019 and July 25, 2022.
  • The paper reports new research results and/or presents novel contributions that significantly extend, and were not previously reported in, prior work
  • The paper has not been presented at and is not under consideration for journal-first programs of other conferences

Authors of a paper that meets these criteria are invited to submit by email to vissoft2022@easychair.org a one-page presentation proposal consisting of the paper’s title, the paper’s authors, a short statement on how the work satisfies the journal first criteria, and a pointer to the original journal paper at the journal’s Website. If the paper is not online yet, then specify so. The original paper (or a preprint) should also be sent during submission.

The journal-first manuscripts are published through the journals and will not be part of the Conference proceedings. The journal-first papers will be listed in the conference program. Journal first presentations will have the same presentation time as technical papers.

== Important Dates (23:59:59 AoE)

Paper Submission: July 25, 2022

Notification: August 1, 2022

Informal Tools Showcase

=======================================

As successfully done in the past, at VISSOFT 2022 authors of all accepted papers will be invited to demonstrate their approaches and tools to the participants in an informal setting. More details will follow a few weeks before the conference.

How to submit

=======================================

Technical papers must not exceed 10 pages (including figures and appendices) plus up to 2 pages that contain ONLY references. NIER/TD papers must not exceed 5 pages including references. Journal-first presentations must submit a one-page proposal. 

Papers must strictly adhere to the two-column IEEE conference proceedings format. Please use the available IEEE Manuscript Templates for Conference Proceedings: https://www.ieee.org/conferences/publishing/templates.html

If a submission is accepted for the journal-first program, at least one author of the associated journal paper must register and present the paper at the conference.

Supplemental material (e.g., video, data, software) that might be helpful for reviewers can be linked in your paper.

Important Dates

Note: VISSOFT uses a single-blind review process (i.e., the names and affiliations of the authors are revealed to reviewers but reviewers’ identities are not revealed to authors).

=======================================

All dates refer to midnight 23:59:59 AoE.

Paper Abstract: June 20, 2022

Paper Submission:

June 27, 2022 (Technical Papers, NIER/TD Track)

July 25, 2022 (Journal First Track)

Notification:

July 25, 2022 (Technical Papers, NIER/TD Track)

August 1, 2022 (Journal First Track)

Camera Ready: August 1, 2022

Conference Date: October 2-3, 2022

Posted in Uncategorized | Leave a comment

VISSOFT 2021 Progam Announced

VISSOFT 2021 —- Sep 27-28, 2021, Virtual, co-located with ICSME 2021 — https://vissoft.info/2021/
Registration link: https://icsme2021.github.io/Registration.html
**** Early registration rate until September 4, 2021 ****

—————————————————————————————————————————————-

VISSOFT 2021 is the 9th IEEE Working Conference on Software Visualization, virtually co-located with ICSME 2021 (https://icsme2021.github.io/index.html)
The VISSOFT conference is principally a venue for publishing and discussing research related to software visualization. VISSOFT brings together a community of researchers from software engineering, information visualization, human-computer interaction, computer graphics, and data science to discuss theoretical foundations, algorithms, techniques, tools, and applications related to software visualization.

On September 27th and 28th we will discuss a range of excellent papers. Accepted were 9 Technical papers, 12 New Ideas and Emerging Results / Tool Demo papers and two Journal-First presentations.
You can find a full list of the accepted papers below!

The keynote will be delivered by Michele Lanza from the Università della Svizzera italiana.
Daniel Weiskopf from the University of Stuttgart will be our capstone speaker.

The program is available at: https://vissoft.info/2021/program.html
Follow us on Twitter to stay up to date: https://twitter.com/IEEEVISSOFT
—————————————————————————————————————————————-

Accepted Papers:

—- Technical Papers —-

1 A Scalable Log Differencing Visualisation Applied to COBOL Refactoring
Céline Deknop, Kim Mens, Alexandre Bergel, Johan Fabry and Vadim Zaytsev

2 CodeCity: On-Screen or in Virtual Reality?
David Moreno-Lumbreras, Roberto Minelli, Andrea Villaverde, Michele Lanza and Jesus M. Gonzalez-Barahona

3 CodingTM: Development Task Visualization for SW Code Comprehension
Taeyoung Kim, Suntae Kim and Duksan Ryu

4 Continuous Rationale Visualization
Anja Kleebaum, Barbara Paech, Jan Ole Johanssen and Bernd Bruegge

5 Global Overviews of Granular Test Coverage with Matrix Visualizations
Kaj Dreef, Vijay Krishna Palepu and James Jones

6 Trace Visualization within the Software City Metaphor: A Controlled Experiment on Program Comprehension
Veronika Dashuber and Michael Philippsen

7 TransVis: Using Visualizations and Chatbots for Supporting Transient Behavior in Microservice Systems
Samuel Beck, Sebastian Frank, Mir Alireza Hakamian, Leonel Merino and André van Hoorn

8 Visualization of Object-Oriented Variability Implementations as Cities
Johann Mortara, Philippe Collet and Anne-Marie Déry

9 Visualizing Metric Trends for Software Portfolio Quality Management
Patric Genfer, Johann Grabner, Christina Zoffi, Mario Bernhart and Thomas Grechenig

—- NIER/TD Papers —-

1 Analyzing and Visualizing Projects and their Relations in Software Ecosystems
Van Tuan Tran, Cheng Cheng, Fabio Petrillo and Yann-Gaël Guéhéneuc

2 Augmenting Code Review Experience Through Visualization
Faruk Balcı, Dilruba Sultan Haliloğlu, Onur Şahin, Cankat Tilki, Mehmet Ata Yurtsever and Eray Tüzün

3 CHANGEVIZ: Enhancing the GitHub Interface with Method Calls Information
Lorenzo Gasparini, Enrico Fregnan, Larissa Braz, Tobias Baum and Alberto Bacchelli

4 Codoc: Code-driven Architectural View Specification Framework for Python
Casper Weiss Bang and Mircea Lungu

5 Live Visualization of Dynamic Software Cities with Heat Map Overlays
Alexander Krause, Malte Hansen and Wilhelm Hasselbring

6 React-bratus: Visualising React.js Component Hierarchies
Mircea Lungu and Stephan Boersma

7 Towards a JSON-based Algorithm Animation Language
Artturi Tilanterä, Giacomo Mariani, Ari Korhonen and Otto Seppälä

8 Visualizing Data in Software Cities
Susanna Ardigò, Csaba Nagy, Roberto Minelli and Michele Lanza

9 Visualizing Discord Servers
Marco Raglianti, Roberto Minelli, Csaba Nagy and Michele Lanza

10 Visualizing GitHub Issues
Aron Fiechter, Roberto Minelli, Csaba Nagy and Michele Lanza

11 Visually Analyzing the Code Quality of Component-based Web Applications
Hagen Tarner, Daniel van den Bongard and Fabian Beck

12 Voronoi Evolving Treemaps
Davide Paolo Tua, Roberto Minelli and Michele Lanza

—- Journal First Papers —-

1 Visual Augmentation of Source Code Editors: A Systematic Mapping Study
Matúš Sulír, Michaela Bačíková, Sergej Chodarev and Jaroslav Porubän

2 An Architecture-Tracking Approach to Evaluate a Modular and Extensible Flight Software for CubeSat Nanosatellites
Carlos Gonzalez, Camilo Rojas, Alexandre Bergel and Marcos Diaz

Posted in Uncategorized | Leave a comment

VISSOFT 2nd Call for Papers – Deadline 11 June

====================================VISSOFT 2021: 9th IEEE Working Conference on Software Visualization
Call for Tool Demos ++++ Second Call for Papers (Abstract Deadline June 11th)====================================
Call for Tool Demos============https://vissoft.info/2021/submission.html#demo
=== Goal and Scope:The tool demo session is an opportunity for researchers and practitioners to present and discuss visualization-related tools in an informal setting.
It is open to authors of VISSOFT papers as well as to authors of visualization-related tools published at ICSME and SCAM from both the current year and the previous year.
=== How to submit:
Please submit your tool demo proposal to https://easychair.org/conferences/?conf=vissoft2021 including
–   a title,
–   a short description (max. 500 words), and
–   a teaser video (max. 1 min).

In addition to presenting your tool demo at VISSOFT, you have the option to present it at ICSME. If you want to use this option please send a mail with the above-mentioned information to Eleni Constantinou (e.constantinou@tue.nl) and Xavier Devroey (x.d.m.devroey@tudelft.nl).
=== Important Dates:
Tool demo submission: September 1, 2021
Notification: September 12, 2021
Presentation (VISSOFT): September 27, 2021
Presentation (ICSME): see https://icsme2021.github.io/
=== Track Chair:
Richard Müller (rmueller@wifa.uni-leipzig.de), Leipzig University, Germany

Call for Papers============Conference website: https://vissoft.info/2021/
Software visualization is a broad research area whose general goal is to enhance and promote the theory, realization, and evaluation of approaches to visually encode and analyze software systems, including software development practices, evolution, structure, and software runtime behavior. Software visualization is inherently interdisciplinary, drawing on theories and techniques from areas such as information visualization, human-computer interaction, computer graphics, and data science, and applying these in the software engineering domain.
The VISSOFT conference is principally a venue for publishing and discussing research related to software visualization. Consequently, VISSOFT brings together a community of researchers from software engineering, information visualization, human-computer interaction, computer graphics, and data science to discuss theoretical foundations, algorithms, techniques, tools, and applications related to software visualization.
This year’s VISSOFT, co-held with ICSME, encourages a variety of submissions that address outstanding challenges in software systems using visualization. This includes technical papers, evaluations, applications/design studies, systems and formalisms, and papers that present novel ideas and tools.
=== Topics of interest include:
–   Innovative visualization and visual analytics techniques for analysis of software engineering data. This includes source code, dependencies, repositories, developer social networks like StackOverflow and GitHub, mobile app reviews, documentation, runtime logs, and DevOps data    –   Visualization to support software development activities, including design, requirements engineering, software maintenance, program comprehension, software performance, software testing, and debugging    –   Interaction techniques and algorithms for software visualization    –   Visualization-based techniques in software engineering education    –   Integration of software visualization tools with development environments    –   Empirical evaluation of software visualizations, including eye-tracking    –   Industrial experience with using software visualization    –   Applications of new technologies to enhance software visualization, including virtual reality, augmented reality, gamification, and machine learning    –   Analytical approaches to understand software-related aspects based on data science concepts    
We solicit papers that present original, unpublished research results. Papers will be rigorously reviewed by an international program committee. In addition to technical papers, VISSOFT features a New Ideas and Emerging Results and Tool Demo (NIER/TD) track. All accepted submissions will appear in the conference proceedings and the IEEE Digital Library.
Submission Types===============
==== Technical papers:
A technical paper contribution must describe an in-depth and mature research result relevant to software visualization. The content of a technical paper can be at a maximum 10 pages long (including all figures, tables, and appendices). However, the 10 page limit does not include the bibliography, which is limited by two additional pages.
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 a video can submit the video together with their paper if the size of the video is smaller than 50 MB, alternatively a URL to the video could be provided.
Authors of technical papers that do not receive an acceptance recommendation from reviewers can, eventually, be invited to adapt the paper and make it acceptable for the NIER/TD track.
Awards: VISSOFT 2021 will award best technical papers.
Special issue: A   selection   of   best   papers   will   be   invited   to   submit   extended   versions   for   tentative   publication  in   a   Special   Section   of   the   journal   of   Information   and   Software   Technology   published   by  Elsevier http://www.elsevier.com/locate/infsof
Artifact evaluation: Paper authors are encouraged to submit research artifacts (e.g., tools, data repositories, frameworks, videos) to the artifact evaluation track of ICSME. Please find further details in https://icsme2021.github.io/
== Important Dates:
Paper Abstract: June 11, 2021Paper Submission: June 18, 2021Notification: July 23, 2021Camera-Ready: August 6, 2021Conference: September 27-28, 2021 (to be confirmed)
Submission link: https://easychair.org/conferences/?conf=vissoft2021
==== NIER/TD Track:
The NIER/TD Track of VISSOFT accepts two types of contributions: NIER (New Ideas and Emerging Results) and Tool Demonstrations (TD). Both NIER and TD contributions have a page limit of 5 (including bibliography).
NIER contributions describe work-in-progress and preliminary exciting results. Authors are encouraged to include open questions and even provocative hypotheses to get early feedback on their research ideas. A sound evaluation is not required for NIER contributions. One of the goals of the NIER Track is to foster collaboration among different research groups.
Tool Demonstrations (TD) describe the design or actual utilization of software visualization tools, with a focus on the architecture of the tool or its use to gain new insights. During the conference, we will organize an informal tool demonstration session where authors of TD papers are invited to demonstrate their tools. The submission may also contain a link to a screencast (e.g., YouTube or Vimeo) to show the interaction possibilities offered by the tool.
== Important Dates:
Paper Abstract: June 11, 2021Paper Submission: June 18, 2021Notification: July 23, 2021Camera-Ready: August 6, 2021Conference: September 27-28, 2021 (to be confirmed)
Submission link: https://easychair.org/conferences/?conf=vissoft2021
==== Journal First Track
A submission to the VISSOFT 2021 call for journal-first paper presentations must adhere to the following criteria:
–   The paper was accepted to a relevant journal and it is in the scope of the conference    –   The paper was published between June 1, 2018 and June 10, 2021:    –   The paper reports new research results and/or presents novel contributions that significantly extend, and were not previously reported in, prior work    –   The paper has not been presented at, and is not under consideration for, journal-first programs of other conferences    
Authors of a paper that meets these criteria are invited to submit a one-page presentation proposal consisting of the paper’s title, the paper’s authors, a short statement on how the work satisfies the journal first criteria, and a pointer to the original journal paper at the journal’s Web site. If the paper is not online yet, then specify so. The original paper should also be uploaded during submission.
If a submission is accepted for the journal-first program, at least one author of the associated journal paper must register and present the paper at the conference. The journal-first manuscripts are published through the journals and will not be part of the Conference proceedings. The journal-first papers will be listed in the conference program. Journal first presentations will have the same presentation time than technical papers.
== Important Dates:
Paper Submission: July 2, 2021Notification: July 23, 2021Camera-Ready: August 6, 2021Conference: September 27-28, 2021 (to be confirmed)
Submission link: https://easychair.org/conferences/?conf=vissoft2021
How to submit============
Technical papers must not exceed 10 pages (including figures and appendices) plus up to 2 pages that contain ONLY references. NIER/TD papers must not exceed 5 pages including references. Journal-first presentations must submit a one-page proposal. 
Papers must strictly adhere to the two-column IEEE conference proceedings format. Please use the available IEEE Manuscript Templates for Conference Proceedings: https://www.ieee.org/conferences/publishing/templates.html
Supplemental material (e.g., video, data, software) that might be helpful for the reviewers can be submitted together with your paper. All material must be included in a single ZIP file. 
Note that VISSOFT uses a single-blind review process (i.e., the authors’ names and affiliations are revealed to reviewers but reviewers’ identities are not revealed to authors). The authors do not need to anonymize their papers.
Important Dates=============
All dates refer to midnight 23:59:59 AoE (http://www.timeanddate.com/time/zones/aoe).
Paper Abstract: June 11, 2021
Paper Submission:June 18, 2021 (Technical Papers, NIER/TD Track)July 2, 2021 (Journal First Track)
Notification: July 23, 2021
Camera-Ready: August 6, 2021
Conference Date: September 27-28, 2021 (to be confirmed)

Posted in Uncategorized | Leave a comment