Dot.Blog

C#, XAML, Xamarin, UWP/Android/iOS

Review : OzCode, le débogue magique !

Déboguer est une tâche difficile, même avec toutes les aides de Visual Studio un peu de renfort peut changer la vie. C’est le cas avec un produit génial que je viens de découvrir : OzCode.

Les difficultés du débogue

Les difficultés sont nombreuses c’est presque là que se situe les plus grandes pertes de temps en développement. Tout va bien, on a codé proprement, on exécute ça passe, et puis ont fait voir à un collègue ou à son chef, et la le premier exemple qu’on prend ça plante ! Un classique. Mais en dehors de l’anecdote le débogue est une activité plutôt prenante, aucun code n’est exempt de bogues et trouver les plus gênants fait intégralement parti du boulot du développeur.

J’ai connu la grande époque des compilateurs en ligne de commande qui après un quart d’heure vous affichait un truc du genre “error 257. line 452”. Et puis c’est tout… Et même parfois rien quand c’était à l’exécution, ça s’arrêtait et revenait à la ligne de commande sans explication. Il fallait se débrouiller avec ça, faire des tests, reperdre du temps à compiler et la boucle recommençait…

Heureusement avec l’avènement d’EDI comme Visual Studio le débogue est devenu plus facile, temps réel. On peut mettre des points d’arrêt, inspecter des variables, mesurer les fuites mémoire, le temps passé dans telle ou telle autre partie du code, etc. Les dernières avancées permettent d’examiner en temps réel l’arbre visuel des applications WFP ou UWP ce qui généralise le concept de débogue même à la partie UI.

Bonheur parfait ?

Pas tout à fait… Les zones d’ombres sont encore nombreuses et l’aspect pratique est encore que trop peu pris en compte.

OzCode

C’est là qu’intervient OzCode.

Il s’installe dans Visual Studio comme tout module externe (Resharper par exemple), offre un menu dédié et des tas de fonctions incroyables…

Le mieux est de voir quelles sont ces fonctions de débogue qui nous sont offertes.

Je vous préviens immédiatement tout cela se comprend beaucoup mieux en action, il est donc nécessaire de regarder les vidéos proposées par OzCode pour se rendre compte de l’incroyable confort apporté et du fonctionnement même de ces fonctions.

La liste ci-dessous sert ainsi d’introduction mais je vous donnerai plus loin les URL à consulter.

Révéler

Quand on met un point d’arrêt dans le code on peut en survolant avec la souris voir le contenu des variables. C’est absolument indispensable et c’est une avancée énorme. Mais hélas on voit tout le contenu de la variable. Si c’est un entier c’est bon, si c’est une classe assez riche ça devient moins évident de repérer les infos dont on a besoin pour le débogue. Si c’est une liste c’est pire encore, il faut descendre dans les fenêtres de débogue pour arriver à l’info qu’on cherche.

Je vous parlais dernièrement d’un attribut de débogue qui permet d’indiquer les infos à afficher en premier sur une classe lors du débogue. C’est super mais il faut ajouter l’attribut à toutes les classes et prévoir ce qui sera pertinent. Or il y a fort à parier qu’en cas de bogue on ait en réalité besoin de voir un autre champ que ceux qu’on a placé dans l’attribut…

C’est là que OzCode et sa fonction “révéler” entre en scène. Dans la fenêtre de débogue affichant le contenu d’une classe on trouve une petite étoile devant chaque champ. Si on l’active ce champ joue le même rôle que si on l’avait placé dans l’attribut. L’avantage est qu’on ne le fait qu’une fois pour une classe dans une session de débogue et qu’on peut changer les champs “prioritaires” comme on le veut.

image

Ici le champ “FistName” a été coché (petite étoile jaune) et au lieu du nom complet de la classe c’est la valeur de ce champ qui est indiqué en première ligne. On peut ajouter autant de champs qu’on le souhaite, en changer, etc.

Et cela reste valable tout le temps. Si on en vient à inspecter plus tard une liste de “customer”, automatiquement cette liste donnera en résumé les champs sélectionnés de la classe :

image

La fonction est même encore un peu mieux que ça mais vous aurez le détail dans les vidéos et la doc indiquées plus bas dans cet article.

