ISSTA 2023 Workshops
32nd ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA 2023)
Powered by
Conference Publishing Consulting

1st ACM International Workshop on Future Debugging Techniques (DEBT 2023), July 17, 2023, Seattle, WA, USA

DEBT 2023 – Proceedings

Contents - Abstracts - Authors

1st ACM International Workshop on Future Debugging Techniques (DEBT 2023)

Frontmatter

Title Page


Welcome from the Chairs
Welcome to the DEBT'23: the first Workshop on Future Debugging Techniques colocated with ECOOP 2023, which took place on July 17th, 2023, in Seattle, USA.

DEBT 2023 Organization
Committee listings

Tools and Demonstrations

Symbolic Debugging with Gillian
Nat Karmios ORCID logo, Sacha-Élie AyounORCID logo, and Philippa Gardner ORCID logo
(Imperial College London, UK)
Software debugging for concrete execution enjoys a mature suite of tools, but debugging symbolic execution is still in its infancy. It carries unique challenges, as a single state can lead to multiple branches representing different sets of conditions, and symbolic states must be 'matched' against logical conditions. Some of today’s otherwise mature symbolic-execution tools still rely on plain-text log files for debugging, which provide no good overview of the execution process and can quickly become overwhelming. We introduce a debugger for Gillian’s verification mode---complete with a custom interface---and ponder the potential for this interface and the protocol behind it to be used outside of Gillian.

Publisher's Version
Out-of-Place Debugging on Constraint Devices with the EDWARD Debugger (Demo)
Tom Lauwaerts ORCID logo, Carlos Rojas Castillo ORCID logo, Elisa Gonzalez Boix ORCID logo, and Christophe Scholliers ORCID logo
(Universiteit Gent, Belgium; Vrije Universiteit Brussel, Belgium)
Debugging embedded systems is difficult due to the restricted resources available, and the the difficulty of reproducing bugs. Moreover, few debugging facilities are available for constrained devices. To address these problems, we build upon a recent technique for debugging big data applications, called out-of-place debugging.
An out-of-place debugger captures a remote process and debugs it locally. However, embedded devices include external resources that are not available locally. We therefore developed a novel hybrid out-of-place debugger, which allows a process running on an embedded device to be partially captured, but still receive data and events produced by the hardware. This has the advantage that we can use all the resources of the local machine to implement advanced debugging features, such as back-in-time debugging.
Our demo shows how the EDWARD prototype in VS Code can debug a common hardware issue, and a concurrency bug on an ESP32. We also show how these issues are difficult to find, or even remain hidden, when using logging or classic remote debuggers.

Publisher's Version Video

Work-in-Progress

Program State Visualizer with User-Defined Representation Conversion (WIP)
Rifqi Adlan Apriyadi ORCID logo, Hidehiko MasuharaORCID logo, and Youyou CongORCID logo
(Tokyo Institute of Technology, Japan)
Conventional non-visual tree-based debuggers possess comprehensibility issues, which include the obscurity of object references, patterns, and overall program structure. Visual debuggers — specifically, ones that display an object diagram to represent the program state — alleviate these issues for imperative programming languages whose very states are directly manipulated by the programmer’s statements. However, these debuggers are also prone to clutter when representing large program states from visualizing too much information. Additionally, the visualized program state can often differ from its conceptual abstraction on paper. We propose user-defined representation conversion which allows users to convert concrete representations of program states to their more focused and abstracted conceptual versions. We design a DSL such that users can specify conversions to manipulate displayed nodes and edges based on object types, references, values, or debugger halt locations. We implemented a prototype of this concept for Java.

Publisher's Version

Full Papers

Using Object-Sequence Diagrams for Debugging
Ole Lehrmann Madsen ORCID logo
(Aarhus University, Denmark)
Programming languages in general have mechanisms for describing the structure of a program and computational processes to be generated during program execution. Modeling languages like UML also have such mechanisms. In addition, UML has mechanisms for describing required properties of a system using e.g. objects diagrams, and sequence diagrams, during the design process. In this paper, we propose to include such language mechanisms also for programming with the purpose of observing program executions. We present a combination of sequence diagrams and object diagrams called object sequence diagrams (OSDs). We present an OSD-based debugger that has the same functionality as a traditional debugger, but method invocations are shown in sequence diagrams. The debugger supports showing the history of method invocations and supports debugging at different levels of the program structure, by hiding method invocations within nested modules.

Publisher's Version
Debugging Video Games: A Systematic Mapping
Adrien Vanègue ORCID logo, Valentin Bourcier ORCID logo, Fabio Petrillo ORCID logo, and Steven Costiou ORCID logo
(Inria, France; University of Lille, France; CNRS, France; Centrale Lille, France; UMR 9189 CRIStAL, France; ÉTS, Canada)
The video game industry is a vast and lucrative sector that generates significant revenue. However, a recurring issue within this industry is the release of games with numerous bugs. The process of debugging, a challenging and expensive undertaking in software development, becomes crucial in rectifying these issues. It is worth noting that such bugs can significantly impact the commercial performance of games in the market. Therefore, an imperative arises to foster further academic research that presents dedicated debugging techniques aimed at enhancing the process specifically within the realm of video game development.
In this paper, we employ a systematic mapping study methodology to discern the existing body of knowledge concerning debugging practices for video games. Through a systematic selection process, we selected 21 relevant studies for analysis, enabling the synthesis of data and facilitating the creation of an overview that encapsulates the state of the art on debugging video games. We identified work analyzing challenges of debugging games, proposing bug detection techniques or dedicated debugging tools. However, these work are always bound to specific contexts or kinds of games. Our analysis shows that there is no academic body of knowledge about debugging video games.
Thus, this initial exploration not only raises pertinent questions but also presents prospects for conducting empirical and controlled experiments to enhance our understanding of effective debugging strategies within the context of video game development. We complete our analysis with a discussion of testing and debugging techniques, and how they could help and open new research opportunities for the debugging of video games.

Publisher's Version

proc time: 3.82