Publications

2022

Thumbnail of Efficient GitHub Crawling using the GraphQL API

Efficient GitHub Crawling using the GraphQL API

Adrian Jobst, Daniel Atzberger, Tim Cech, Willy Scheibel, Matthias Trapp, and Jürgen Döllner
22th International Conference on Computational Science and Its Applications (ICCSA) 2022, BibTeX, Abstract

The number of publicly accessible software repositories on online platforms is growing rapidly. With more than 128 million public repositories (as of March 2020), GitHub is the world’s largest platform for hosting and managing software projects. Where it used to be necessary to merge various data sources, it is now possible to access a wealth of data using the GitHub API alone. However, collecting and analyzing this data is not an easy endeavor. In this paper, we present Prometheus, a system for crawling and storing software repositories from GitHub. Compared to existing frameworks, Prometheus follows an event-driven microservice architecture. By separating functionality on the service level, there is no need to understand implementation details or use existing frameworks to extend or customize the system, only data. Prometheus consists of two components, one for fetching GitHub data and one for data storage which serves as a basis for future functionality. Unlike most existing crawling approaches, the Prometheus fetching service uses the GitHub GraphQL API. As a result, Prometheus can significantly outperform alternatives in terms of throughput in some scenarios.

Thumbnail of Tooling for Time- and Space-efficient git Repository Mining

Tooling for Time- and Space-efficient git Repository Mining

Fabian Heseding, Willy Scheibel, and Jürgen Döllner
19th International Conference on Mining Software Repositories – Data and Tool Showcase Track (MSR) 2022, BibTeX, Abstract, DOI:10.1145/3524842.3528503

Software projects under version control grow with each commit, accumulating up to hundreds of thousands of commits per repository. Especially for such large projects, the traversal of a repository and data extraction for static source code analysis poses a trade-off between granularity and speed. We showcase the command-line tool pyrepositoryminer that combines a set of optimization approaches for efficient traversal and data extraction from git repositories while being adaptable to third-party and custom software metrics and data extractions. The tool is written in Python and combines bare repository access, in-memory storage, parallelization, caching, change-based analysis, and optimized communication between the traversal and custom data extraction components. The tool allows for both metrics written in Python and external programs for data extraction. A single-thread performance evaluation based on a basic mining use case shows a mean speedup of 15.6×to other freely available tools across four mid-sized open source projects. A multi-threaded execution allows for load distribution among cores and, thus, a mean speedup up to 86.9×using 12 threads.

Github Project, Source Code Archive

Thumbnail of Augmenting Library Development by Mining Usage Data from Downstream Dependencies

Augmenting Library Development by Mining Usage Data from Downstream Dependencies

Christoph Thiede, Willy Scheibel, Daniel Limberger, and Jürgen Döllner
Candidate for Best Student Paper
17th International Conference on Evaluation of Novel Approaches to Software Engineering (ENASE) 2022, BibTeX, Abstract, DOI:10.5220/0011093700003176

In the dependency graph of a software ecosystem, downstream dependencies are the nodes that depend on a package. Apart from end-user APIs, these dependencies make up the bulk of a library’s usage for most packages. Other than for upstream dependencies, tools that provide individual package developers with this kind of information rarely exist to date. This paper makes two contributions: (i) We propose an approach for gathering downstream dependencies of a single package efficiently and extracting usage samples from them using a static type analyzer. (ii) We present a tool that allows npm package developers to survey the aggregated usage data directly in their IDE in an interactive and context-sensitive way and that further supports them in understanding which packages use specific package members and why and how they use these members. This can help prioritize and steer development and uncover unexpected usage patterns, inappropriate member signatures, or misleading interface design. Our methods return over 8 000 dependencies for popular packages and process about 12 dependencies per minute while requiring about 500 MB memory in total and less than 30 MB storage per package, but tend to exclude unpopular dependencies. Usage sample extraction is very precise but not easily available for repositories with complex build configurations or metaprogramming patterns. We show that usage data from downstream dependency repositories is a promising and diverse source of information for mining software repositories and that our approach supports package developers in maintaining their APIs.

Github Project, Source Code Archive

Thumbnail of Mining Developer Expertise from Bug Tracking Systems using the Author-Topic Model

Mining Developer Expertise from Bug Tracking Systems using the Author-Topic Model

Daniel Atzberger, Jonathan Schneider, Willy Scheibel, Daniel Limberger, Matthias Trapp, and Jürgen Döllner
Best Student Paper Award
17th International Conference on Evaluation of Novel Approaches to Software Engineering (ENASE) 2022, BibTeX, Abstract, DOI:10.5220/0011045100003176

