Modern Software as a Service (SaaS) platforms, such as the Microsoft Power Platform, simplify maintenance efforts through abstraction of underlying layers such as managing server infrastructure or OS-level configurations. Nevertheless, they still allow custom code extensions to extend and customize the application behavior. Yet, this implies restricted control and limited insights with respect to performance.Often, built-in performance reportings do not provide enough detail for efficient problem root cause analysis. Open standards, such as OpenTelemetry, make it easier to implement a more advanced aligned tracing ecosystem. Yet, while monitoring on traditional, non-cloud systems has been thoroughly studied, collecting telemetry data on SaaS systems faces many more complex challenges such as sandboxing, e.g., limited API access, or collecting end-to-end traces through multiple distributed entry points. Besides platform experience, deep technical knowledge about serialization, transmission, and caching costs is essential to understand the process and assess the performance overhead introduced by collecting telemetry data.In this work, we discuss common challenges regarding SaaS observability and the performance impact that telemetry data collection introduces. For this, we modify Intermediate Language (IL) code, i.e., already compiled code, on the Microsoft Power Platform to collect telemetry data for each method execution. A key finding is that a significant and often unreported portion of performance overhead originates from the SaaS platform itself, a crucial distinction from the overhead introduced by telemetry collection. Finally, we propose a concept for adaptive telemetry collection based on execution plan prediction, which aims to balance observability detail with performance overhead by estimating monitoring costs.

Software development education faces challenges in teaching abstract and complex programming concepts. Since problems in comprehension can lead to decreased student engagement, we introduce JavaWiz: an educational graphical debugger that addresses these challenges by combining traditional debugging functionality with intuitive, dynamic visualizations of program state and run-time behavior. JavaWiz's key features include real-time visualization of heap, stack, and static fields; automatically generated flow charts; interactive representations of data structures; and unique time-travel debugging capabilities. Its step-by-step visual exploration of code execution, including the ability to step backward, bridges the gap between abstract concepts and concrete program understanding. We present the tool's visualization components in detail and discuss its applications in teaching. Lecturers report positive influence on their in-class demonstrations and initial student feedback reinforces the tool's usefulness for program comprehension.

Enhancing students’ comprehension of bytecode generation and its interpretation is crucial, yet challenging, in compiler construction courses. Traditional approaches often emphasize theoretical concepts, making it difficult for students to grasp the inner workings of bytecode interpreters.To bridge this gap, we introduce a web-based tool for trace-based bytecode interpreter visualization, designed to enhance comprehension by providing an interactive and visually enriched learning experience. Our tool provides a side-by-side view that aligns the original high-level source code and its corresponding low-level bytecode, with arrows indicating jumps and method calls. Users can step through the executed bytecode (forwards and backwards) to see the effect of each operation. A dynamic memory visualization utilizes animations to illustrate changes in the interpreter’s various memory regions and its registers. To further increase the flexibility of our tool, we developed a lightweight metalanguage that enables educators to define visualizations for arbitrary bytecode formats.Our tool aims to bridge the gap between abstract theory and concrete execution. We demonstrate its effectiveness in various educational settings, e.g., how it can help educators improve their live teaching and how it facilitates student self-study.

Annotations add metadata to source code entities such as classes or functions, which later can be processed by so-called annotation processors to, for example, modify the annotated program’s source code. While annotation processing has been well-explored in Java, the Kotlin community still lacks a comprehensive summary. Thus, in this paper, we summarize the main approaches available in Kotlin: (1) ‍Compile-time annotation processing using (a) ‍Kotlin Annotation Processing Tool (KAPT), (b) ‍Kotlin Symbolic Processing (KSP), or (c) ‍writing a custom Kotlin Compiler plugin; as well as (2) ‍load-time code modification using an agent or a custom class loader. We provide proof-of-concept implementations, discuss advantages and disadvantages, and specifically focus on how well each approach supports modifying the annotated source code. This should help developers and researchers to better decide when to use which approach.

