DEBT '23: "Program State Visualizer with ..."
Program State Visualizer with User-Defined Representation Conversion (WIP)
Rifqi Adlan Apriyadi, Hidehiko Masuhara, and Youyou Cong
(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.
@InProceedings{DEBT23p5,
author = {Rifqi Adlan Apriyadi and Hidehiko Masuhara and Youyou Cong},
title = {Program State Visualizer with User-Defined Representation Conversion (WIP)},
booktitle = {Proc.\ DEBT},
publisher = {ACM},
pages = {5--10},
doi = {10.1145/3605155.3605863},
year = {2023},
}
Publisher's Version
DEBT '23: "Symbolic Debugging with Gillian ..."
Symbolic Debugging with Gillian
Nat Karmios, Sacha-Élie Ayoun, and Philippa Gardner
(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.
@InProceedings{DEBT23p1,
author = {Nat Karmios and Sacha-Élie Ayoun and Philippa Gardner},
title = {Symbolic Debugging with Gillian},
booktitle = {Proc.\ DEBT},
publisher = {ACM},
pages = {1--2},
doi = {10.1145/3605155.3605861},
year = {2023},
}
Publisher's Version
DEBT '23: "Debugging Video Games: A Systematic ..."
Debugging Video Games: A Systematic Mapping
Adrien Vanègue, Valentin Bourcier, Fabio Petrillo, and Steven Costiou
(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.
@InProceedings{DEBT23p23,
author = {Adrien Vanègue and Valentin Bourcier and Fabio Petrillo and Steven Costiou},
title = {Debugging Video Games: A Systematic Mapping},
booktitle = {Proc.\ DEBT},
publisher = {ACM},
pages = {23--30},
doi = {10.1145/3605155.3605865},
year = {2023},
}
Publisher's Version
DEBT '23: "Program State Visualizer with ..."
Program State Visualizer with User-Defined Representation Conversion (WIP)
Rifqi Adlan Apriyadi, Hidehiko Masuhara, and Youyou Cong
(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.
@InProceedings{DEBT23p5,
author = {Rifqi Adlan Apriyadi and Hidehiko Masuhara and Youyou Cong},
title = {Program State Visualizer with User-Defined Representation Conversion (WIP)},
booktitle = {Proc.\ DEBT},
publisher = {ACM},
pages = {5--10},
doi = {10.1145/3605155.3605863},
year = {2023},
}
Publisher's Version
DEBT '23: "Debugging Video Games: A Systematic ..."
Debugging Video Games: A Systematic Mapping
Adrien Vanègue, Valentin Bourcier, Fabio Petrillo, and Steven Costiou
(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.
@InProceedings{DEBT23p23,
author = {Adrien Vanègue and Valentin Bourcier and Fabio Petrillo and Steven Costiou},
title = {Debugging Video Games: A Systematic Mapping},
booktitle = {Proc.\ DEBT},
publisher = {ACM},
pages = {23--30},
doi = {10.1145/3605155.3605865},
year = {2023},
}
Publisher's Version
DEBT '23: "Symbolic Debugging with Gillian ..."
Symbolic Debugging with Gillian
Nat Karmios, Sacha-Élie Ayoun, and Philippa Gardner
(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.
@InProceedings{DEBT23p1,
author = {Nat Karmios and Sacha-Élie Ayoun and Philippa Gardner},
title = {Symbolic Debugging with Gillian},
booktitle = {Proc.\ DEBT},
publisher = {ACM},
pages = {1--2},
doi = {10.1145/3605155.3605861},
year = {2023},
}
Publisher's Version
DEBT '23: "Out-of-Place Debugging on ..."
Out-of-Place Debugging on Constraint Devices with the EDWARD Debugger (Demo)
Tom Lauwaerts, Carlos Rojas Castillo, Elisa Gonzalez Boix, and Christophe Scholliers
(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.
@InProceedings{DEBT23p3,
author = {Tom Lauwaerts and Carlos Rojas Castillo and Elisa Gonzalez Boix and Christophe Scholliers},
title = {Out-of-Place Debugging on Constraint Devices with the EDWARD Debugger (Demo)},
booktitle = {Proc.\ DEBT},
publisher = {ACM},
pages = {3--4},
doi = {10.1145/3605155.3605862},
year = {2023},
}
Publisher's Version
Video
DEBT '23: "Symbolic Debugging with Gillian ..."
Symbolic Debugging with Gillian
Nat Karmios, Sacha-Élie Ayoun, and Philippa Gardner
(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.
@InProceedings{DEBT23p1,
author = {Nat Karmios and Sacha-Élie Ayoun and Philippa Gardner},
title = {Symbolic Debugging with Gillian},
booktitle = {Proc.\ DEBT},
publisher = {ACM},
pages = {1--2},
doi = {10.1145/3605155.3605861},
year = {2023},
}
Publisher's Version
DEBT '23: "Out-of-Place Debugging on ..."
Out-of-Place Debugging on Constraint Devices with the EDWARD Debugger (Demo)
Tom Lauwaerts, Carlos Rojas Castillo, Elisa Gonzalez Boix, and Christophe Scholliers
(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.
@InProceedings{DEBT23p3,
author = {Tom Lauwaerts and Carlos Rojas Castillo and Elisa Gonzalez Boix and Christophe Scholliers},
title = {Out-of-Place Debugging on Constraint Devices with the EDWARD Debugger (Demo)},
booktitle = {Proc.\ DEBT},
publisher = {ACM},
pages = {3--4},
doi = {10.1145/3605155.3605862},
year = {2023},
}
Publisher's Version
Video
DEBT '23: "Using Object-Sequence Diagrams ..."
Using Object-Sequence Diagrams for Debugging
Ole Lehrmann Madsen
(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.
@InProceedings{DEBT23p11,
author = {Ole Lehrmann Madsen},
title = {Using Object-Sequence Diagrams for Debugging},
booktitle = {Proc.\ DEBT},
publisher = {ACM},
pages = {11--22},
doi = {10.1145/3605155.3605864},
year = {2023},
}
Publisher's Version
DEBT '23: "Program State Visualizer with ..."
Program State Visualizer with User-Defined Representation Conversion (WIP)
Rifqi Adlan Apriyadi, Hidehiko Masuhara, and Youyou Cong
(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.
@InProceedings{DEBT23p5,
author = {Rifqi Adlan Apriyadi and Hidehiko Masuhara and Youyou Cong},
title = {Program State Visualizer with User-Defined Representation Conversion (WIP)},
booktitle = {Proc.\ DEBT},
publisher = {ACM},
pages = {5--10},
doi = {10.1145/3605155.3605863},
year = {2023},
}
Publisher's Version
DEBT '23: "Debugging Video Games: A Systematic ..."
Debugging Video Games: A Systematic Mapping
Adrien Vanègue, Valentin Bourcier, Fabio Petrillo, and Steven Costiou
(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.
@InProceedings{DEBT23p23,
author = {Adrien Vanègue and Valentin Bourcier and Fabio Petrillo and Steven Costiou},
title = {Debugging Video Games: A Systematic Mapping},
booktitle = {Proc.\ DEBT},
publisher = {ACM},
pages = {23--30},
doi = {10.1145/3605155.3605865},
year = {2023},
}
Publisher's Version
DEBT '23: "Out-of-Place Debugging on ..."
Out-of-Place Debugging on Constraint Devices with the EDWARD Debugger (Demo)
Tom Lauwaerts, Carlos Rojas Castillo, Elisa Gonzalez Boix, and Christophe Scholliers
(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.
@InProceedings{DEBT23p3,
author = {Tom Lauwaerts and Carlos Rojas Castillo and Elisa Gonzalez Boix and Christophe Scholliers},
title = {Out-of-Place Debugging on Constraint Devices with the EDWARD Debugger (Demo)},
booktitle = {Proc.\ DEBT},
publisher = {ACM},
pages = {3--4},
doi = {10.1145/3605155.3605862},
year = {2023},
}
Publisher's Version
Video
DEBT '23: "Out-of-Place Debugging on ..."
Out-of-Place Debugging on Constraint Devices with the EDWARD Debugger (Demo)
Tom Lauwaerts, Carlos Rojas Castillo, Elisa Gonzalez Boix, and Christophe Scholliers
(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.
@InProceedings{DEBT23p3,
author = {Tom Lauwaerts and Carlos Rojas Castillo and Elisa Gonzalez Boix and Christophe Scholliers},
title = {Out-of-Place Debugging on Constraint Devices with the EDWARD Debugger (Demo)},
booktitle = {Proc.\ DEBT},
publisher = {ACM},
pages = {3--4},
doi = {10.1145/3605155.3605862},
year = {2023},
}
Publisher's Version
Video
DEBT '23: "Debugging Video Games: A Systematic ..."
Debugging Video Games: A Systematic Mapping
Adrien Vanègue, Valentin Bourcier, Fabio Petrillo, and Steven Costiou
(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.
@InProceedings{DEBT23p23,
author = {Adrien Vanègue and Valentin Bourcier and Fabio Petrillo and Steven Costiou},
title = {Debugging Video Games: A Systematic Mapping},
booktitle = {Proc.\ DEBT},
publisher = {ACM},
pages = {23--30},
doi = {10.1145/3605155.3605865},
year = {2023},
}
Publisher's Version