During software development processes, software defects, so-called bugs, are captured in a semi-structured manner in bug tracking systems using textual components and categorical features. It is the task of the triage owner to assign open bugs to developers with the required skills and expertise. This task, known as bug triaging, requires an in-depth knowledge about a developer’s skills. Various machine learning techniques have been proposed to automate this task, most of these approaches apply topic models, especially Latent Dirichlet Allocation (LDA), for mining the textual components of bug reports. However none of the proposed approaches explicitly models a developers expertise. In most cases these algorithms are treated as black box, as they allow no explanation about their recommendation. In this work, we show how the Author-Topic Model (ATM), a variant of LDA, can be used to capture a developer’s expertise in the latent topics of a corpus of bug reports from the model itself. Furthermore, we present three novel bug triaging techniques based on the ATM. We compare our approach against a baesline model, that is based on LDA, on a dataset of 18269 bug reports from the Mozilla Firefox project collected between July 1999 to June 2016. The results show that the ATM can outperform the LDA-based approach in terms of the Mean Reciprocal Rank (MRR).

Thumbnail of Visualization of Knowledge Distribution across Development Teams using 2.5D Semantic Software Maps

Visualization of Knowledge Distribution across Development Teams using 2.5D Semantic Software Maps

Daniel Atzberger, Tim Cech, Adrian Jobst, Willy Scheibel, Daniel Limberger, Matthias Trapp, and Jürgen Döllner
13th International Conference on Information Visualization Theory and Applications (IVAPP) 2022, BibTeX, Abstract, DOI:10.5220/0010991100003124

In order to detect software risks at an early stage, various software visualization techniques have been developed for monitoring the structure, behaviour, or the underlying development process of software. One of greatest risks for any IT organization consists in an inappropriate distribution of knowledge among its developers, as a projects’ success mainly depends on assigning tasks to developers with the required skills and expertise. In this work, we address this problem by proposing a novel Visual Analytics framework for mining and visualizing the expertise of developers based on their source code activities. Under the assumption that a developer’s knowledge about code is represented directly through comments and the choice of identifier names, we generate a 2D layout using Latent Dirichlet Allocation together with Multidimensional Scaling on the commit history, thus displaying the semantic relatedness between developers. In order to capture a developer’s expertise in a concept, we utilize Labeled LDA trained on a corpus of Open Source projects. By mapping aspects related to skills onto the visual variables of 3D glyphs, we generate a 2.5D Visualization, we call KnowhowMap. We exemplify this approach with an interactive prototype that enables users to analyze the distribution of skills and expertise in an explorative way.

2021

Thumbnail of Software Galaxies: Displaying Coding Activities using a Galaxy Metaphor

Software Galaxies: Displaying Coding Activities using a Galaxy Metaphor

Daniel Atzberger, Willy Scheibel, Daniel Limberger, and Jürgen Döllner
14th International Symposium on Visual Information Communication and Interaction (VINCI) 2021, BibTeX, Abstract, DOI:10.1145/3481549.3481573

Software visualization uses metaphors to depict software and software development data that usually has no gestalt. The choice of a metaphor and visual depiction is researched broadly, but deriving a layout based on similarity is still challenging. We present a novel approach to 3D software visualization called Software Galaxy. Our layout is based on applying Latent Dirichlet Allocation on source code. We utilize a metaphor inspired from astronomy for depicting software metrics for single files and clusters. Our first experiments indicate that a 3D visualization capturing semantic relatedness can be beneficial for standard program comprehension tasks.

Thumbnail of Interactive Simulation and Visualization of Long-Term, ETF-based Investment Strategies

Interactive Simulation and Visualization of Long-Term, ETF-based Investment Strategies

Martin Büßemeyer, Daniel Limberger, Willy Scheibel, and Jürgen Döllner
14th International Symposium on Visual Information Communication and Interaction (VINCI) 2021, BibTeX, Abstract, DOI:10.1145/3481549.3481568

Personal, long-term investment products, especially ones for retirement savings, require thorough understanding to use them profitably. Even simple savings plans based on exchange-traded funds(ETFs) are subject to many variables and uncertainties to be considered for expected and planned-upon returns. We present aninteractive simulation of an ETF-based savings plan that combinesforecasts, risk awareness, taxes and costs, inflation, and dynamicinflows and outflows into a single visualization. The visualizationconsists of four parts: a form-fill interface for configuration, a savings and payout simulation, a cash flow chart, and a savings chart. Based on a specific use case, we discuss how private investors canbenefit from using our visualization after a short training period.

Demo

Thumbnail of Visualization of Data Changes in 2.5D Treemaps using Procedural Textures and Animated Transitions

Visualization of Data Changes in 2.5D Treemaps using Procedural Textures and Animated Transitions

Daniel Limberger, Willy Scheibel, Jan van Dieken, and Jürgen Döllner
14th International Symposium on Visual Information Communication and Interaction (VINCI) 2021, BibTeX, Abstract, DOI:10.1145/3481549.3481570

This work investigates the extent to which animated procedural texture patterns can be used to support the representation of changes in 2.5D treemaps. Changes in height, color, and area of individual nodes can easily be visualized using animated transitions. Especially for changes in the color attribute, plain animated transitions are not able to directly communicate the direction of change itself. We show how procedural texture patterns can be superimposed to the color mapping and support transitions. To this end, we discuss qualitative properties of each pattern, demonstrate their ability to communicate change direction both with and without animation, and conclude which of the patterns are more likely to increase effectiveness and correctness of the change mapping in 2.5D treemaps.

