Techniques de débogage statique et dynamique pour le langage HipHop.js

Static and dynamic debugging techniques for the HipHop.js language

• Auteur / Autrice : Jayanth Krishnamurthy
• Direction : Manuel Serrano
• Type : Thèse de doctorat
• Discipline(s) : Informatique
• Date : Soutenance le 21/04/2023
• Etablissement(s) : Université Côte d'Azur
• Ecole(s) doctorale(s) : École doctorale Sciences et technologies de l'information et de la communication
• Partenaire(s) de recherche : Laboratoire : Institut national de recherche en informatique et en automatique (France). Unité de recherche (Sophia Antipolis, Alpes-Maritimes)
• Jury : Président / Présidente : Julien Deantoni
• Jury : Examinateurs / Examinatrices : Manuel Serrano, Julien Deantoni, Elisa Gonzalez Boix, Alan Schmitt, Timothy Bourke, Gérard Berry
• Jury : Rapporteurs / Rapporteuses : Elisa Gonzalez Boix, Alan Schmitt

Mots clés

Mots clés contrôlés

Langages de programmation

Temps réel (informatique)

Bogues (informatique)

Débogage

Mots clés libres

Techniques de débogage

HipHop.js

Erreur de causalité

Programmation réactive synchrone

Debugging techniques

HipHop.js

Causality error

Synchronous reactive programming

Résumé

Un grand nombre d’applications informatiques modernes sont interactives, réagissant au stimulus fourni par l’environnement global. HipHop.js est un DSL réactif synchrone inspiré d’Esterel pour JavaScript construit sur Hop.js dédié à la programmation de telles applications. HipHop.js peut être utilisé pour développer des applications telles que les contrôleurs IoT, des interfaces graphiques réactives, etc.Traditionnellement les systèmes réactifs ont été utilisés dans des systèmes critiques car ils apportent des garanties de sécurités au delà de ce que peuvent fournir des langages généralistes. Néanmoins, comme pour les langages classique, un usage systématique et rigoureux de procédures de tests augmentent la confiance qu’un utilisateur peut apporter dans un système réactif. Le débogage est aussi une étape nécessaire si un dysfonctionnement est détecté. Cette thèse se concentre sur le développement d’un environnement dédié pour les programmeurs HipHop.js, facilitant,l’analyse et la mise au point de programmes. Il y a deux principales contributions dans cette thèse. Le premier est le support pour le débogage d’un classe d’erreurs typiques des systèmes réactifs appelées « erreurs de causalité » dans HipHop.js et le second est de fournir une infrastructure aux programmeurs HipHop.js pour étudier et comprendre le comportement de leurs programmes réactifs, identifier ainsi toute subtilité bogues et affiner leur source.HipHop.js suit le modèle de synchronie parfaite introduit dans le langage de programmation Esterel. Ce mémoire de thèse commence par une brève introduction à la programmation réactive à l’aide de HipHop.js afin de rendre accessible la suite du document aux lecteurs peu familiers avec le modèle de la programmation réactive. Ce modèle peut conduire à ce que cette communauté nomme des « cycles d’erreurs de causalité ». Ceux-ci sont généralement difficiles à isoler et à réparer.Dans cette thèse, nous discutons en détail la prise en charge du débogage des erreurs de causalité qui peuvent être détectées à la compilation ainsi que lors de l’exécution. Nous commençons par fournir des exemples expliquant l’origine et la formation des erreurs de causalité et les difficultés rencontrées pour les déboguer. Ensuite, nous présentons les techniques basées sur des algorithmes de graphes permettant de signaliser les erreurs avec des messages précis dirigeant les programmeurs directement vers la source des erreurs. Nous illustrons l’efficacité des méthodes proposées sur un exemple concret.Dans une seconde partie, nous proposons un ensemble d’utilitaires destinés à faciliter la compréhension des comportements « temporels » des programmes HipHop.js et cela, dès les premiers stades du développement. Ces analyseurs de programmes fournissent aux programmeurs HipHop.js des interfaces faciles à utiliser qui permettent de simplifier et d’automatiser l’identification et la localisation des erreurs. Ce manuscrit commence par présenter les analyseurs de programme. Ensuite,des exemples illustratifs expliquant les utilisations des utilitaires et leurs intérêts sont présentés. Les détails des implémentations, y compris les outils et la théorie pertinente, constituent la dernière partie de la thèse sur l’analyseur de programmes.

Many of the modern day computer applications are reactive in nature, continuously reacting to the stimulus from its environment. IoT controllers for orchestration,responsive GUIs, collaborative video games are some of those reactive applications.HipHop.js, a synchronous reactive DSL inspired by Esterel for JavaScript can beused to build reactive applications. The objective of this thesis is to provide supporting infrastructure for building error free reactive applications using HipHop.js.There are two main contributions in this thesis. First one is the support for debugging a special class of errors - causal errors, typical to synchronous reactive systems,and the second one is to provide a software infrastructure for HipHop.js programmers to understand, and test the temporal behavior of their programs, aiding infault localization and improved debugging experience of HipHop.js programs.HipHop.js follows the model of perfect synchrony introduced in the Esterel programming language, and this may lead to classical causality error cycles during execution. These are generally difficult to isolate and to fix. In this thesis, the support for debugging causality errors in compile time and run time is presented in detail. First, illustrative examples explaining the origin and formation of causality errors in HipHop.js and the difficulties faced in debugging them are presented.Then, the techniques based on graph based algorithms that are used to construct better error messages directing programmers to the source of causal errors are presented. The effectiveness of the proposed methods is demonstrated with a realworld example.As a second contribution, a program analyzer with utilities that can be usedto understand the temporal behavior of HipHop.js programs, right from the early stages of program development is presented. The program analyzer aims to provide HipHop.js programmers easy to use interface that can simplify and automate error identification and localization. The presentation in the thesis has introduction to the program analyzer, detailing the motivation behind the various utilities it has.Then, illustrative examples explaining the usage of utilities and their advantages are presented. The implementation details including the tools and relevant theoryis the final part of the thesis on the program analyzer.The thesis also includes a brief introduction to reactive programming using HipHop.js to make the thesis self-contained and also provide a basic introduction to readers from non-reactive background. The illustrative examples on HipHop.js onstructs include control flow visualization for better understanding. The thesis concludes with a review on related literature and future work that can be carried on the infrastructure presented in this thesis.