Many monitoring tools that help developers in analyzing the run-time behavior of their applications share a common shortcoming: they require their users to have a fair amount of experience in monitoring applications to understand the used terminology and the available analysis features. Consequently, novice users who lack this knowledge often struggle to use these tools efficiently. In this paper, we introduce the guided exploration (GE) method that aims to make interactive monitoring tools easier to use and learn. In general, tools that implement GE should provide four support operations on each analysis step: they should automatically (1) detect and (2) highlight the most important information on the screen, (3) explain why it is important, and (4) suggest which next steps are appropriate. This way, tools guide users through their analysis processes, helping them to explore the root cause of a problem. At the same time, users learn the capabilities of the tool and how to use them efficiently. We show how GE can be implemented in new monitoring tools as well as how it can be integrated into existing ones. To demonstrate GE's feasibility and usefulness, we present how we extended the memory monitoring tool AntTracks to provided guided exploration support during memory leak analysis and memory churn analysis. We use these guidances in two user scenarios to inspect and improve the memory behavior of the monitored applications. We hope that our contribution will help usability researchers and developers in making monitoring tools more novice-friendly by improving their usability and learnability.

Tool support is essential to help developers in understanding the memory behavior of complex software systems. Anomalies such as memory leaks can dramatically impact application performance and can even lead to crashes. Unfortunately, most memory analysis tools lack advanced visualizations (especially of the memory evolution over time) that could facilitate developers in analyzing suspicious memory behavior.In this paper, we present Memory Cities, a technique to visualize an application's heap memory evolution over time using the software city metaphor. While this metaphor is typically used to visualize static artifacts of a software system such as class hierarchies, we use it to visualize the dynamic memory behavior of an application. In our approach, heap objects can be grouped by multiple properties such as their types or their allocation sites. The resulting object groups are visualized as buildings arranged in districts, where the size of a building corresponds to the number of heap objects or bytes it represents. Continuously updating the city over time creates the immersive feeling of an evolving city. This can be used to detect and analyze memory leaks, i.e., to search for suspicious growth behavior. Memory cities further utilize various visual attributes to ease this task. For example, they highlight strongly growing buildings using color, while making less suspicious buildings semi-transparent.We implemented memory cities as a standalone application developed in Unity, with a JSON-based interface to ensure easy data import from external tools. We show how memory cites can use data provided by AntTracks, a trace-based memory monitoring tool, and present case studies on different applications to demonstrate the tool's applicability and feasibility.

Memory analysis tools are essential for finding and fixing anomalies in the memory usage of software systems (e.g., memory leaks). Although numerous tools are available, hardly any empirical studies exist on their usefulness for developers in typical usage scenarios. Instead, most evaluations are limited to reporting performance metrics. We thus conducted a study to empirically assess the usefulness of the interactive memory analysis tool AntTracks Analyzer. Specifically, we first report findings from assessing the tool using a cognitive walkthrough, guided by the Cognitive Dimensions of Notations Framework. We then present the results of a qualitative user study involving 14 subjects who used AntTracks to detect and resolve memory anomalies. We report lessons learned from the study and implications for developers of interactive memory analysis tools. We hope that our results will help researchers and developers of memory analysis tools in defining, selecting, and improving tool capabilities.

In this article, we present results obtained from field trials with the Hobbit robotic platform, an assistive, social service robot aiming at enabling prolonged independent living of older adults in their own homes. Our main contribution lies within the detailed results on perceived safety, usability, and acceptance from field trials with autonomous robots in real homes of older users. In these field trials, we studied how 16 older adults (75 plus) lived with autonomously interacting service robots over multiple weeks. Robots have been employed for periods of months previously in home environments for older people, and some have been tested with manipulation abilities, but this is the first time a study has tested a robot in private homes that provided the combination of manipulation abilities, autonomous navigation, and non-scheduled interaction for an extended period of time. This article aims to explore how older adults interact with such a robot in their private homes. Our results show that all users interacted with Hobbit daily, rated most functions as well working, and reported that they believe that Hobbit will be part of future elderly care. We show that Hobbit’s adaptive behavior approach towards the user increasingly eased the interaction between the users and the robot. Our trials reveal the necessity to move into actual users’ homes, as only there, we encounter real-world challenges and demonstrate issues such as misinterpretation of actions during non-scripted human-robot interaction.