C’est vraiment une option hyper pratique qui fait gagner beaucoup de temps. Mais c’est loin d’être la seule qu’offre OzCode !

Chercher

Lorsqu’on débogue on cherche souvent à voir la valeur d’une propriété particulière ou d’un champ à l’intérieur d’une propriété. Mais quand on a des listes entières, des objets complexes, chercher ses valeurs que Visual Studio affiche devient très long, et souvent cela fait même perdre le fil du raisonnement qu’on était en train de mener pour pister le bogue…

La fonction chercher de OzCode s’intègre aux fenêtres de débogue. Dans la capture plus haut on voit la ligne en bas “search”. Automatiquement OzCode va placer en surbrillance les correspondances. L’œil trouvera immédiatement ce qu’il cherche, et le cerveau lui ne sera pas freiner dans ses cogitations pour pister le bogue !

Cela n’a rien de fantastique, le Ctrl-F est un classique avec le Ctrl-C, mais il s’avère que cela n’existe pas dans les fenêtres de débogue et c’est bien dommage. Enfin ça n’existe pas si on n’utilise pas OzCode.

Voir toutes les instances

Placer un point d’arrêt et regarder les variables présentes dans la méthode autour de celui-ci est une chose. Mais souvent on aimerait bien voir le contenu d’autre éléments d’une même classe. Pour vérifier ce qu’elles contiennent ou par exemple pour s’assurer de leur nombre (un singleton doit être unique ou si on a créé 5 objets bien précis il ne doit pas y en avoir 6 en mémoire, et si tel est le cas quel est le contenu de ces instances, etc, etc).

Or Visual Studio ne permet pas vraiment ce zoom spécifique sur toutes les instances d’une même classe. OzCode le peut.

Il le fait avec pas mal d’options très subtiles, le tout en conservant les avantages des autres mécanismes déjà vu plus haut. Il faut vraiment voir la vidéo de présentation c’est nettement plus évident et l’effet Wow est garanti !

Break point conditionnels

Vous allez me dire, ça ça existe ! Oui c’est vrai, mais placer un point d’arrêt conditionnel n’est pas toujours évident.

OzCode permet en un clic de placer un point d’arrêt conditionnel sur le test d’une valeur et pré-remplit même la condition en fonction du contexte. L’affaire est jouée, vite et bien.

Là encore, et je parle par expérience, le débogue ce n’est pas une balade en forêt. On ne flâne pas en s’extasiant sur une valeur au hasard comme on se plait à capter l’envol d’un faisan entre deux buissons… Quand on débogue c’est qu’on a le stress qui monte un peu ou beaucoup selon les circonstances, on a l’impression, toujours, que déboguer c’est perdre du temps que ça empêche d’avancer, on veut aller vite pour continuer à coder. Au fur et à mesure qu’on s’enfonce dans le débogue on échafaude des idées, on bâti des hypothèses qu’il faut valider ou invalider le plus vite possible. Tout ce qui ralentit ou gêne cette démarche peut faire perdre le fil, peut interdire de trouver ce qu’on cherche.

Toutes les aides apportées par OzCode effacent ces moments plus ou moins longs et gênants pour libérer l’esprit et trouver ce fichu bogue le plus vite possible. C’est vraiment un produit dont j’aurai du mal à me passer désormais.

Les exceptions

Travailler dans un environnement qui sait retourner des exceptions et une pile d’appel c’est vraiment un confort incroyable. Mais naviguer dans des exceptions chainées (exceptions internes) dans les grandes piles d’appel encore une fois cela peut devenir très rapidement une perte de temps qui fait dévier ce qu’on est venu faire : tuer un bogue, pas se balader dans la mémoire de l’appli…

OzCode offre des fonctions de recherche et de navigation dans les exceptions qui permettent réellement d’en tirer les informations essentielles le plus vite possible. Cela évite aussi de passer à côté de l’info qui aurait permis de trouver le bogue un heure avant…

Là encore il faut regarder la vidéo c’est nettement plus parlant.

When Set…Break

