Gaining an in-depth understanding of the structure of software systems can be overwhelming, time-consuming, and unappealing. Since people play a key role in software development, human factors, such as motivation, must be considered when designing software development tools. We investigated this concept by using “gamification” for software visualization. We developed a gamified visualization tool for object-oriented software architectures, added gamification elements using a user-centered design approach, and evaluated it based on qualitative feedback from software developers. Our results suggest that gamification meaningfully enhances software understanding via visualization. However, further design iterations are needed to improve gamified visualization, as well as a quantitative study to evaluate it.

Software understanding is a critical activity for a wide range of stakeholders in software development. However, existing software visualization tools often lack an iterative user-centered design approach, resulting in solutions that do not fully meet the specific needs of target audiences. We describe a design iteration of the software visualization tool IslandViz targeted at professional software developers. We implemented a revised version of IslandViz based on insights from previous user evaluations and evaluated this version by conducting contextual interviews with experts who perform their regular coding tasks in their own software systems with and without IslandViz. From their qualitative feedback, we identified and implemented two key requirements for coding productivity, including performance improvements and a desktop-based presentation. We describe the resulting prototype and discuss lessons learned and future work.

The architecture and inner structure of software is often only implicitly available in the form of its source code and thus not tangible and intuitively easy to understand for non-programmers and laymen. Our goal is to create visualizations as automatically as possible, with which such people can neverthe-less understand the software or parts of the software and get a feel for the structure of the software and how its methods work. Especially for newcomers to software projects, for management or even for students and pupils, it can be helpful to get a non-technical insight into the software. We use the concept of visualizing information as comics to present aspects of the software as strikingly as possible, as comics are an effective way to present complex systems and interrelationships for certain target groups. For this purpose, we present a method to generate comics from source code. Our semi-automated process is based on generating a prompt for an LLM from source code, which in turn generates a prompt for a comic image generation using the text-to-image model Stable Diffusion. We show that generative AI methods can be used to rapidly generate human-compatible artistic representations from source code. However, further research is needed to validate the understandability of the results.

C# is the most widely used programming language among XR developers. However, only a limited number of graph-based data acquisition tools exist for C# software. XR development commonly relies on reusing existing software components to accelerate development. Graph-based visualization tools can facilitate this comprehension process, e.g., by providing an overview of relationships between components. This work describes a new tool called Src2Neo that generates labeled property graphs of C#-based software projects. The stored graph follows a simple C# naming scheme and — contrary to other solutions — maps each software entity to exactly one node. The resulting graph facilitates the comprehension process by providing an easy to read representation of software components. Additionally, the generated graphs can act as a data basis for more advanced software visualizations without the need for complex data requests.

Stereotypes support a high-level software comprehension by implying roles and responsibilities of classes in software systems. We propose the idea of using stereotypes as design patterns for serious games to enhance object oriented software comprehension. These design patterns can reduce the complexity of software systems and encode software knowledge into game mechanics. We provide examples of possible game mechanics and discuss the application of the proposed design patterns.

Software development is a complex process involving many people and development tools and their interactions; during development, a lot of data such as source code, documents, or software artifacts and information such as issues, discussions, or code analyses are generated or modified. In addition to the analysis and visualization of software systems, it is useful to analyze the software development process to obtain better information about the quality, reliability, and trustworthiness of the software. To gain insights and knowledge about software development processes, we extract the provenance of development processes, especially from version control systems for Git-based software projects, and visualize the provenance information using graph visualization, metrics representation, and development timelines; including an integration of these methods into a web-based dashboard. With the help of visual provenance representations, project managers can gain an overview and insights into development progress, effects of process changes, and interactions among developers and with external contributors, which we exemplify with a case study of a software with high social relevance.

The use of static code analysis tools for security audits can be time consuming, as the many existing tools focus on different aspects and therefore development teams often use several of these tools to keep code quality high and prevent security issues. Displaying the results of multiple tools, such as code smells and security warnings, in a unified interface can help developers get a better overview and prioritize upcoming work. We present visualizations and a dashboard that interactively display results from static code analysis for “interesting” commits during development. With this, we aim to provide an effective visual analytics tool for code security analysis results.