Modern memory monitoring tools do not only offer analyses at a single point in time, but also offer features to analyze the memory evolution over time. These features provide more detailed insights into an application's behavior, yet they also make the tools more complex and harder to use.

Memory leaks are a major threat in modern software systems. They occur if objects are unintentionally kept alive longer than necessary and are often indicated by continuously growing data structures.

Evidence has shown that the use of restricted natural languages can reduce ambiguities in textual use case specifications (UCSs). Restricted natural languages often come with specific editors that support particular use case templates and provide enforcement of the language's restrictions. However, whether restriction enforcement facilitates the definition of UCSs as compared to an editor without such support is a fundamental question to answer. To this end, we report results of a controlled experiment in which we compared two approaches for defining restricted UCSs: (i) a specific Restricted Use Case Modeling (RUCM) tool that supports restriction enforcement; and (ii) a general Office Word UCS template without such enforcement. We compared both approaches from multiple perspectives including restriction misuse, understandability, and restrictiveness. Results show that the restriction misuse rates are generally low, which indicates the usefulness of the RUCM, independent of the use of the editors. The results also indicate that the RUCM tool eases the application of more complex restrictions. We also found that the participants profited from extensive training prior to the experiment. The experiment participants further showed their strong willingness to recommend the RUCM tool to others and to use it in the future, which was not the case for the Office Word template.

Software becomes more and more complex. Performance degradations and anomalies can often only be understood by using monitoring approaches, e.g., for tracing the allocations and lifetimes of objects on the heap. However, this leads to huge amounts of data that have to be classified, grouped and visualized in order to be useful for developers. In this paper, we present a flexible offline memory analysis approach that allows classifying heap objects based on arbitrary criteria. A small set of predefined classification criteria such as the type and the allocation site of an object can further be extended by additional user-defined criteria. In contrast to state-of-the-art tools, which group objects based on a single criterion, our approach allows the combination of multiple criteria using multi-level grouping. The resulting classification trees allow a flexible in-depth analysis of the data and a natural hierarchical visualization of the results.

Benchmark suites are an indispensable part of scientific research to compare different approaches against each another. The diversity of benchmarks is an important asset to evaluate novel approaches for effectiveness and weaknesses. In this paper, we describe the memory characteristics and the GC behavior of commonly used Java benchmarks, i.e., the DaCapo benchmark suite, the DaCapo Scala benchmark suite and the SPECjvm2008 benchmark suite. The paper can serve as a useful guide to select benchmarks in accordance with desired application characteristics on modern virtual machines as well as with different compilers and garbage collectors. It also helps to put results that are based on these benchmarks into perspective. Additionally, we compare Java's current default collector to the G1 GC.

State-of-the-art memory monitoring tools collect lots of raw data. Yet, the analysis of this data is often not well supported. Existing tools restrict the user in the way how to analyze the underlying data, how to process it, and how to visualize it. This results in the dilemma that the raw data often contains more information than what can be exploited. We present a novel user-centric approach, allowing custom offline analysis and visualization of memory monitoring data by employing user-defined classification on heap objects. Putting the user in the center of the analysis process and providing flexible query and classification interfaces can change the way how we monitor memory usage. Our goal is to turn special-purpose memory monitoring tools into more general and customizable tools.

Robots are an increasingly discussed solution for assistance of seniors. Importance of testing natural interaction therefore becomes crucial. This paper presents first results of a study with an autonomous mobile social service robot prototype that was deployed in 18 private households of senior adults aged 75 years and older for a total of 371 days. Findings show that utility met the users' expectations. However, the robot was rather seen as a toy instead of being supportive for independent living. Furthermore, despite of an emergency function of the robot, perceived safety did not increase. Reasons for this might be the good health conditions of our users, a lack of technological robustness and slow performance of the prototype. However, users believed that a market ready version of the robot would be vital for supporting people who are more fragile and more socially isolated.