Il arrive souvent quand on débogue qu’on se demande “mais d’où provient la valeur de cette propriété ?”. C’est vrai ça, qui a changé en douce ce 42 en 75 ? On a beau pister, forcément on ne trouve pas puisqu’on suit la logique qu’on croit être celle du programme. Mais si ça bogue c’est que ça ne passe pas exactement par là où on croit… Le débogue c’est l’art de la pensée parallèle, savoir changer sa caméra de place pour filmer la scène et découvrir ce qui était caché. Il y a un savoir-faire indéniable qui vient aussi beaucoup de l’expérience. Mais dans tous les cas Visual Studio ne vous dira pas qui a modifié la variable en question… OzCode oui.

Demandez-lui de faire un break dès que telle propriété ou champ est modifié, et vous découvrirez surement qu’un test que vous croyiez vrai ne l’était pas et qu’une lointaine méthode vient changer la valeur de l’objet… On découvre parfois à ces occasions des circuits de promenade qu’on n’imaginait pas… C’est encore plus vrai en multi-threading ou avec de l’asynchrone.

Bis repetita la vidéo vous montrera cela très bien, mieux qu’un discours plus long.

Filtrer les collections

Filtrer le contenu d’une collection est super facile par code notamment grâce à Linq par exemple. Mais en débogue c’est une autre paire de manches ! Visual Studio ne le permet pas.

Et pourtant n’afficher que les lignes dont le champ “total” est égal à zéro parmi les 1230 enregistrements remontés par une requête serait certainement plus rentable que de scroller des heures dans les petites fenêtres de débogue et certainement moins dangereux que de bricoler le code lui-même pour afficher dans la fenêtre de sortie les éléments en question…

OzCode permet de le faire facilement. Et c’est vraiment une aide qui fait gagner un temps fou.

On peut saisir des expressions complexes pour créer le filtre, modifier tout cela comme on le veut, bref c’est le paradis au lieu de l’enfer.

Hmm dois-je préciser qu’en regardant la vidéo c’est encore plus parlant ?

Tracer

Un bon développement fait usage d’une librairie de gestion des traces. Sans trace difficile de comprendre le bogue intervenu chez un utilisateur. Mais même devant Visual Studio en session de débogue et même avec un système de trace on est souvent coincé car il n’est pas possible de tout tracer, toutes les entrées ou sorties de méthodes, toutes les propriétés de tous les objets, cela serait infernal.

Et il ne s’agit certainement pas de le faire, on se retrouverait avec tellement d’informations à traiter qu’on serait paralysé dans la tâche de débogue.

De façon plus intelligente OzCode permet de demander la trace d’un objet, d’une valeur. A la volée. Et on obtient une fenêtre de traces immédiatement exploitable. On arrête, on reprend, on trace autre chose, en même temps ou pas, c’est certainement l’une des aides les plus précieuses.

Oui oui, il y a une vidéo qui démontre ça aussi.

La vue magique

C’est vrai que c’est magique (en regardant la vidéo vous le verrez mieux). Il s’agit là d’afficher des informations directement dans le code source, des infos comme par exemple la valeur de retour d’une méthode, la valeur des variables à l’entrée.

image

C’est vraiment ultra pratique, il faut le voir et surtout l’essayer (il y a une version d’essai 30 jours), d’autant que c’est un poil plus subtil que le résumé que j’en fait ici.

Prévoir l’avenir

Avoir une vision magique comme superman qui passe à travers les murs qui rendre Visual Studio aveugle c’est déjà très fort, mais avoir le don de double vue c’est encore plus incroyable !

OzCode propose de prévoir l’avenir…

Avec cette option en mode débogue OzCode prévoit quel code va être exécuté et il baisse l’intensité visuelle du code qui ne le sera pas. On a tout de suite un code plus facile à lire et plus facile à comprendre puisque cette vision est prédictive. Pour pister un bogue avoir un temps d’avance sur lui est un précieux atout !

Le plus drôle vous ne devinerez jamais : il y a une vidéo qui montre tout ça ! Si, c’est incroyable.

Expressions personnalisées

On débogue, on débogue, on affiche des valeurs, on les compare (OzCode sait comparer deux instances et montrer les différences), on prévoit l’avenir, oui mais… Pour rechercher un bogue précis il est souvent intéressant d’avoir des valeurs “synthétiques” pour que l’œil puisse réagir plus vite à une situation anormale. Un exemple très simple, un objet d’opération comptable stockant la valeur d’une facture et son règlement. Comparer des tas d’instances devient vite difficile si on cherche uniquement la facture où il y a un écart d’exactement 23 centimes entre le montant TTC et son règlement…Surtout si les collections sont grandes.