Thumbnail of Algorithmic Improvements on Hilbert and Moore Treemaps for Visualization of Large Tree-structured Datasets

Algorithmic Improvements on Hilbert and Moore Treemaps for Visualization of Large Tree-structured Datasets

Willy Scheibel, Christopher Weyand, Joseph Bethge, and Jürgen Döllner
23rd EG Conference on Visualization (EuroVis) 2021, BibTeX, Abstract, DOI:10.2312/evs.20211065

Hilbert and Moore treemaps are based on the same named space-filling curves to lay out tree-structured data for visualization. One main component of them is a partitioning subroutine, whose algorithmic complexity poses problems when scaling to industry-sized datasets. Further, the subroutine allows for different optimization criteria that result in different layout decisions. This paper proposes conceptual and algorithmic improvements to this partitioning subroutine. Two measures for the quality of partitioning are proposed, resulting in the min-max and min-variance optimization tasks. For both tasks, linear-time algorithms are presented that find an optimal solution. The implementation variants are evaluated with respect to layout metrics and run-time performance against a previously available greedy approach. The results show significantly improved run time and no deterioration in layout metrics, suggesting effective use of Hilbert and Moore treemaps for datasets with millions of nodes.

Author Version, Slides, Github Project

Thumbnail of Software Forest: A Visualization of Semantic Similarities in Source Code using a Tree Metaphor

Software Forest: A Visualization of Semantic Similarities in Source Code using a Tree Metaphor

Daniel Atzberger, Tim Cech, Merlin de la Haye, Maximilian Söchting, Willy Scheibel, Daniel Limberger, and Jürgen Döllner
Candidate for Best Student Paper
12th International Conference on Information Visualization Theory and Applications (IVAPP) 2021, BibTeX, Abstract, DOI:10.5220/0010267601120122

Software visualization techniques provide effective means for program comprehension tasks as they allow developers to interactively explore large code bases. A frequently encountered task during software development is the detection of source code files of similar semantic. To assist this task we present Software Forest, a novel 2.5D software visualization that enables interactive exploration of semantic similarities within a software system, illustrated as a forest. The underlying layout results from the analysis of the vocabulary of the software documents using Latent Dirichlet Allocation and Multidimensional Scaling and therefore reflects the semantic similarity between source code files. By mapping properties of a software entity, e.g., size metrics or trend data, to visual variables encoded by various, figurative tree meshes, aspects of a software system can be displayed. This concept is complemented with implementation details as well as a discussion on applications.

Author Version, Demo

2020

Thumbnail of Survey of Treemap Layout Algorithms

Survey of Treemap Layout Algorithms

Willy Scheibel, Daniel Limberger, and Jürgen Döllner
13th International Symposium on Visual Information Communication and Interaction (VINCI) 2020, BibTeX, Abstract, DOI:10.1145/3430036.3430041

This paper provides an overview of published treemap layout algorithms from 1991 to 2019 that were used for information visualization and computational geometry. First, a terminology is outlined for the precise communication of tree-structured data and layouting processes. Second, an overview and classification of layout algorithms is presented and application areas are discussed. Third, the use-case-specific adaption process is outlined and discussed. This overview targets practitioners and researchers by providing a starting point for own research, visualization design, and applications.

Author Version, Slides

Thumbnail of Survey on User Studies on the Effectiveness of Treemaps

Survey on User Studies on the Effectiveness of Treemaps

Carolin Fiedler, Willy Scheibel, Daniel Limberger, Matthias Trapp, and Jürgen Döllner
13th International Symposium on Visual Information Communication and Interaction (VINCI) 2020, BibTeX, Abstract, DOI:10.1145/3430036.3430054

Treemaps are a commonly used tool for the visual display and communication of tree-structured, multi-variate data. In order to confidently know when and how treemaps can best be applied, the research community uses usability studies and controlled experiments to "understand the potential and limitations of our tools" (Plaisant, 2004). To support the communities' understanding and usage of treemaps, this survey provides a comprehensive review and detailed overview of 69 user studies related to treemaps. However, due to pitfalls and shortcomings in design, conduct, and reporting of the user studies, there is little that can be reliably derived or accepted as a generalized statement. Fundamental open questions include configuration, compatible tasks, use cases, and perceptional characteristics of treemaps. The reliability of findings and statements is discussed and common pitfalls of treemap user studies are identified.

Author Version, Companion Website

Thumbnail of A Framework for Interactive Exploration of Clusters in Massive Data using 3D Scatter Plots and WebGL

A Framework for Interactive Exploration of Clusters in Massive Data using 3D Scatter Plots and WebGL

Lukas Wagner, Willy Scheibel, Daniel Limberger, Matthias Trapp, and Jürgen Döllner
25th International Conference on 3D Web Technology (Web3D) 2020, BibTeX, Abstract, DOI:10.1145/3424616.3424730

