An interactive debugging approach based on time-traveling queries
Une approche de débogage interactive basée sur des Time-traveling queries
Résumé
Debugging is an indispensable part of software development, often consuming a significant amount of time and resources.Efficiently debugging a program requires program comprehension.To acquire it, developers explore the program execution, a task often performed using interactive debuggers.Unfortunately, exploring a program's execution through standard interactive debuggers is a tedious and costly task.We propose Time-traveling Queries (TTQs) to ease interactive program exploration.TTQs is a mechanism that automatically explores program executions using a time-traveling debugger to collect execution data.This mechanism enables a new debugging approach, where the collected data is used to time-travel through execution states, facilitating the exploration of program executions.We built a set of key TTQs based on typical questions developers ask when trying to understand programs.We conducted a user study with 34 participants to evaluate the impact of our queries on program comprehension activities.Results show that, compared to traditional debugging tools, TTQs significantly improve developers' precision while reducing the time and effort required to perform program comprehension tasks, allowing for a more efficient debugging process.While our TTQs-based debugging approach shows promising results in improving interactive debugging problems, it requires a time-traveling debugger to operate.However, debuggers of such kind are not available in all systems.In systems where multiple programs run in shared memory, time-traveling debuggers face the challenge of precisely scoping time-travel operations.This presents a critical difficulty that limits the applicability of time-traveling debuggers to these systems.To investigate this difficulty, we study the essential properties required to apply time-traveling solutions to this type of system.From these properties, we introduced two time-traveling debuggers for Pharo, a shared memory system.We evaluated the importance of these properties through two experiments, demonstrating their significance in performing precise time-traveling operations.Furthermore, we analyze existing solutions to assess their applicability to shared memory systems.
Le debugging est une activité incontournable du développement logiciel.Il s'agit d'une tâche ardue qui nécessite une grande quantité de temps et de ressources, et elle exige que les développeurs aient une compréhension approfondie de leurs programmes. Pour ce faire, les développeurs explorent l'exécution de leurs programmes à l'aide de debuggers interactifs.Cependant, cette activité est souvent répétitive et coûteuse.Afin de simplifier l'exploration interactive des programmes, nous proposons les Time-traveling Queries (TTQs).TTQs est un mécanisme qui explore automatiquement les exécutions de programmes en utilisant un Time-traveling Debugger pour recueillir des données d'exécution.Ce mécanisme permet une nouvelle approche de debugging, où les données collectées permettent de voyager dans le temps à travers les états d'exécution, facilitant ainsi l'exploration des exécutions de programmes.Nous avons élaboré un ensemble de questions clés basées sur des questions typiques que les développeurs se posent lorsqu'ils essaient de comprendre les programmes.Pour évaluer l'impact de nos requêtes sur les activités de compréhension des programmes, nous avons mené une étude empirique impliquant 34 utilisateurs.Nos résultats montrent que, par rapport aux outils de debugging traditionnels, les TTQs améliorent considérablement la précision des développeurs tout en réduisant le temps et les efforts nécessaires pour mener à bien les tâches de compréhension des programmes.Malgré les résultats prometteurs que notre approche a montrés, elle présente une exigence cruciale: elle nécessite l'utilisation d'un Time-traveling Debugger pour être opérationnelle.Cependant, il est important de noter que les debuggers de ce genre ne sont pas disponibles pour tous les systèmes.Dans les systèmes où plusieurs programmes sont exécutés dans une mémoire partagée, les Time-traveling Debuggers se heurtent à la complexité de délimiter les effets en mémoire causés par les opérations de voyage dans le temps.Pour résoudre ce problème, nous avons mené une étude approfondie des propriétés essentielles requises pour adapter les solutions de voyage dans le temps à ce type de système.En utilisant ces propriétés comme guide, nous avons introduit deux Time-traveling Debuggers spécifiquement conçus pour Pharo, un système qui repose sur une mémoire partagée.Nous avons ensuite évalué l'importance de ces propriétés au travers de deux expériences, démontrant ainsi leur rôle crucial dans la réalisation d'opérations précises de voyage dans le temps.Enfin, nous avons procédé à une analyse approfondie des solutions existantes pour évaluer leur applicabilité dans le contexte des systèmes à mémoire partagée.
Origine : Version validée par le jury (STAR)