Dans des cas comme celui-là (et d’autres plus complexes en réalité) on a tendance à modifier carrément le code de la classe pour créer une propriété qui affiche la différence en espérant que cela permettra de mieux voir la ligne qu’on recherche.

Mais il y a plus facile et moins risqué que de bricoler le code : demander à OzCode d’afficher la valeur d’une expression librement saisie comme s’il s’agissait d’un champ ou d’une propriété de la classe…

En mixant cette possibilité avec les autres (comme les filtres sur les collections par exemple), trouver en quelques secondes ce qui ne va pas dans un code est autrement plus facile.

Au cas où vous ne l’auriez pas déjà deviné, et oui, il existe une vidéo qui présente cette fonction !

Exporter des instances

C’est un peu la cerise sur le gâteau. En plein débogue vous tombez sur une configuration d’objets particulière qui fait planter le programme. C’est une sorte de cas d’école. Il serait intéressant de pouvoir “figer la scène” de mémoriser tout cela pour par exemple s’en servir comme valeurs dans des tests unitaires. Ou bien pour tout autre analyse d’ailleurs.

OzCode permet à tout moment de choisir des objets et de les exporter avec leurs valeurs, en code C#, en JSON ou en XML…

il devient très simple de reprendre un contexte donné en réhydratant des classes à l’aide de cette sauvegarde ce qui permettra d’étudier plus en profondeur et autant de fois qu’on le voudra la situation problématique. Et toujours en repartant de la même situation de départ bien particulière.

On ne fait pas ça tous les jours, mais c’est assurément une astuce très utile dans certains cas.

Passons à la dernière fonction, le déboque de Linq.

Mais non je n’ai pas oublié, il y a bien sûr une vidéo qui montre tout ça !

Déboguer Linq

J’adore Linq. Programmer avec un langage qui n’a pas un équivalent est une souffrance, vraiment. Mais parfois Linq complique le débogue, il est difficile d’inspecter ce qui se passe dans ses entrailles, de suivre une valeur et ses changements comme on le ferait dans une boucle classique.

C’est même tellement difficile que c’est impossible ou presque . Et ça se termine souvent par une réécriture sous forme de boucle d’ailleurs… A conditions que l’expression Linq soit très simple sinon on est cuit…

On touche là encore à de l’impalpable que les mots ne rendent pas fidèlement, la documentation et les vidéos vous permettront de voir en fonctionnement cette option et cela vous en dira beaucoup plus.

image

D’autres choses

OzCode permet d’autres choses bien utiles comme la comparaison d’instances que j’ai évoquée rapidement plus haut. Ces petites fonctions peuvent devenir de grandes alliées lorsqu’il s’agit de trouver un bogue alors que le client passe dans une heure et que “ça marchait avant” … mais que ça ne marche plus…

Conclusion

Le débogue est un sport, une chasse. Beaucoup le vivent comme une punition comme si un code devait fonctionner du premier coup. Le débogue fait partie intégrante du développement. Certes on le vit souvent comme une perte de temps, mais en réalité c’est ça développer…

Toutefois aucune raison d’être maso, s’il existe des moyens techniques pour accélérer le débogue autant s’en servir. Faire la vaisselle fait partie intégrante de l’action de manger… Mais si on a un lave-vaisselle on n’a aucune raison de faire ça à la main… Pour le débogue c’est pareil.

Maintenant que vous savez que OzCode existe, à vous de choisir si vous allez continuer à faire la vaisselle à la main ! Sourire

La doc, les vidéo ? Vous faites bien de me le rappeler :

Les vidéos sur les fonctions de OzCodes

La documentation de OzCode

Les programmes exemples OzCode sur GitHub

OzCode coute $79 pour un développeur. Il y a des licences corporate avec des remises et les licences sites pour les équipes de plus 50 personnes.

Le produit est utilisé par des sociétés comme Dell, At&t, Intel, Lockheed Martin, Siemens… Et je comprends qu’ils aient été séduits.

A vous de voir maintenant !

Stay Tuned !

blog comments powered by Disqus