This paper presents a rendering framework for the visualization of massive point datasets in the web. It includes highly interactive point rendering, cluster visualization, basic interaction methods, and importance-based labeling, while being available for both mobile and desktop browsers. The rendering style is customizable, as shown in figure 1. Our evaluation indicates that the framework facilitates interactive visualization of tens of millions of raw data points even without dynamic filtering or aggregation.

Author Version, Slides, Demo

Thumbnail of A Taxonomy of Treemap Visualization Techniques

A Taxonomy of Treemap Visualization Techniques

Willy Scheibel, Matthias Trapp, Daniel Limberger, and Jürgen Döllner
11th International Conference on Information Visualization Theory and Applications (IVAPP) 2020, BibTeX, Abstract, DOI:10.5220/0009153902730280

A treemap is a visualization that has been specifically designed to facilitate the exploration of tree-structured data and, more general, hierarchically structured data. The family of visualization techniques that use a visual metaphor for parent-child relationships based “on the property of containment” (Johnson, 1993) is commonly referred to as treemaps. However, as the number of variations of treemaps grows, it becomes increasingly important to distinguish clearly between techniques and their specific characteristics. This paper proposes to discern between Space-filling Treemap, Containment Treemap, Implicit Edge Representation Tree, and Mapped Tree for classification of hierarchy visualization techniques and highlights their respective properties. This taxonomy is created as a hyponymy, i.e., its classes have an is-a relationship to one another. With this proposal, we intend to stimulate a discussion on a more unambiguous classification of treemaps and, furthermore, broaden what is understood by the concept of treemap itself.

Author Version, Slides

Thumbnail of Visualization of Tree-structured Data using Web Service Composition

Visualization of Tree-structured Data using Web Service Composition

Willy Scheibel, Judith Hartmann, Daniel Limberger, and Jürgen Döllner
VISIGRAPP 2019: Computer Vision, Imaging and Computer Graphics Theory and Applications 2020, BibTeX, Abstract, DOI:10.1007/978-3-030-41590-7_10

This article reiterates on the recently presented hierarchy visualization service HiViSer and its API. It illustrates its decomposition into modular services for data processing and visualization of tree-structured data. The decomposition is aligned to the common structure of visualization pipelines and, in this way, facilitates attribution of the services' capabilities. Suitable base resource types are proposed and their structure and relations as well as a subtyping concept for specifics in hierarchy visualization implementations are detailed. Moreover, state-of-the-art quality standards and techniques for self-documentation and discovery of components are incorporated. As a result, a blueprint for Web service design, architecture, modularization, and composition is presented, targeting fundamental visualization tasks of tree-structured data, i.e., gathering, processing, rendering, and provisioning. Finally, the applicability of the service components and the API is evaluated in the context of exemplary applications.

Author Version

2019

Thumbnail of Advanced Visual Metaphors and Techniques for Software Maps

Advanced Visual Metaphors and Techniques for Software Maps

Daniel Limberger, Willy Scheibel, Matthias Trapp, and Jürgen Döllner
12th International Symposium on Visual Information Communication and Interaction (VINCI) 2019, BibTeX, Abstract, DOI:10.1145/3356422.3356444

Software maps provide a general-purpose interactive user interface and information display for software analytics tools. This paper systematically introduces and classifies software maps as a treemap-based technique for software cartography. It provides an overview of advanced visual metaphors and techniques, each suitable for interactive visual analytics tasks, that can be used to enhance the expressiveness of software maps. Thereto, the metaphors and techniques are briefly described, located within a visualization pipeline model, and considered within the software map design space. Consequent applications and use cases w.r.t. different types of software system data and software engineering data are discussed, arguing for a versatile use of software maps in visual software analytics.

Author Version

Thumbnail of Design and Implementation of Web-Based Hierarchy Visualization Services

Design and Implementation of Web-Based Hierarchy Visualization Services

Willy Scheibel, Judith Hartmann, and Jürgen Döllner
Candidate for Best Paper
10th International Conference on Information Visualization Theory and Applications (IVAPP) 2019, BibTeX, Abstract, DOI:10.5220/0007693201410152

There is a rapidly growing, cross-domain demand for interactive, high-quality visualization techniques as components of web-based applications and systems. In this context, a key question is how visualization services can be designed, implemented, and operated based on Software-as-a-Service as software delivery model. In this paper, we present concepts and design of a SaaS framework and API of visualization techniques for tree-structured data, called HiViSer. Using representational state transfer (REST), the API supports different data formats, data manipulations, visualization techniques, and output formats. In particular, the API defines base resource types for all components required to create an image or a virtual scene of a hierarchy visualization. We provide a treemap visualization service as prototypical implementation for which subtypes of the proposed API resources have been created. The approach generally serves as a blue-print for fully web-based, high-end visualization services running on thin clients in a standard browser environment.

Author Version, Slides, Homepage

2018

Thumbnail of EvoCells – A Treemap Layout Algorithm for Evolving Tree Data

EvoCells – A Treemap Layout Algorithm for Evolving Tree Data

