Hi, I'm Adrian

Immersive Software Archaeology: Comprehending Software Structure through Interactive Visualization in Virtual Reality

I proudly present my PhD thesis! The thesis concludes my journey at the IT University of Copenhagen and my research project Immersive Software Archaeology.

Comprehending existing software systems is an activity relevant for, e.g., preparing the re-engineering of a legacy system. It is often complicated by missing or incomplete documentation and the absence of a system's original developers, making source code the only reliable source of information. However, exploring a software system solely by reading through its source code is a tedious and challenging task that, if possible at all, requires significant stamina and motivation. Visualizations can offer an overview of otherwise complex source code bases, making them a valuable tool for assisting software engineers in this exploration process. In this thesis, I present work on utilizing virtual reality (VR) to provide teams of software engineers with interactive, synchronized multi- user visualizations of source code, for the purpose of exploring software architecture while taking notes on insights and planning future actions. To foster software architecture exploration, the presented VR visualization methods are based on results from automated software clustering techniques. Further, they introduce concepts for mixing automatically interpreted freehand drawing in VR with multimedia annotations, so that engineers can explore software systems in long-lived sessions. I demonstrate the presented visualization methods in tool imple- mentations and assess via empirical studies their suitability for assisting engineers in comprehending software systems. The results of the studies show that VR software visualization is suitable for assisting engineers – especially those with less experience – in comprehending a subject system’s architectural structure. Regarding note-taking, the studies demonstrate that freehand sketching in VR is useful for capturing high-level views on system architecture, while multi-media annotations (such as audio recordings) are a valuable means for more general notes. Lastly, the studies show that software engineers value synchronized multi-user VR software visualization for focused exploration sessions with vivid communication where even with little training and despite their unfamiliarity with VR, engineers are able to gain correct insights into a subject system.

This paper presents technical aspects of the tool implementation to our VR visualization method for software exploration with note taking (part of the ISA project).

Understanding software systems is a vital task, often undertaken by teams of engineers, for the development and maintenance of systems. Collaborative software visualization tools are essential in this context, yet they are limited. Existing tools, particularly in virtual reality, allow exploration but lack the crucial feature of note-taking, which is a significant limitation. We introduce Immersive Software Archaeology (ISA), a virtual reality tool that enables engineering teams to collaboratively explore and comprehend software systems. Unique to ISA, it facilitates note-taking during exploration with virtual multimedia whiteboards that support freehand diagramming, audio recordings, and VR screenshots. Notes taken on these whiteboards are synchronized with an Integrated Development Environment (IDE), providing easy access to the results of a VR exploration while performing changes to the system’s source code.

This is a complementary video:

This paper presents our method for collaborative software exploration with note taking capabilities in virtual reality. (Part of the ISA project).

Exploring and comprehending a software system, e.g., as preparation for its re-engineering, is a relevant, yet challenging endeavour often conducted by teams of engineers. Collaborative exploration tools aim to ease the process, e.g., via interactive visualizations in virtual reality (VR). However, these neglect to provide engineers with capabilities for persisting their thoughts and findings. We present an interactive VR visualization method that enables (distributed) teams of engineers to collaboratively (1) explore a subject system, while (2) persisting insights via free-hand diagrams, audio recordings, and in-visualization VR screenshots. We invited pairs of software engineering practitioners to use our method to collaboratively explore a software system. We observed how they used our method and collected their feedback and impressions before replaying their findings to the original developers of the subject system for assessment.

Best Tool Paper Award - SANER'24

This paper presents technical aspects of the VR tool developed for our architecture visualization via a solar system metaphor in VR (part of the ISA project).

Comprehending large-scale software systems is a challenging and daunting task, particularly when only source code is available. While software visualization attempts to aid that process, existing tools primarily visualize a system’s structure in terms of files, folders, packages, or namespaces, neglecting its logical decomposition into cohesive architectural components. We present the tool Immersive Software Archaeology (ISA) which (i) estimates a view of a system’s architecture by utilizing concepts from software architecture recovery and (ii) visualizes the results in virtual reality (VR) so that users can explore a subject system interactively, making the process more engaging. In VR, a semantic zoom lets users gradually transition between architectural components of different granularity and classlevel elements while relationship graphs let users navigate along connections across classes and architectural components. We present results from a controlled experiment with 54 participants to investigate the usefulness of ISA for assisting engineers with exploring an unfamiliar large-scale system compared to another state-of-the-art VR approach and an IDE.