We analyze visually, to what extend team members and external developers contribute to open-source projects to have a high-level impression about collaboration in that projects. For that, we record the provenance of the development process and draw the resulting property graph. Our graph drawings show, which developers are jointly changed the same files what we apply to Germany's COVID-19 exposure notification app 'Corona-Warn-App'.

The visualization of software architectures by the use of effective and feasible visual metaphors provides an intuitive approach to comprehend the implemented architecture of a software project. In this regard not only the visualization of the latest status of the implemented architecture is important, but also the visualization of the history of software architectures. Such visualizations show dependencies and contexts in which design decisions were made. Resulting information supports programmers to understand systems and to recognize disadvantageous design decisions. A software which is particularly suited for the visualization of component-based software is IslandViz. This software visualizes OSGi-based software architectures in Virtual Reality with an island metaphor, but at this point the history of an architecture is not taken into account. In this paper we present how IslandViz can be extended to visualize the history of software architectures of OSGi-based software projects. For this purpose we use algorithms for dynamic graphs to realize a dynamic positioning of the islands and an adaptable layout of the regions on the islands. The aim is to ensure that the user's orientation in the virtual environment is preserved even if elements of the visualization must adapt due to changes in the software history.

Exploring of software architectures with software visualization in Augmented Reality (AR) is possible with different interaction methods, such gesture, gaze, and speech. For interaction with speech (i.e., natural language), we present an architecture and an implementation of conversational interfaces for the Microsoft HoloLens device. We aim to remedy some peculiarities of AR devices, but also enhancing the exploration task at hand. To implement the conversational interface different natural language processing (NLP) components such as natural language generation and intent recognition are typically required. Our proposed architecture integrates conversational components with the AR-based software visualization. We describe its implementation based on different user utterances, where the system provides information about the to-be-explored component-based software architecture in the form of adjusted visualizations and speech-based results. We apply out tool to explore OSGi-based software architectures.

We propose the tool IslandViz for exploring modular software systems in virtual reality. We use an island metaphor, which represents every module as a distinct island. The resulting island system is displayed in the confines of a virtual table, where users can explore the software visualization on multiple levels of granularity by performing navigational tasks. Our approach allows users to get a first overview about the complexity of an OSGi-based software system by interactively exploring its modules as well as the dependencies between them.

We present an approach for exploring OSGi-based software systems in virtual reality. We employ an island metaphor, which represents every module as a distinct island. The resulting island system is displayed in the confines of a virtual table, where users can explore the software visualization on multiple levels of granularity by performing intuitive navigational tasks. Our approach allows users to get a first overview about the complexity of an OSGi-based software system by interactively exploring its modules as well as the dependencies between them.

This demo presents an immersive augmented reality solution for visualizing OSGi-based software architectures. By employing an island metaphor, we map abstract software entities to tangible real-world objects. Using advanced input modalities, such as voice and gesture control, our approach allows for interactive exploration and examination of complex software systems.

Many applications today use deep learning to provide intelligent behavior. To understand and explain how deep learning models come to certain decisions can be hard or completely in-transparent. We propose a visualization of convolutional neural networks in Virtual Reality (VR). The interactive application shows the internal processes and allows to inspect the results. Large networks can be visualized in real-time with special rendering techniques.

We present the visualization of component-based software architectures in Virtual Reality (VR) to understand complex software systems. We describe how to get all relevant data for the visualization by data mining on the whole source tree and on source code level. The data is stored in a graph database for further analysis and visualization. The software visualization uses an island metaphor. Storing the data in a graph database allows to easily query for different aspects of the software architecture.

Software visualizations provide many different complex views with different filters and metrics. But often users have a specific question to which they want to have an answer or they need to find the best visualization by themselves and are not aware of other metrics and possibilities of the visualization tool. We propose an interaction with software visualizations based on a conversational interface. The developed tool extracts meta information from natural language sentences and displays the best fitting software visualization by adjusting metrics and filter settings.