Willy Scheibel, Christopher Weyand, and Jürgen Döllner
9th International Conference on Information Visualization Theory and Applications (IVAPP) 2018, BibTeX, Abstract, DOI:10.5220/0006617102730280

We propose the rectangular treemap layout algorithm EvoCells that maps changes in tree-structured data onto an initial treemap layout. Changes in topology and node weights are mapped to insertion, removal, growth, and shrinkage of the layout rectangles. Thereby, rectangles displace their neighbors and stretche their enclosing rectangles with a run-time complexity of O(n log n). An evaluation using layout stability metrics on the open source ElasticSearch software system suggests EvoCells as a valid alternative for stable treemap layouting.

Author Version, Slides

2017

Thumbnail of Mixed-Projection Treemaps: A Novel Approach Mixing 2D and 2.5D Treemaps

Mixed-Projection Treemaps: A Novel Approach Mixing 2D and 2.5D Treemaps

Daniel Limberger, Willy Scheibel, Matthias Trapp, and Jürgen Döllner
21st International Conference on Information Visualisation (iV) 2017, BibTeX, Abstract, DOI:10.1109/iV.2017.67

2D treemaps are a space-filling visualization technique that facilitate exploration of non-spatial, attributed, tree-structured data using the visual variables size and color. In extension thereto, 2.5D treemaps introduce height for additional information display. This extension entails challenges such as increased rendering effort, occlusion, or the need for navigation techniques that counterbalance the advantages of 2D treemaps to a certain degree. This paper presents a novel technique for combining 2D and 2.5D treemaps using multi-perspective views to leverage the advantages of both treemap types. It enables a new form of overview+detail visualization for complex treemaps and contributes new concepts for real-time rendering of and interaction with mixed-projection treemaps. The technique operates by tilting up inner nodes using affine transformations and animated state transitions. The mixed use of orthogonal and perspective projections is discussed and application examples that facilitate exploration of multi-variate data and benefit from the reduced interaction overhead are demonstrated.

Author Version, Slides

Thumbnail of Attributed Vertex Clouds

Attributed Vertex Clouds

Willy Scheibel, Stefan Buschmann, Matthias Trapp, and Jürgen Döllner
GPU Zen 2017, BibTeX, Abstract

In todays computer graphics applications, large 3D scenes are rendered which consist of polygonal geometries such as triangle meshes. Using state- of-the-art techniques, this geometry is often represented on the GPU using vertex and index buffers, as well as additional auxiliary data such as tex- tures or uniform buffers. For polygonal meshes of arbitrary complexity, the described approach is indispensable. However, there are several types of simpler geometries (e.g., cuboids, spheres, tubes, or splats) that can be generated procedurally. We present an efficient data representation and render- ing concept for such geometries, denoted as attributed vertex clouds (AVCs). Using this approach, geometry is generated on the GPU during execution of the programmable rendering pipeline. Each vertex is used as the argument for a function that procedurally generates the target geometry. This function is called a transfer function, and it is implemented using shader programs and therefore executed as part of the rendering process. This approach allows for compact geometry representation and results in reduced memory footprints in comparison to traditional representations. By shifting geometry generation to the GPU, the resulting volatile geometry can be controlled flexibly, i.e., its position, parameteri- zation, and even the type of geometry can be modified without requiring state changes or uploading new data to the GPU. Performance measurements suggests improved rendering times and reduced memory transmission through the rendering pipeline.

Author Version, Source Code

Thumbnail of Reducing Visual Complexity in Software Maps using Importance-based Aggregation of Nodes

Reducing Visual Complexity in Software Maps using Importance-based Aggregation of Nodes

Daniel Limberger, Willy Scheibel, Sebastian Hahn, and Jürgen Döllner
8th International Conference on Information Visualization Theory and Applications (IVAPP) 2017, BibTeX, Abstract, DOI:10.5220/0006267501760185

Depicting massive software system data using software maps can result in visual clutter and increased cognitive load. This paper introduces an adaptive level-of-detail (LoD) technique that uses scoring for interactive aggregation on a per-node basis. The scoring approximates importance by degree-of-interest measures as well as screen and user-interaction scores. The technique adheres to established aggregation guidelines and was evaluated by means of two user studies. The first user study investigates task completion time in visual search. The second evaluates the readability of the presented nesting level contouring for aggregates. With the adap- tive LoD technique software maps allow for multi-resolution depictions of software system information. It facilitates efficient identification of important nodes and allows for additional annotation.

Author Version, Slides

2016

Thumbnail of Dynamic 2.5D Treemaps using Declarative 3D on the Web

Dynamic 2.5D Treemaps using Declarative 3D on the Web

Daniel Limberger, Willy Scheibel, Stefan Lemme, and Jürgen Döllner
21st International Conference on Web3D Technology (Web3D) 2016, BibTeX, Abstract, DOI:10.1145/2945292.2945313