This is a complementary video:

In this paper, we present a virtual whiteboard that lets users of software visualizations free-handedly sketch software structures using a virtual pen and elements from the visualization. We integrated it into the ISA project and tested it with engineers from different companys.

Re-architecting a software system requires significant preparation, e.g., to scope and design new modules with their boundaries and constituent classes. When planning an intended future state of a system as a re-engineering goal, engineers often fall recur to mechanisms such as freehand sketching (using a whiteboard). While this ensures flexibility and expressiveness, the sketches remain disconnected from the source code. The alternative, tool-supported diagramming on the other hand considerably restricts flexibility and impedes free-form communication. We present a method for preparing the architectural software re-engineering via freehand sketches in virtual reality (VR) that can be seamlessly integrated with the model structure of a software visualization and, thus, also the code of a system, for productive use: Engineers explore a subject system in the immersive visualization, while freehand sketching their insights and plans. Our concept automatically interprets sketched shapes and connects them to the system’s source code, and superimposes code-level references into a sketch to support engineers in reflecting on their sketches. We evaluated our method in an iterative interview-based case study with software developers from four different companies, where they planned a hypothetical re-engineering of an opensource software system.

This is a complementary video:

In this paper, we present a method for "uniquifying" 3D software visualizations via systematic generation of unique 3D landmarks using a mixture of 3D modelling and variability modeling techniques.

Software visualization facilitates the interactive exploration of large-scale code bases, e.g., to rediscover the architecture of a legacy system. Visualizations of software structure suffer from repetitive patterns that complicate distinguishing different subsystems and recognizing previously visited parts of an architecture. We leverage variability-modeling techniques to "uniquify" visualizations of subsystems via custom-tailored 3D models of recognizable landmarks: For each subsystem, we derive a descriptor and translate it to a (random but deterministic) configuration of a feature model of variable 3D geometry to support large numbers of different 3D models while capturing the design language of a particular type of landmark. We devised a hybrid variant derivation mechanism using a slots-and-hooks composition system for 3D geometry as well as adjusting visual characteristics, e.g., material. We demonstrate our method by creating various different trophies as landmarks for the visualization of a software system.

In this paper, we describe a method for visualizing the architecture and design of a large-scale software system in virtual reality, so that one can explore and comprehend its structure visually instead of only reading code. We implemented this method in our tool Immersive Software Archaeology.

Exploring an unfamiliar large-scale software system is challenging especially when based solely on source code. While software visualizations help in gaining an overview of a system, they generally neglect architecture knowledge in their representations, e.g., by arranging elements along package structures rather than functional components or locking users in a specific abstraction level only slightly above the source code. In this paper, we introduce an automated approach for software architecture recovery and use its results in an immersive 3D virtual reality software visualization to aid accessing and relating architecture knowledge. We further provide a semantic zoom that allows a user to access and relate information both horizontally on the same abstraction level, e.g., by following method calls, and vertically across different abstraction levels, e.g., from a member to its parent class. We evaluate our contribution in a controlled experiment contrasting the usefulness regarding software exploration and comprehension of our concepts with those of the established CityVR visualization and the Eclipse IDE.

Here is a video that demonstrates the prototype:

In this paper, we report on insights into developing a software product line using delta-oriented programming. The concrete tool used was DeltaJava.

A Software Product Line (SPL) captures families of closely related software variants. The configuration options of an SPL are represented by features. Typically, SPLs are developed in a featurecentric manner and, thus, require different development methods and technologies from developing software products individually. For developers of single systems, this means a shift in paradigm and technology. Especially with invasive variability realization mechanisms, such as Delta-Oriented Programming (DOP), centering development around configurable features realized via source code transformation is commonly expected to pose an obstacle, but concrete experience reports are lacking. In this paper, we investigate how DOP and cutting-edge SPL development tools are picked up by non-expert developers. To this end, we report on our experiences from a student capstone SPL development project. Our results show that participants find easy access to SPL development concepts and tools. Based on our observations and the participants’ practices, we define guidelines for developers using DOP.