In large software projects, it can be hard to understand the actual architecture of the implemented software systems if current design documents are outdated or do not exist at all. For systems based on the OSGi component specification, which are used to build quite large applications with back-end and front-end services, tools for visualizing the actual architecture can help to understand the system. We provide an interactive tool that visualizes OSGi-based systems with their components, packages, services, and dependencies in 3D using Virtual Reality headsets. It uses the metaphor of modular electronic systems. The tool allows software engineers, project managers, or clients to explore the architecture and get a first impression about component sizes and their dependencies.

In science, more and more software is published as Open Source software or uses Open Source projects. Therefore, scientists must be aware of requirements, restrictions and compatibility issues of Open Source licenses. We describe our strategy at the German Aerospace Center (DLR) to awake the awareness among our domain scientists and to enable and support them in publishing Open Source software, which is free of license issues. We provide hands-on material, offer training courses, and foster knowledge sharing between peer scientists. Findings and feedback prove the usefulness and effectiveness.

The architecture of software it not tangible, but in different situations it is preferable to have it tangible. For example, while reviewing it against the intended design, introducing the software to others, or starting to develop on a new part. Basic aspects of a software architecture are the modules the software is constructed of and the dependencies between them. To comprehend these aspects is important especially for software using a technology such as OSGi, which key concept is modularization. In this paper, we describe interactive visualization tools that we developed to comprehend large OSGi-based applications with their modules and dependencies. We applied our solution for OSGi-based applications with hundreds of modules containing multiple submodules each. With the resulting visualizations, we can explore the modularization of the software architecture.

In aerospace engineering, as well as in many other disciplines, many software tools are developed. Often, it is hard to get an overview of already existing software. Sometimes this leads to multiple development of software, if nobody is able to determine whether a software for a specific tasks exist already or not. Therefore, in companies and organizations there is a need for a directory of exiting software. The German Aerospace Center has built such a directory based on the Open Source software Allura, which is the base software that drives the Open Source hosting platform SourceForge.net. Allura has been customized to the needs of the aerospace domain. The result is a software portal for the aerospace research community, that allow to register and categorize software. It is intendend to be used both for Open Source and proprietary software. Employees of the German Aerospace Center as well as the public can search for existing software. This reduces the amount of software developed twice and allows to get in touch with colleagues who developed similar software.

Today modern software development is not possible without the aid of tools like version control systems, bug tracking systems or instruments that ensure the compliance with code conventions. Unfortunately, all of these tools “live in their own world”, are only loosely coupled and do not interact with each other. RepoGuard addresses this problem by linking version control systems to other software development tools. It is implemented as an extension to several version control systems and provides interfaces to integrate other tools. The use of RepoGuard allows maximum control and validation of all committed resources before they are permanently stored. Additionally, RepoGuard provides communication channels in order to inform all relevant stakeholders about the failure or success of the process. Overall, RepoGuard provides simple but effective means to guarantee software quality standards in distributed development processes.

This paper presents wrapping techniques that we have developed in order to integrate applications into the scientific workflow management system TENT. These techniques take into account the varying degrees of controllability found for each application and utilize various kinds of communication mechanisms between application and the associated wrapper. We also give an outline of the principles of component technology employed in the CORBA based TENT environment. In addition, the means by which applications can be connected through their associated wrappers and TENT components to form distributed workflows are presented. It is demonstrated how TENT provides the user with a homogeneous perspective on scientific workflows running in a distributed environment and how he is enabled to efficiently configure and control these workflows by means of the TENT component model.

Abstract This paper describes recent development efforts on the integrated simulation environment TENT. TENT is a component‐based software integration and workflow management system using the capabilities of CORBA and Java. It is used to integrate the applications required to form complex workflows, which are typical of multidisciplinary simulations in engineering, in which different simulation codes have to be coupled. We present our work in integrating TENT with the Globus Toolkit to create a Grid computing environment. The Java Commodity Grid Toolkit has been especially useful for this work. Copyright © 2002 John Wiley & Sons, Ltd.