The 2.5D treemap represents a general purpose visualization technique to map multi-variate hierarchical data in a scalable, interactive, and consistent way used in a number of application fields. In this paper, we explore the capabilities of Declarative 3D for the web-based implementation of 2.5D treemap clients. Particularly, we investigate how X3DOM and XML3D can be used to implement clients with equivalent features that interactively display 2.5D treemaps with dynamic mapping of attributes. We also show a first step towards a glTF-based implementation. These approaches are benchmarked focusing on their interaction capabilities with respect to rendering and speed of dynamic data mapping. We discuss the results for our representative example of a complex 3D interactive visualization technique and summerize recommendations for improvements towards operational web clients.

Author Version, Slides, Source Code, Demo

Thumbnail of Interactive Revision Exploration using Small Multiples of Software Maps

Interactive Revision Exploration using Small Multiples of Software Maps

Willy Scheibel, Matthias Trapp, and Jürgen Döllner
7th International Conference on Information Visualization Theory and Applications (IVAPP) 2016, BibTeX, Abstract, DOI:10.5220/0005694401310138

To explore and to compare different revisions of complex software systems is a challenging task as it requires to constantly switch between different revisions and the corresponding information visualization. This paper proposes to combine the concept of small multiples and focus+context techniques for software maps to facilitate the comparison of multiple software map themes and revisions simultaneously on a single screen. This approach reduces the amount of switches and helps to preserve the mental map of the user. Given a software project the small multiples are based on a common dataset but are specialized by specific revisions and themes. The small multiples are arranged in a matrix where rows and columns represents different themes and revisions, respectively. To ensure scalability of the visualization technique we also discuss two rendering pipelines to ensure interactive frame-rates. The capabilities of the proposed visualization technique are demonstrated in a collaborative exploration setting using a high-resolution, multi-touch display.

Author Version, Poster (Portrait), Poster (Landscape)

2014

Thumbnail of Interaktive Visualisierung von hierarchischen, multivariaten und zeitlich variierenden Daten

Interaktive Visualisierung von hierarchischen, multivariaten und zeitlich variierenden Daten

Willy Scheibel
Master's Thesis at the Hasso Plattner Institute, University of Potsdam 2014, Abstract, DOI:10.13140/RG.2.2.33837.33763

A treemap recursively subdivides a two-dimensional area in order to encode a hierarchy and enables the visualization of multiple attributes e.g. with the size, the extruded height or the color of a node. Traditional treemap layout algorithms and rendering techniques can only be used for the comparison of two data sets at different points in time to some extent, as (1) no comparison between nodes in a treemap and between different states is possible and (2) there are no rendering techniques for the size differences of a node over time. This thesis introduces the techniques EvoCell-Layouting, Change Map, and Change Hints. EvoCell-Layouting is a novel treemap layout algorithm that iteratively changes a given treemap layout. Change Maps are density maps to locate changes in attribute values disregarding the difference and the size of the node. Change Hints visualize spatial changes between two states of a treemap. These three techniques enhance the comprehension of the evolution of temporal hierarchical data. A prototypical implementation, a discussion about alternatives, and performance and memory analyses demonstrate real data applicability. An additional case study reveals distinctive changes in the software system of a monitored open-source project that are hard to detect with traditional hierarchy visualizations.

Thesis

Committee Work

Logo of Faculty of Digital Engineering (Hasso Plattner Institute and University of Potsdam)
since 2017

Faculty Counsil, Voting Member

Faculty of Digital Engineering (Hasso Plattner Institute and University of Potsdam)

Logo of Faculty of Digital Engineering (Hasso Plattner Institute and University of Potsdam)
Logo of Faculty of Digital Engineering (Hasso Plattner Institute and University of Potsdam)
since 2017

Study Commission, Voting Member

Faculty of Digital Engineering (Hasso Plattner Institute and University of Potsdam)

Logo of Faculty of Digital Engineering (Hasso Plattner Institute and University of Potsdam)
Logo of IEEE Computer Society / VGTC
since 2021

Reviewer

IEEE Computer Society / VGTC

  • Transactions for Visualization and Computer Graphics (TVCG)
  • Visualization Conference (VIS)
  • Pacific Visualization Symposium (PacificVis)
Logo of IEEE Computer Society / VGTC
Logo of Elsevier
since 2021

Reviewer

Elsevier

  • Information Sciences (INS)
Logo of Elsevier
Logo of International Symposium on Visual Information Communication and Interaction
since 2022

Reviewer

International Symposium on Visual Information Communication and Interaction

  • VINCI
Logo of International Symposium on Visual Information Communication and Interaction
Logo of International Symposium on Visual Information Communication and Interaction: VINCI 2021
in 2021

Organization Committee, Publication Chair

International Symposium on Visual Information Communication and Interaction: VINCI 2021

Logo of International Symposium on Visual Information Communication and Interaction: VINCI 2021
Logo of University of Potsdam
2018–2019

Working Group for the Principles in Teaching, Voting Member

University of Potsdam

Logo of University of Potsdam
Logo of Faculty of Digital Engineering, designated (Hasso Plattner Institute and University of Potsdam)
in 2017

Founding Committee, Voting Member

Faculty of Digital Engineering, designated (Hasso Plattner Institute and University of Potsdam)