In this short paper, we outline our goals for the ISA project and what challenges we want to address:

Many of today’s software systems will become the legacy systems of tomorrow, comprised of outdated technology and inaccurate design documents. Preparing for their eventual re-engineering requires engineers to regain lost design knowledge and discover re-engineering opportunities. While tools and visualizations exist, comprehending an unfamiliar code base remains challenging. Hence, software archaeology suffers from a considerable entry barrier as it requires expert knowledge, significant diligence, tenacity, and stamina. In this paper, we propose a paradigm shift in how legacy systems’ design knowledge can be regained by presenting our vision for an immersive explorable software visualization in virtual reality (VR). We propose innovative concepts leveraging benefits of VR for a) immersion in an exoteric visualization metaphor, b) effective navigation and orientation, c) guiding exploration, and d) maintaining a link to the implementation. By enabling immersive and playful legacy system exploration, we strive for lowering the entry barrier, fostering long-term engagement, strengthening mental-model building, and improving knowledge retention in an effort to ease coping with the increased number of tomorrow’s legacy systems.

This is the complementary conference talk/video:

Extended journal version of our GPCE'19 paper "Automated Metamodel Augmentation for Seamless Model Evolution Tracking and Planning":

In model-based software engineering, models are central artifacts for management, design and implementation. To meet new requirements, engineers need to plan and perform model evolution. So far, model evolution histories are captured using version control systems, e.g., Git. However, these systems are unsuitable for planning model evolution as they do not have a notion of future changes. Furthermore, formally assigning responsibilities to engineers for performing evolution of model parts is achieved by using additional tools for access control. To remedy these shortcomings, we provide a method to generate evolution-aware modeling notations by augmenting existing metamodels with concepts for capturing previous performed and planned evolution as first-class entity. To provide a clear overview, we automatically generate a Gantt-style viewer for augmented models and capabilities to slice models for certain time periods. Our method enables engineers to seamlessly plan future model evolution while actively developing the current model state using a centralized access point for evolution. With the generated Gantt-style viewers and the slicing functionality, we enable engineers to inspect relevant model evolution while reducing model size and hiding unnecessary complexity. In our evaluation, we provide an implementation of our method in the tool TemporalRegulator3000. We show applicability for real-world metamodels and capture the entire evolution timeline of corresponding models.

In this paper, we present a method that enables to safely plan evolution based on an evolving feature model:

A software product line (SPL) enables large-scale reuse in a family of related software systems through configurable features. SPLs represent a long-term investment so that their ongoing evolution becomes paramount and requires careful planning. While existing approaches enable to create an evolution plan for an SPL on feature-model (FM) level, they assume the plan to be rigid and do not support retroactive changes. In this paper, we present a method that enables to create and retroactively adapt an FM evolution plan while preventing undesired impacts on its structural and logical consistency. This method is founded in structural operational semantics and linear temporal logic. We implement our method using rewriting logic, integrate it within an FM tool suite and perform an evaluation using a collection of existing FM evolution scenarios.

In this paper, we present a method that allows to automatically extend arbitrary EMOF meta models with capabilities to integrate model instances' evolution into their model structure.

In model-based software engineering, models are central artifacts used for management, design and implementation. To meet new requirements, engineers need to plan and perform model evolution. So far, model evolution histories are captured using version control systems, e.g., Git. However, these systems are unsuitable for planning model evolution as they do not have a notion of future changes. Furthermore, formally assigning responsibilities to engineers for performing evolution of model parts is achieved by using additional tools for access control. To remedy these shortcomings, we provide a method to generate evolution-aware modeling notations by augmenting existing metamodels with concepts for capturing past and planned evolution as first-class entity. Our method enables engineers to seamlessly plan future model evolution while actively developing the current model state, both using a centralized access point for evolution. In our evaluation, we provide an implementation of our method in the tool TemporalRegulator3000, show applicability for realworld metamodels, and capture the entire evolution time line of corresponding models.