Logo of Faculty of Digital Engineering, designated (Hasso Plattner Institute and University of Potsdam)

Projects

Thumbnail of cmake-init

cmake-init

Role: Maintainer
Type: Project Template
Homepage , Source Code

Template for reliable, cross-platform C++ project setup using cmake.

Thumbnail of globjects

globjects

Role: Maintainer
Type: OpenGL Library
Homepage , Source Code

A cross-platform C++ wrapper for OpenGL API objects.

Thumbnail of glbinding

glbinding

Role: Maintainer
Type: OpenGL Library
Homepage , Source Code

A C++ binding for the OpenGL API, generated using the gl.xml specification.

Thumbnail of glkernel

glkernel

Role: Maintainer
Type: Math Library
Source Code

C++ library for pre-computing noise, and random sample kernels.

Thumbnail of Attributed Vertex Clouds Demo

Attributed Vertex Clouds Demo

Role: Maintainer
Type: Demo
Source Code

Demo to the Article "Attributed Vertex Clouds" from GPU Zen: Advanced Rendering Techniques

Thumbnail of Unified Memory Demo

Unified Memory Demo

Role: Maintainer
Type: Demo
Source Code

Unified Memory Heterogenous Computing Showcase.

HiViSer

Role: Maintainer
Type: Research Project
Homepage

A Web API specification for the management and provisioning of tree-structured data and their visualization using information visualization techniques.

openll

Role: Maintainer
Type: Research Project
Homepage , Source Code

Open Label Library – API specification and reference implementations for glyph rendering in 2D and 3D graphics environments.

Thumbnail of cppexpose

cppexpose

Role: Maintainer
Type: Utility Library
Homepage , Source Code

C++ library for type introspection, reflection, and scripting interface.

Thumbnail of cppassist

cppassist

Role: Maintainer
Type: Utility Library
Homepage , Source Code

C++ sanctuary for small but powerful and frequently required, stand alone features.

Thumbnail of cpplocate

cpplocate

Role: Maintainer
Type: Utility Library
Homepage , Source Code

Cross-platform C++ library providing tools for applications to locate themselves, their data assets as well as dependent modules.

Thumbnail of HPI Schul-Cloud

HPI Schul-Cloud

Role: Contributor
Type: Service
Source Code

HPI Schul-Cloud Core Server.

CG Internals PPA

Role: Maintainer
Type: Binary Package Archive
Homepage

The Ubuntu Package Archive for the Open Source software of CG Internals.

khrbinding-generator

Role: Maintainer
Type: Utility Tools
Source Code

A Python generator for the Khronos APIs OpenGL, OpenGL ES, OpenGL SC, and EGL.

eglbinding

Role: Maintainer
Type: EGL Library
Source Code

A C++ binding for the EGL API, generated using the egl.xml specification.

glscbinding

Role: Maintainer
Type: OpenGL SC Library
Source Code

A C++ binding for the OpenGL SC API, generated using the gl.xml specification.

glesbinding

Role: Maintainer
Type: OpenGL ES Library
Homepage , Source Code

A C++ binding for the OpenGL ES API, generated using the gl.xml specification.

Thumbnail of gloperate

gloperate

Role: Maintainer
Type: OpenGL Framework
Source Code

C++ library for defining and controlling modern GPU rendering/processing operations.

Thumbnail of cppfs

cppfs

Role: Contributor
Type: Utility Library
Homepage , Source Code

Cross-platform C++ file system library supporting multiple backends.

qmltoolbox

Role: Contributor
Type: Utility Library
Source Code

QML item library for cross-platform graphics applications.

Thumbnail of webgl-operate

webgl-operate

Role: Contributor
Type: WebGL Framework
Homepage , Source Code

A TypeScript based WebGL rendering framework.

Widelands

Role: One-time Contributor
Type: Video Game
Homepage

A free, Settlers II inspired, open source real-time strategy game with singleplayer campaigns and a multiplayer mode.

Thumbnail of glm

glm

Role: One-time Contributor
Type: Math Library
Homepage , Source Code

C++ library for OpenGL Mathematics.

Tasteful Framework

Role: Maintainer
Type: Web Framework
Source Code

A framework to create web application servers written in C++ based on the Tasteful Server.

Tasteful Server

Role: Maintainer
Type: Web Framework
Source Code

A multithreaded web server written in C++ (using Qt)

Presentations

06/18/21

Algorithmic Improvements on Hilbert and Moore Treemaps for Visualization of Large Tree-structured Datasets
EuroVis 2021, Virtual Attendance at Zürich, Switzerland

Slides (PDF)

12/08/20

A Survey of Treemap Visualization Techniques
VINCI 2020, Virtual Attendance at Eindhoven, The Netherlands

Slides (PDF)

02/29/20

A Taxonomy on Treemap Visualization Techniques
IVAPP 2020, Valletta, Malta

Slides (PDF)

02/26/19

Rendering Procedural Textures for Visualization of Thematic Data in 3D Geovirtual Environments
IVAPP 2019, Prague, Czech Republic

02/26/19

Design and Implementation of Web-Based Hierarchy Visualization Services
IVAPP 2019, Prague, Czech Republic

Slides (PDF)

03/07/18

Einführung in die Shared-Memory-Programmierung heterogener Systeme
parallel 2018, Heidelberg, Deutschland

Handout (PDF, 5.1 MiB), Slides (PDF)

01/28/18

EvoCells – A Treemap Layout Algorithm for Evolving Tree Data
IVAPP 2018, Funchal, Madeira, Portugal

Slides (PDF)

02/28/16

Interactive Revision Exploration using Small Multiples of Software Maps
IVAPP 2016, Rome, Italy

Poster (Landscape, PDF), Poster (Portrait, PDF)

Teaching

2022 : Summer Term

Computer Graphics II
Lecture (B.Sc.), Co-Lecturer

Advanced Techniques for Analysis and Visualization of Software Data
Project Seminar (M.Sc.), Seminar Lead and Tutor

2021/22 : Winter Term

Computer Graphics I
Lecture (B.Sc.), Co-Lecturer

Introduction to Data Visualization
Lecture (M.Sc.), Tutor

Design and Construction of AI-based Interactive Systems with a 'Dark Side of AI'
Project Seminar (B.Sc.), Seminar Lead and Tutor

Advanced Techniques for Visual Analytics of Highdimensional Data
Project Seminar (M.Sc.), Tutor

2021 : Summer Term

Systems Engineering and Data Processing with C++
Lecture (M.Sc.), Lecturer and Tutor

Software Mining and Applications
Seminar (M.Sc.), Seminar Lead and Tutor

Visualization and Analysis of Mulitidimensional Data
Seminar (M.Sc.), Tutor

2020/21 : Winter Term

Computer Graphics I
Lecture (B.Sc.), Co-Lecturer

Programing User Interfaces
Lecture (B.Sc.), Co-Lecturer and Tutor

Analysis and Visualization of Similarities of Software Systems
Project (M.Sc.), Supervisor

2020 : Summer Term

Computer Graphics II
Lecture (B.Sc.), Co-Lecturer

Analysis and Visualization of Software Data
Seminar (M.Sc.), Seminar Lead and Tutor

Visual Analytics on Multi-dimensional Data using Topic Maps
Project (M.Sc.), Supervisor

2019/20 : Winter Term

Game Programming
Seminar (B.Sc.), Seminar Lead and Tutor

Selected Topics in Visual Analytics
Seminar (M.Sc.), Tutor

Selected Topics in Data Analytics
Seminar (M.Sc.), Tutor

2019 : Summer Term

Fundamentals of Software Analytics
Lecture (M.Sc.), Co-Lecturer and Tutor

2018/19 : Winter Term

Introduction to Software Analytics
Lecture (BA/MA), Co-Lecturer and Tutor

Visualization Algorithms & Techniques
Seminar (M.Sc.), Tutor

2018 : Summer Term

Gameprogramming
Project Seminar (B.Sc.), Seminar Lead and Tutor

2017/18 : Winter Term

Advanced Development in C++
Project Seminar (M.Sc.), Seminar Lead and Tutor

2017 : Summer Term

Advanced Information Visualization
Seminar (M.Sc.), Tutor

2016/17 : Winter Term

Advanced Programming in C++
Lecture (M.Sc.), Co-Lecturer and Tutor

Methods and Techniques of Information Visualization
Seminar (M.Sc.), Tutor

Real-time Monitoring of Massive Filesystems
Project (M.Sc.), Supervisor

2016 : Summer Term

Computergraphics II
Lecture (B.Sc.), Tutor

Methods and Techniques of Software Visualization
Seminar (M.Sc.), Tutor

Massive Information Mining for Software Analytics
Project (B.Sc.), Supervisor

2015/16 : Winter Term

Computergraphics I
Lecture (B.Sc.), Tutor

Systems Engineering for Software Analytics
Seminar (M.Sc.), Tutor

2015 : Summer Term

Computergraphics I
Lecture (B.Sc.), Tutor

Visual Software Analytics
Seminar (M.Sc.), Tutor

Programming of Computer Graphics Techniques using C++ and OpenGL
Seminar (B.Sc.), Tutor and Co-Lecturer

Software Analytics
Project (B.Sc.), Supervisor

2014/15 : Winter Term

Computergraphics II
Lecture (B.Sc.), Tutor

Visualization for Interactive Software Analytics
Seminar (M.Sc.), Tutor

Automated Visual Software Analytics
OpenHPI Course, Tutor

Software Analytics
Project (B.Sc.), Supervisor

2014 : Summer Term

Information Visualization
Seminar (M.Sc.), Co-Tutor

Graphics Programming using OpenGL and C++
Seminar (B.Sc.), Co-Tutor and Co-Lecturer

2013/14 : Winter Term

Software Analysis and Visualization
Seminar (M.Sc.), Co-Tutor

Contact

E-Mail:

willyscheibel@gmx.de

Other: willy.scheibel@hpi.de, willy.scheibel@cginternals.com

vCard: