Implémenter la capture de pierres au Go

Session du 19 juillet 2022 à 20h00

Pratique & Live Coding

Bases du Langage

DevOps & Environnement

Deviens membre Premium

Cette session de mentorat est réservée aux membres Premium. Rejoignez-nous pour accéder à toutes les rediffusions des sessions de mentorat !

Premium

+100h de formations
+180 exercices de code
+100h de mentorats en rediffusion
20 projets
Mentorats groupés hebdomadaires
Support individuel avec nos mentors

Découvrir les formules

Voir le détail des fonctionnalités

Implémenter la capture de pierres au Go

Deuxième partie de la session de « live coding » de Lionel à propos du projet de jeu de Go.

Vous pouvez retrouver le projet avec les détails sur ce dépôt Git:
https://github.com/DocstringFr/2022-Mentorat-yoyonel-Goban/wiki

Rechercher dans la transcription

00:00:00 :Ok, vous m'entendez tous? Toujours ce petit doute au départ.Ok, cool. Du coup j'ai lancé 5 minutes en avance pour lancer le signal et permettre

00:01:11 :aux gens de venir. Donc on va attendre tranquillou le début de la session.J'ai eu l'occasion de regarder un peu le GitHub que j'ai fait pour le projet. Je vous

00:01:37 :le mets dans le chat au cas où. Normalement il y a Thibaut qui a communiqué dessus sur Rocket et sur Discord il me semble. Du coup j'ai versionné ce qu'on avait commencé

00:01:50 :à faire, le projet Python. J'ai utilisé un espace, enfin le repo GitHub de Docstring,donc de Thibaut pour placer le projet. Donc là que j'ai nommé 2022 mentorat Johan Elkoban.

00:02:08 :Je suis très fort en nommage. D'ailleurs on va attendre que tout le monde arrive, je vais faire un petit tour des lieux de cet espace de stockage pour vous présenter un peu à quoi ça sert, comment l'utiliser. Ça peut être intéressant.

00:02:30 :Mon chat qui a tiré un... Qu'est-ce qu'il a petit chaton? Tu veux faire du mentoring ? Le chat coding? On te rappelle qu'on fera un bot Discord, un chat Discord.

00:03:03 :Est-ce qu'il y a des activités? Il me semblerait que non. On va attendre encore un peu.Donc ça va être le bot qui avance le début. Bonsoir. Ah, monsieur Romain. Il me semble

00:03:39 :que c'était toi qui a pas mal travaillé avec, tu avais fait des soumissions. Bon, un instant, je vais sortir mon chat.Voilà, en fait j'avais coupé le son et il disparaît dans le fond. Donc je parlais

00:05:36 :de la question de Yannick, est-ce qu'on peut lier ce projet GitHub à notre compte GitHub pour le retrouver plus vite par la suite? Donc du coup, ce qui t'intéresse là dans

00:05:45 :ce cas-là, c'est l'option stars, qui est l'équivalent des favoris dans les pages web, qui permet de mettre en favoris un projet GitHub. Donc après, dans ta liste, je ne

00:05:56 :sais plus où on récupère les favoris, your stars, moi j'en avais pas mal, mais là apparemment il est apparu, parce que c'est le dernier que j'ai staré. Bon du coup je vais essayer

00:06:07 :de déstarer quand même. Tiens c'est marrant, il garde le... Ah du coup il y a quelqu'un d'autre qui a dû faire un star déjà. Alors Thibaut qu'est-ce qu'il nous dit? Oui,

00:06:19 :je pense. Ok. Est-ce que tout le monde m'entend et voit mon écran? Ok cool, c'est juste pour être sûr, je ne veux pas partir dans un monologue, ou si je ne sers pas l'écran ce serait dommage. Ok, du coup on va commencer la session mentor. Donc l'idée c'est de

00:06:47 :reprendre ce qu'on avait fait fin juin, il me semble, 28 juin, qui était de travailler sur un exercice d'open classroom sur un Goban, donc c'est le jeu de Goban, non le jeu de Go pardon, et du coup le Goban c'est le plateau du jeu de Go et on place des pierres sur le

00:07:05 :plateau et bon, il y a des contraintes de jeu etc. L'exercice open classroom c'était,ça se focalisait sur une règle et la règle de capture, donc de savoir si une pierre,donc il y a deux types de pierres, pierre blanche et pierre noire, et une pierre est capturée si elle ne possède aucun déplacement possible, donc en gros toutes ses positions

00:07:26 :adjacentes directes, donc haut, bas, gauche, droite, sont bloquées par une autre pierre ou en particulier par une pierre opposée à la sienne. Et après on parle de forme prise

00:07:40 :en entourant toutes les positions qui forment la forme, donc par exemple une forme blanche peut être une continuité de pierres blanches qui font une continuité adjacente, donc haut,bas, gauche, droite, et si toutes ces pierres qui constituent la forme n'ont pas de degré de liberté, donc entourées par des pierres opposées, dans le cas des pierres blanches

00:08:03 :c'était des pierres noires, donc on dit que la forme est prise. Donc la condition de capture de la forme c'est que toutes les pierres qui composent la forme sont prises.

00:08:13 :Du coup on avait commencé à développer en live coding la fonctionnalité, donc on avait un projet, on peut le revoir, qui est ici, donc avec un GoBand PY en point d'entrée,ça c'est ce qui est fourni par, ressources fournies par Open Classroom, et il nous demande d'implémenter cette méthode, isTaken, qui par rapport à une position x, y, et par rapport

00:08:43 :à un plateau qu'on a passé en initialisation, on doit déterminer si c'est pris ou pas pris,donc la définition que j'ai dit au préalable. Il passe aussi un test GoBand, donc c'est

00:08:56 :une ressource fournie par Open Classroom qui fait des suites de tests unitaires, donc avec le nom du test, enfin test underscore, donc ça c'est la notation, le préfixage pour que ça soit reconnu comme un test, et après une description dans le nom, qui teste différents cas, et par rapport à ce qu'on avait codé, on avait fait dans Solus

00:09:19 :Mentora, on avait fait une classe qui hérite de GoBand, qui est notre classe de départ ici, et du coup on implémente notre solution dans cet objet dérivé, ou cette classe dérivée de GoBand, et on avait commencé à développer isTaken, qui prend deux positions int et qui envoie un bool, donc c'est pris ou pas pris, et voilà. On n'avait pas été jusqu'au

00:09:45 :bout, on avait fait qu'une partie de l'implémentation, donc il y avait un test qui échouait, donc c'est ce test là, black shape is not taken, donc en gros, black shape is not taken, en gros là c'est la forme noire ici, et du coup la requête, par exemple quand on fait une

00:10:07 :requête ici, isTaken c'est vrai, parce que tout autour c'est pris par des pierres, si on fait la requête sur lui c'est vrai aussi, elle est taken, parce que tout autour c'est pris par des pierres, par contre si on fait la requête sur lui, là il y a un degré de

00:10:22 :liberté ici, juste à sa droite, donc comme une des pièces de la forme noire a un degré de liberté, alors toute la forme noire est libre. Donc comme on n'a pas fait, on n'a

00:10:35 :pas implémenté la solution récursive ou autre, enfin la solution qui fait cette considération de formes plus complexe, ou de plusieurs éléments dans une forme, c'est normal qu'on ne passe pas le test. Ok, je regarde vite fait s'il y a des gens qui se manifestent quelque part,

00:10:53 :je ne vois rien, ok, on va dire que c'est bon, requête il dit quoi? Il ne dit pas grand chose, ok, on va dire qu'on est bon. Du coup, il y avait cette première implémentation,

00:11:05 :on avait vu un peu une approche, ce qu'on appelle TDD, où j'écris le code, enfin les tests sont écrits, et du coup on écrit le code pour faire avancer dans les tests,d'ailleurs on peut le lancer. Actuellement tout passe parce qu'il y a cette commande

00:11:20 :magique, enfin magique, depuis test, ça a un marqueur, et on dit que ce test doit échouer,parce qu'on n'a pas fait le code. Du coup j'ai fait ça parce que j'avais monté une

00:11:31 :CI sur le projet et je n'aime pas avoir un projet, en quoique j'aurais pu le laisser en rouge, mais grosso modo cette ligne dit que c'est normal, XFail, en gros ça dit que le test qui suit va fail et je lui donne une raison, donc la récursivité n'est pas encore

00:11:46 :implémentée. Donc là quand on voit ici, on voit que ça XFail, donc ça fail, la récursivité n'est pas encore implémentée, et là il dit que oui en effet ça ne marche pas, mais comme on l'a préfixé avec un décorateur, ah oui, ok, je vous montre juste après.

00:12:05 :CI c'est Continuous Integration, c'est un procédé qui permet de lancer les tests automatiquement là où on stocke le projet. Je vais vous montrer dans deux secondes. Donc du coup là

00:12:20 :je finis là dessus avec le XFail, en gros ça dit ok ce test je sais qu'il ne marche pas, parce que de toute façon je n'ai pas fait l'implémentation, donc je sais qu'il va échouer, et là en préfixant ici, je dis qu'à pittest que c'est normal qu'il ne fonctionne

00:12:34 :pas, et pour l'instant on fait comme s'il n'y avait rien. Du coup là c'est par mon comment ou on l'enlève, le XFail, on va le faire d'ailleurs, le but de ce sort c'est de passer ce test, donc là il fait une vraie erreur, il dit j'attendais false et j'ai eu

00:12:53 :vrai, et il attendait 63, donc ligne 63. Donc dès le premier test qui est normal, en 01,donc 01 c'est cette pièce, donc là par rapport à notre implémentation il regarde les positions adjacentes, donc elles sont toutes prises, donc ça renvoie vrai, if taken elle est prise,sauf que par rapport à ce qu'on a dit tout à l'heure, il y a la position juste à côté

00:13:23 :qui appartient aussi à la forme, elle est libre, donc la forme est libre, donc chacune des pièces de la forme est libre. Donc on plante directement au premier test.

00:13:32 :Donc du coup il y avait ce repo, qui était juste en local sur ma machine, donc après j'ai vu avec Thibault ce que je vous disais pour ce qu'on appelle le versionner, c'est quand on va mettre le stocker sur un serveur distant, en général on peut stocker aussi en local en versionnant, mais d'ailleurs en fait tout le temps, enfin souvent, voire

00:13:56 :tout le temps on le fait parce que d'abord on fait un git en local, donc à l'intérieur de notre structure, de notre répertoire. On peut voir, non je suis dans le bug là,

00:14:07 :on peut voir ici, non il faut, parce que c'est un répertoire caché, c'est ce répertoire-là git ici. En gros c'est là-dedans qu'il y a le projet versionné, ou une représentation

00:14:21 :du versionnement du projet. Bonjour, je suis nouveau, j'aimerais savoir s'il y a des mentorats par niveau. Bonjour Gaël, du coup sur l'annonce, donc la question c'est, Gaël voudrait savoir

00:14:36 :s'il y a des mentorats par niveau. Pour l'instant non, si j'en avais parlé avec Thibault, il me disait il attend peut-être la rentrée quand il y aura plus de participants, d'étudiants pour justement faire des annonces de mentorats par niveau etc. Pour l'instant comme on est

00:14:55 :assez peu, il fusionne tout le monde et il essaye dans l'annonce du mentorat de donner des indications sur ce qu'on va aborder, et souvent ça donne des indications sur le niveau de ce qu'on va aborder. Est-ce que oui, non, ça devrait être jouable. J'aurais peut-être

00:15:18 :dû le faire en settings global, juste un instant. J'aurais dû le faire avant. Bon,je peux le faire à la main pour chaque fichier, c'est pas grave. Ok, bon j'hésite pas Gaël

00:15:41 :si vraiment je vais un peu trop vite ou c'est un peu trop complexe ce que je dis, tu lâches un message et j'essaie de revenir sur les notions si je vais trop vite. Donc du coup

00:15:52 :l'idée c'est de versionner. Donc en gros l'intérêt et l'usage du versionnement c'est pour partager du code et pour avoir une sauvegarde extérieure de son ordi, genre typiquement si son ordi crache ou si sa maison brûle ou n'importe quel événement fâcheux de ce type, l'idée c'est de pouvoir avoir une sauvegarde dans le cloud entre guillemets, donc extérieure

00:16:17 :à son habitation et de là où on est. Et après ce projet distant sur un serveur comme GitHub, GitLab, etc. peut être accessible par d'autres personnes, après il y a des notions

00:16:30 :d'autorisation et de qui est permis de rentrer dedans et de voir. Et tout le monde peut le récupérer, tout le monde peut regarder les sources, tout le monde peut le récupérer pour soi, pour l'utiliser. Donc c'est vraiment un outil de base dans l'open source, dans

00:16:44 :le partage de code et de projet. C'est vraiment la brique de base qui permet que tout le monde peut participer à un même projet et interagir avec les autres.

00:16:56 :Typiquement, par exemple là, il y a le projet Git, c'est ce qu'on voit ici dans mon shell,il dit que je suis sur la branche main. Donc la branche c'est des sortes de répertoires

00:17:07 :là où on stocke les versions de son projet. Et le point d'exclamation, en gros il dit qu'il y a eu un changement, que je ne suis pas synchronisé. En gros ça, donc là c'est

00:17:17 :Git, je vais écrire en toute la piste statut. Donc en gros je demande à Git quel est le statut de mon repo local. Il dit que j'ai fait une modification, donc c'est le XFail

00:17:25 :que j'ai effacé dans test, test goban. Et par exemple là je peux faire un git diff,et là il va me dire le détail de la modification. Donc en gros là il dit que j'ai enlevé

00:17:36 :cette ligne et j'ai enlevé cette ligne. Et donc là, cette différence, il le fait par rapport à mon état local, qui était le dernier état qu'il considérait comme synchronisé avec le distant, donc GitHub. Et au fur et à mesure que je fais des changements

00:17:53 :en local, il va dire ouais, là tu as des différences, tu as des différences, parce que ta source de synchronisation qui est GitHub, forcément en local quand tu fais du code,quand tu modifies tes fichiers, tu changes les sources et tu changes l'état de ton versionnement sur ta machine. Mais ça c'est un fonctionnement normal. Et après au bout

00:18:13 :d'un moment, on dit quand tu as fini le développement, tu peux ajouter des fichiers, donc là par exemple test goban, et après tu peux faire un commit, donc le commit ça permet de, par rapport à des changements ou à un ensemble de changements, d'associer un message qui décrit ce changement, et dans le message tu décris ce que tu fais, par exemple là

00:18:35 :tu pourrais dire remove XFail marker, XFail bittest marker, par exemple. D'ailleurs,est-ce qu'on va le faire? Ok. Du coup, après l'idée dans Git, c'est comme je disais,

00:18:56 :de pouvoir avoir une synchronisation externe, c'est-à-dire que ce ne soit pas que sur son ordi ou sur son disque dur, mais que ce soit aussi dans le cloud et dans un site. Donc

00:19:04 :là en l'occurrence on utilise GitHub, qui est, je ne sais pas si vous avez déjà expérimenté,mais GitHub, on peut aller faire un tour. Donc GitHub ça ressemble à ça, c'est un

00:19:21 :des standards dans le versionnement de logiciels ou plateformes de versionnement, donc du coup là c'est sur mon compte, et en fait là, dans GitHub, on peut stocker ses projets,et il y a plusieurs outils qui permettent de faire de la présentation, de faire de la documentation, récupérer les sources, gérer les projets, etc. Donc là, par exemple,

00:19:44 :typiquement dans ce projet, j'ai fait la structuration de projet qu'on avait vue sur mon ordi,donc ça c'est les fichiers que j'ai poussés, et après dans le readme, c'est un fichier markdown où on décrit les projets, j'ai rajouté des annotations de documentation qui reprenaient en gros ce que j'avais mis dans l'explication de la première session,

00:20:05 :donc comment installer le projet et lancer les tests, et après j'ai copié l'énoncé du problème Open Classroom, donc assez simplement avec un peu de, comment ça s'appelle,de pagination, enfin pas de pagination mais de formatage de texte, pour avoir un rendu,bon c'est pas exceptionnel, mais bon ça fait le taf. Donc une personne qui vient, qui voit

00:20:30 :le projet, par exemple comme vous, puisque c'était fait pour vous initialement, il atterrit sur cette page où ici il y a les sources qui sont versionnées pour la version main,donc les branches, donc la branche principale du projet, et ça c'est la dernière version en fait que j'ai synchronisé entre mon ordi et GitHub, du coup les modifications, c'est

00:20:55 :ce qu'on appelle les commits, donc à chaque groupe de modification on fait un commit,et à chaque commit on peut associer un message, et du coup à un moment qu'on a suffisamment de commits pour une fonctionnalité, on synchronise, on pousse ces commits sur le repo distant,et on a un historique, ce qu'on appelle un historique de commit, par exemple là le dernier

00:21:18 :c'était de la documentation, pour ajouter un badge, là c'était pour la CCI etc, bon on va revenir sur la CI si vous voulez, et donc en nommant comme ça on a un historique en fait des modifications, et une personne qui vient sur le projet en fait, en regardant cet arbre et cette liste de commits, a l'historique de comment j'ai fait le projet.

00:21:38 :Repo, pardon, repo c'est repository ou répertoire de sources, et en raccourci on dit repo.Genre typiquement ça, docstring 2022 mentora yoionel goban, c'est le repo, c'est la repository du projet goban.

00:22:00 :Ensuite ce que j'ai fait, je ne vais pas rentrer dans les détails, c'est un peu plus avancé,c'est de la CI, juste pour revenir à une question qu'il y avait initialement.

00:22:09 :Donc en gros dans Github, Github nous donne un service qui permet d'utiliser des machines de Github pour lancer des tests et lancer ce qu'on appelle la CI, donc Continuous Integration.

00:22:21 :Donc à chaque modification qu'on fait sur le repo distant, donc le repo Github, on peut lui demander s'il te plaît quand je fais une modification, vérifie que mes tests passent par exemple.

00:22:31 :Et donc c'est ce qu'on voit, et donc sur Github, ce procédé, cette CI s'appelle Github Action,donc c'est dans l'onglet Action, et dans Action il y a ce qu'on appelle les workflows,donc c'est des exécutions de tâches, et moi comme je les configure actuellement, sur chacune des modifications, sur chacune des requêtes qu'on fait de modification, ça

00:22:54 :lance un workflow qui lance les tests, typiquement par exemple ça c'était Romain qui avait fait une requête, et du coup sur tous les interpréteurs qu'on est censé supporter pour le projet, donc Python 3.7, 3.8, 3.9, 3.10, on lance un job, donc un job c'est

00:23:13 :une tâche faite sur Github par leur serveur, on peut regarder la tâche pour 3.10.Donc en gros ça met en place le job, ça récupère les sources, ça met en place Python 3.10

00:23:24 :puisque c'est la version d'interpréteur qu'on veut tester, ça installe les dépendances,c'est le readme, c'est le readme, les premières étapes du readme qu'on a sur le projet.

00:23:36 :Tiens alors c'est un peu long, bon en gros là ça fait un pip install tout simplement,parce que notre projet n'est pas très compliqué.Ensuite là ça lance les tests, donc là pareil c'est runpytest, donc c'est pareil c'est dans le readme, les étapes de run.

00:23:48 :Et sauf que dans le readme, donc je remonte ici, ça en fait c'est des indications pour un humain, donc comme vous, par contre ici on voit que c'est tout automatisé, en fait ça reprend ces indications et ça les automatise, donc c'est fait par une sorte de robot qui lance au fur et à mesure tous ces tests de manière automatique et qui permet en fait

00:24:11 :à chaque étape ou à chaque moment que je resynchronise mon code, qu'il m'assure que tout fonctionne par rapport à ma définition de tout fonctionnant.Donc Yannick demande est-ce que ça vérifie si ça peut être lancé avec la version 3.10?

00:24:24 :Oui, comme c'est écrit actuellement, donc ça vérifie tout ce qu'on appelle des builds,donc des constructions, donc 3.10, 3.9, 3.8, 3.7, c'est les versions de Python.

00:24:33 :On pourrait même faire des builds qui pourraient regarder sur différentes plateformes, genre typiquement avec GitHub Action, donc la CI de GitHub, on peut lui dire fais comme si tu étais sous Mac, donc Mac OS, fais comme si tu étais sous Windows, ou là en l'occurrence moi je fais comme si j'étais sous Linux parce que bon c'est la plateforme que j'aime bien,

00:24:52 :et du coup les machines, donc là c'est dans le setup des machines, il y a une notion d'environnement d'operating system, donc l'OS, donc dans mon cas ici là c'est des Ubuntu, donc c'est une version de Linux, mais ça pourrait être un Windows, ça pourrait être un Mac OS,enfin il y a un nombre de choix, on peut ici changer la nature du système pour s'assurer

00:25:19 :justement si notre programme on veut qu'il soit compatible sur différents OS, on peut s'assurer de la même manière qu'on s'assure qu'il est compatible avec différentes versions de Python.

00:25:29 :Donc ça c'est plutôt puissant et c'est plutôt pratique.C'est un peu avancé, donc je ne vais pas rentrer dans les détails là-dessus, mais c'est un truc, en entreprise souvent vous aurez quelque chose comme ça, un équivalent de ça.

00:25:42 :Donc chez GitHub ça s'appelle Action, GitHub Action, et chez GitLab c'est GitLab CI,donc pour Continuous Integration, c'est un peu plus simple.Je ne sais pas pourquoi ils ont remplacé Action chez GitHub.

00:25:53 :Bref.Ok, donc ça c'est la partie Git avec GitHub.Donc là il y a toutes les sources, on peut naviguer dedans, on peut rentrer dedans.

00:26:05 :Le client pour observer les sources est plutôt bien, il est vraiment très bien fait avec les lignes, il y a même de l'intelligence en fait, si on clique sur les choses il sait se retrouver, il sait naviguer en fait.

00:26:19 :Je me demande même si on fait ça.Ouais bon il n'est pas intelligent au point de savoir qu'il utilise.Pareil là sur notre solution, là typiquement ici par exemple la Goban qui est définie dans notre classe Goban, il arrive à le comprendre ici, et donc on peut remonter ici si on veut.

00:26:36 :Donc c'est plutôt bien fait, c'est assez joli.Donc ça peut être un bon moyen aussi d'explorer des codes sources ou de regarder des projets.Il ne faut pas hésiter si vous êtes sur GitHub et qu'il y a un projet qui vous intéresse,allez faire un tour, c'est assez agréable comme navigation.

00:26:54 :C'est pareil sur les tests aussi, on peut regarder, c'est assez visuel.Donc là c'est le code.Après il y a la notion d'issue, issue en anglais c'est problème ou quelque chose qui va avoir.

00:27:06 :On peut l'utiliser, moi je l'utilise un peu différemment, j'utilise issue, ça peut être vu comme quelque chose qu'on attend, on note à l'attention du mainteneur du projet, donc moi, ce serait bien si tu faisais quelque chose en fait.

00:27:20 :Genre soit j'ai détecté un problème et je te montre le problème, ou soit ça peut être une caractéristique ou une propriété qu'on veut faire sur le projet, une nouvelle.

00:27:31 :On peut dire tiens ça serait mieux, par exemple là, rajoute de la documentation ou structure le projet pour que ce soit un projet propre, piton.

00:27:38 :Ça c'est des trucs que je me suis fait à moi-même en disant, bah là actuellement ton projet il n'est pas très documenté et il n'est pas très bien structuré, donc vas-y fais quelque chose de mieux.

00:27:48 :En plus j'ai pas dit grand chose dedans parce que c'est lié au projet, c'est un mauvais exemple celui-là.Genre dans ce qu'on a fermé, est-ce qu'il y en a des vrais? Non c'est que des trucs

00:27:58 :de projet, bon bref.Donc là les issues en fait c'est quand on voit quelque chose qui va pas ou qu'on voudrait rajouter quelque chose par rapport au projet, on peut faire une new issue, et là on peut décrire, on peut donner un titre, on peut dire la description, et normalement ça va

00:28:12 :notifier, donc on peut dire c'est assigné à qui, le type de problème qu'on a relevé,donc là il y a plusieurs types, etc.Donc c'est un outil sympa pour aider le développeur, même pour, genre si on voit un problème,ou si on voit un bug, ou si on voit une idée d'amélioration, c'est la voie pour communiquer

00:28:34 :avec le maintenant.Ou un bug, ouais, Lionel dit ou un bug, oui en effet.Pool request, donc ça Romain il a commencé, il a déjà joué avec.

00:28:45 :Donc ça en gros c'est, on a vu un problème, soit dans issue, soit on l'a vu en dehors d'issue, et on a fait une amélioration, on a fait une résolution de ce problème.

00:28:57 :Donc ça peut se faire, ce que je disais en début de séance, en forkant, donc en récupérant les sources et en travaillant sur ces sources, et après en proposant une solution, ou d'ailleurs c'est peut-être le seul moyen de se faire, ou sinon ouais si on a les droits du projet

00:29:13 :en fait on peut le faire directement sur le projet et faire une pool request.Donc là par exemple on peut regarder, bon là c'est la solution, on va peut-être pas la regarder, mais grosso modo Romain il l'a fait, donc lui ce qu'il a fait, il a fork,donc il a récupéré les sources, il a modifié pour résoudre le problème, donc la version

00:29:32 :récursive de EastAken et une version non récursive d'EastAken, et après il m'a proposé, donc il a poussé ces modifications, et il m'a proposé une pool request pour que je l'observe et éventuellement je l'intègre dans mon projet.

00:29:48 :Là en l'occurrence on l'a utilisé comme une méthode pédagogique, dans le sens qu'il a utilisé ce moyen pour me dire regarde moi j'ai une solution pour la version récursive et une solution non récursive, et moi je l'ai utilisé en regardant son code et en testant, et ça m'a permis aussi de lui faire des retours par rapport à ce qu'il m'a proposé.

00:30:09 :Donc c'est vraiment un très bon moyen de communication par rapport à du code et par rapport à du développement.Donc projet, je peux vous montrer, mais grosso modo j'ai créé un projet pour avancer sur les étapes, mais ça c'est un truc encore aussi un peu plus avancé, ça permet de structurer

00:30:25 :en fait et de se donner des objectifs, par exemple en 0.9 je voulais que ça soit prêt pour les étudiants, donc pour vous, et en 1.0 je voulais un truc d'e-clean, donc le

00:30:34 :0.9 il a été fait à 100%, c'est pour ça qu'il y a eu une transmission du projet,le 1.0 il manque des trucs, donc tous les in progress, donc il y en a que deux, dans

00:30:45 :l'occurrence c'était rajouter la documentation et structurer le projet.Mais c'est une vue, c'est un peu avancé ça, c'est sur ce qu'on appelle la structuration de projet, ça peut être, voire c'est très utile quand on travaille à plusieurs, là c'est un peu superflu comme je travaille tout seul dessus, c'est juste pour m'amuser

00:31:00 :avec l'outil.Donc après il y a les pages wiki, ça c'est cool, je l'ai utilisé pour faire de la documentation pour vous, donc je vous mets le lien d'ailleurs, normalement vous avez eu accès à ça.

00:31:13 :C'est là que j'ai commencé à rentrer la documentation, donc c'est une façon de structurer la documentation pour un projet, donc quand c'est de la documentation technique ça peut être vraiment un bon moyen, comme la doc elle est liée au projet, ça peut être un bon endroit le wiki de mettre de la doc liée au projet.

00:31:31 :Donc il y a une page sur le modèle de données, donc là j'avais fait des petits schémas à la main, je m'étais amusé, donc je vous laisse lire, ça parle du modèle de données comment Open Class Moom a modélisé ce Coban et ces pierres, et j'essaye d'expliquer comment ils l'ont fait par rapport au modèle de mémoire.

00:31:50 :ClassObjects, donc c'est sur les objets de classe, donc là pareil il y a un peu de documentation,ça parle un peu de l'implementation qu'a fait Open Class Room et de comment c'est utilisé pour résoudre ce problème.

00:32:02 :Et après il y en a deux autres, donc là les add documentation ça parle d'eux, donc il y a type int, c'est un truc qu'il faut que je fasse, et test unitaire c'est aussi un truc qu'il faut que je fasse.

00:32:12 :Du coup quand j'aurai fait ces deux là on ne sera pas loin de la version 1.0 du projet.Ok, est-ce que vous avez des questions par rapport à ce que vous avez présenté, GitHub et versionnement? Donc là c'est overview, comme on n'a pas forcément, normalement

00:32:32 :ça demande un peu de temps et d'expérimentation, genre plusieurs heures, du coup là je vous ai vraiment fait une overview plus sur le côté de la fonctionnalité et l'intérêt des outils.

00:32:43 :Après il faudrait y revenir dessus, on verra avec Thibault je crois que c'est un truc qu'il voulait faire très prochainement, des vidéos et des tutos sur comment utiliser Git et GitHub.

00:32:53 :Donc là c'était vraiment pour vous donner une idée de l'outil, de comment je vais l'utiliser pour ce projet, et comment vous pouvez éventuellement l'utiliser si ça vous motive.

00:33:03 :Donc si vous avez des questions, je vous laisse intervenir un peu.On va revenir sur le code et essayer de faire la version récursive, vous montrer comment faire la version récursive, ou une implémentation de la version récursive.

00:33:18 :Donc il y a Arnold qui est en train de taper quelque chose.Suspense.C'est un projet en partenariat avec Open Classroom ou c'est juste un projet? Ah oui, bonne

00:33:28 :question Arnold.Donc il me demande est-ce que c'est un projet en partenariat avec Open Classroom ou c'est juste un projet Open Classroom récupéré pour l'exercice.

00:33:36 :Donc c'est la seconde alternative.C'est un étudiant d'Oxfam qui est aussi à Open Classroom j'imagine, qui me posait des questions en message et il me demandait de l'aide sur la résolution de son problème.

00:33:52 :Et après du coup je me suis dit ouais mais en fait c'est un problème assez intéressant,enfin c'est un problème assez simple et assez intéressant pour montrer la récursivité.

00:34:02 :Et après en regardant le code je me suis dit mais en fait ouais c'est pas mal fait,en fait il y a aussi des notions par exemple de couverture de test, donc avec les fichiers qu'ils fournissent.

00:34:11 :Et le code est assez bien fait avec la classe et avec la gestion, le modèle de mémoire,le modèle de données qu'ils utilisaient.Donc je trouvais que c'était une bonne ressource de base pour initier un mentorat dessus.

00:34:26 :Ok, du coup on va revenir sur l'implémentation, sur le live coding.Du coup, là on a viré, ici il y avait les X-Rays derrière là, donc comme je disais c'était pour dire à PyTest que c'est normal que ça ne marche pas, et là comme on l'a viré, on a ce test qui ne fonctionne pas, donc que la forme noire est non prise

00:34:57 :parce qu'elle a un degré de liberté, donc c'est en explicite ici.Et donc là c'est ce qu'on voit ici, c'est que cette pièce en 1,1 est libre, donc la forme noire, donc avec la pièce en 0,1 et en 1,2 devrait être aussi libre parce que la forme avec la 1,1 est libre.

00:35:20 :Sauf que avec notre version naïve là actuellement, c'est quand on fait la requête ISTECAN01,donc il regarde cette pièce, il ne regarde que les pièces à côté d'elle, et forcément avec notre version naïve on n'a pas de notion de forme, donc là toutes les positions adjacentes elles sont prises. Donc il renvoie vrai ici, il renvoie vrai ici, il renvoie faux ici,

00:35:41 :mais ce premier test ici ne passe pas, cette première recherche.Du coup, ce qu'on avait fait, donc on revient là sur le code qu'on avait écrit, donc la première étape c'était est-ce que la position est sur une pierre ou pas, donc on récupérait le statut de la position de la pierre courante par rapport à la requête.

00:36:05 :Ouais, Yann fait en commentaire, faut connaître les règles de ce jeu pour mieux appréhender ce projet. Si c'est une question, je dirais non. Le problème énoncé du programme, du

00:36:17 :problème donne la règle qu'on doit comprendre, qui est la définition de capture en fait d'une position ou d'une pierre, et après par extension il définit la règle pour considérer qu'une forme, donc un ensemble de pierres, soit prise ou pas. Donc je sais pas, je connais

00:36:38 :pas, je suis pas un expert en Go, je sais pas s'il y a d'autres règles. Moi il me semblait de ce que j'avais entendu que Go en termes de règles était extrêmement simple,mais en termes de maîtrise et de plan de jeu c'était infiniment complexe. C'est possible

00:36:53 :qu'il n'y ait pas beaucoup plus d'autres règles dans le jeu de Go.Donc première étape, on regardait... de rien. Première étape on regardait si la

00:37:07 :position de la requête, donc if taken, x, y, est-ce que c'est sur une pierre ou pas.Si c'est pas sur une pierre, de toute façon ça n'a pas de sens, une caisse vide est forcément non prise, donc c'est par convention. Et pareil si c'est une position invalide,

00:37:21 :en dehors du plateau, ça n'a pas de sens non plus. Deuxième étape, on est sur une pierre, donc on regarde toutes les positions adjacentes, donc droite, gauche, bas, haut,haute, enfin position, donc de la pierre courante, donc en x, y, donc on est en x plus 1, x moins

00:37:40 :1, y plus 1, y moins 1. Et pour chacune des positions adjacentes de x, y, on regarde s'il y a une position libre. S'il y a une position libre, alors la pierre n'est pas prise, et

00:37:55 :sinon on n'avait rien fait, on avait juste renvoyé qu'elle est prise. On la considère ici, là, on considère qu'elle est prise. Ce qu'on voit dans l'exemple ici, c'est que

00:38:04 :cette pièce, donc cette pierre noire, est prise avec un autre algo, mais sa forme noire n'est pas prise avec un autre algo. Donc il faut qu'on ait une conception plus généraliste

00:38:16 :de la requête. Là en l'occurrence, notre implémentation, c'est ce qu'on appelle un point de vue ponctuel, c'est à dire qu'on donne un point dans l'espace et on considère ses positions autour de ce point. Là il faut qu'on arrive à élargir cette position ponctuelle

00:38:32 :en vue en termes de forme. Donc il faut qu'on ait une notion de forme. En étape intermédiaire,comment on pourrait faire? En termes d'algo, c'est sur les positions adjacentes, on pourrait

00:38:53 :se demander si elle n'est pas libre, est-ce que c'est une pierre de notre couleur ou pas.Si c'est une pierre de notre couleur, c'est à dire qu'on est en train de former une forme,on est en train de continuer une forme. Si c'est une pierre opposée à notre couleur,

00:39:13 :c'est à dire que c'est un ennemi qui est en train de nous bloquer. Donc en fait ici,si ce n'est pas une position vide, on est sur une pierre. Et on avait récupéré le

00:39:28 :statut. Donc là ici, on peut se poser la question, est-ce que la pierre adjacente est de la même couleur? Donc en gros, est-ce que la position de la roquette est la statue

00:39:57 :de la pierre adjacente? Il faut peut-être que je désactive Copilot. C'est où déjà?Un peu agressif. Ok, dans ce cas là, en gros, dans ce cas là, c'est à dire qu'on a une

00:40:23 :formation de forme. Bon pour l'instant on va faire passe. Et dans le cas contraire,en fait, c'est une pierre d'une autre couleur. Donc la position est prise. Enfin, la position

00:40:47 :pour cette direction est prise. Par contre on ne peut pas conclure spécialement. Donc ça en gros, ici ça ne va rien faire, si on relance le test ça va aller au même endroit parce qu'on n'a rien fait, on a fait que des passes. Ok, le truc, c'est quand on est sur

00:41:09 :une position adjacente et que c'est de la même couleur, on poursuit la forme. Donc ici,par exemple là, si on a la roquette ici, en haut il va dire que c'est une pierre d'une autre couleur, en bas il va dire que c'est une pierre d'une autre couleur, par contre

00:41:24 :à droite il va dire que c'est une pierre de la même couleur. Donc l'idée de la récursivité en fait c'est de relancer la roquette is taken sur une position adjacente d'une pierre de la même couleur, donc en gros de poursuivre le is taken sur la forme et de poursuivre

00:41:43 :cette recherche de est-ce que j'ai une liberté autour de moi. Donc en gros ici, quand on sait qu'on a une pierre de même couleur, donc ça veut dire qu'on poursuit ici, on poursuit la création d'une forme et... non, ça n'a toujours pas désactivé, c'est chiant

00:42:08 :ce truc. Attendez qu'il y en ait un, si j'arrive pas à le retrouver. Comment je fais pour le désactiver? C'est où déjà? Ah oui, git hub, copilot, ok. Donc là on va réappeler

00:42:47 :is taken sur la position adjacente. Ah du coup on a pas la position... ok, donc là du coup il nous manque la position. En fait là ce qu'on veut c'est sur la position adjacente

00:43:10 :qui n'existe pas. Est-ce que ça a marché ça? Non c'est pas un return, là ici c'est un... donc là on va conserver une variable par rapport au parcours des positions adjacentes.

00:43:52 :Variable elle va dire en fait est-ce qu'on est libre, c'est à dire est-ce qu'on considère qu'il y a un état libre et cet état libre... en gros il est vrai... alors attend, cet état

00:44:16 :libre... non non, en fait c'est pas ça, en gros ici est-ce qu'on a une position adjacente libre? Ok. Et si on est sur une même pierre, on veut regarder si la position adjacente

00:44:35 :a un degré de liberté, donc en gros si c'est pas pris. Et dans ce cas là, si en fait ça renvoie que c'est pas pris, en fait on retourne false. En gros c'est si dans la récursivité

00:45:03 :à un moment on dit que la position adjacente d'une pierre de la même forme a un degré de liberté, alors toute la forme a un degré de liberté. Par contre on n'a pas de position

00:45:17 :adjacente, donc en gros c'est ici, on get le statut, il faut qu'on conserve aussi la direction de la position adjacente. Donc ici en fait c'est position adjacente... ok...

00:45:42 :statut... ouais, en fait c'est position adjacente, ok. Ici là on va stocker un tuple... on va peut-être pas faire le type tout de suite... et là on va aussi récupérer la position

00:46:01 :adjacente. En gros là, ici au lieu de faire une liste des statuts des positions adjacentes,ce qu'on fait c'est une liste de tuples, donc de deux éléments, où on a le déplacement,enfin la position, et on a le statut de la position. Donc ici quand on iter sur cette

00:46:21 :liste, on récupère la position adjacente et le statut de la position adjacente. Pourquoi il est pas content ici? Ah oui. Ok, du coup on regarde, donc là ça continue à fonctionner,

00:46:45 :est-ce que la position est libre? Si oui, alors si elle est libre, donc ça veut dire que la pierre est pas prise, enfin la pierre et la forme n'est pas prise. Sinon on regarde

00:46:59 :le statut de la position adjacente, on regarde si c'est le même statut que la pierre qu'on a examiné au départ, si c'est le cas on appelle est-ce que c'est pris sur la position adjacente, donc par un effet d'ici, on fait la récurrence d'ailleurs. Si l'appel sur

00:47:17 :la position adjacente par récurrence dit qu'on n'est pas pris, alors l'appel initial, donc en x, y, est aussi pas prise, donc ça remonte l'information que c'est pas pris. Si c'est

00:47:36 :une pierre adverse, alors on passe, on pourra effacer ça après, mais bon on le garde pour l'instant. Toutes les positions adjacentes ne sont pas libres, donc ouais ok, on va conserver

00:47:49 :ça. Donc là on va lancer les tests unitaires, en particulier ce test-là qui passait pareil,on va voir ce qui se passe. Tac, il n'y a plus personne qui fonctionne. Qu'est-ce qu'ils

00:48:06 :disent? Ah oui du coup forcément ça influence tous les autres, et là il dit en fait il a un problème d'unpack. Pourquoi le unpack il est pas content? Tiens c'est marrant

00:48:26 :ça. Pourquoi j'arrive pas à unpacker? Et pourquoi j'arrive même pas à breaker? C'est un peu jaloux ça. Il faut regrouper les données en type... Oui bien vu, très bien vu, yes

00:49:02 :en effet. Oui parce que là oui, en fait j'ai fait n'importe quoi, en effet, bien vu. Par contre c'est chiant, pourquoi il me donnait pas... Ok, bon on reparle là-dessus. Donc

00:49:23 :là en gros il y a les tests qui refonctionnent, bon c'est normal puisqu'on regardait la position directe devant, et on a toujours notre black test qui ne fonctionne pas, et qu'est-ce qu'il nous donne? Ah voilà, c'est ça que j'attendais. Là il nous dit recursion detected, sum and

00:49:39 :position. En gros cette erreur dit en fait qu'il soupçonne qu'on a une boucle infinie en fait. D'ailleurs normalement ça devait être... Ah oui c'est ça, c'est celle-là

00:49:49 :que je cherchais, d'ailleurs je vais l'agrandir un peu. C'est cette erreur en fait qui est intéressante. Il dit maximum recursion death expected in comparison. Donc en gros on a

00:49:59 :bouclé pour ce test, on a bouclé plein de fois, et il a pas réussi à sortir de la boucle de récurrence. C'est-à-dire qu'il se faisait appeler constamment avec les mêmes

00:50:12 :valeurs, et donc il revenait sur les mêmes appels indéfiniment. Donc on va regarder,on va se faire un petit debug à la main. Ici on fait un appel récursif, donc on va

00:50:25 :afficher l'appel qu'on fait. Recursive position. Normalement on devrait avoir... Pourquoi il est pas content là? Ah mais il y a tout le monde qui va pas, il dit can you star expression

00:50:47 :? Ah oui forcément, ça a pas de sens. Du coup on va lancer juste ce test-là, parce que sinon on va avoir trop de trucs à l'écran. Et c'est pas le bon test. Pourquoi il tourne

00:51:01 :lui maintenant? Putain c'est étrange, pourquoi il fait passer le test? Ah bon, ok. Donc là on voit les prints des calls. Donc ici, juste avant d'appeler ici en récursion, self

00:51:20 :is taken. Donc là on voit qu'il fait un call en 0,1. Après on voit qu'il fait un call en 1,1. Et après on voit qu'il refait un call en 0,1. Après on voit qu'il refait un

00:51:30 :call en 1,1, etc. Et au bout d'un moment, je sais plus c'est combien par défaut, il dit ouais mais en fait là tu fais plein de fois la même chose et ça tourne à infini.

00:51:43 :En gros, par rapport au test, si on regarde le test, donc là il fait un call en 0,1,donc c'est le call initial ici, is taken 0,1. Il regarde les positions adjacentes, donc

00:51:55 :ici c'est des pierres blanches, donc il n'y a pas de call récursif. Par contre sur le côté, en 1,1, il voit que c'est une pierre de la même couleur, donc il fait un call en 1,1. Et après, quand on est du point de vue du call du 1,1, donc il regarde les positions

00:52:13 :adjacentes, donc il regarde à priori il doit regarder gauche, droite du coup. Non il regarde droite, gauche. Tiens c'est marrant, pourquoi il tombe quand même en récurrence. Donc bon.

00:52:25 :Bref, donc il regarde les positions adjacentes et là il revoit une position adjacente, donc 1,0. Donc on est avec ce point de vue là, en 1,1, et on regarde à sa gauche et on voit

00:52:39 :qu'il y a une pierre de la même couleur. Donc on revient en récursion sur cette pierre en 0,1. Sauf que c'est la pierre qui nous a appelé initialement. En fait c'est pour

00:52:53 :ça qu'on tombe, les deux se détectent à l'infini. En fait ça fait une boucle infini entre la position 0,1 et la position 1,1 parce que chacune, genre la position 0,1 appelle la 1 et la 1,1 appelle la 0,1. Donc ils oscillent, c'est une oscillation de période 2, et donc

00:53:12 :ça tourne à l'infini. Donc là le problème c'est que quand on fait notre appel, en fait on n'a pas conscience de qui nous a appelés, on n'a pas conscience de ce qu'on a fait comme chemin. Donc on a le potentiel problème, même là on a le problème concret en fait

00:53:25 :de revenir sur nos pas et de refaire le même travail et de ne pas avoir de possibilité de sortir en fait de cette récursivité, de ce travail de récursif. Donc la solution

00:53:36 :pour ça c'est qu'il faut qu'il y ait un contexte en fait sur l'appel, c'est à dire que quand on fait l'appel on ne peut pas juste appeler sans savoir d'où on vient et ce qu'on a fait, on doit conserver en fait une trace de où on a été et qu'est-ce qu'on

00:53:50 :fait. Donc l'idée, soit on modifie, bon on va le faire en mode simple, on va modifier,ça c'était dans l'énoncé qu'on pouvait changer la signature des appels, donc là on va suivre l'énoncé, la possibilité de l'énoncé. Donc là en fait ce qu'on

00:54:11 :veut c'est un historic of position et ça va être une liste de coordonnées XY qui va au fur et à mesure, d'ailleurs non, liste on n'a pas le droit. Parce que liste c'est

00:54:36 :ce qu'on appelle un type mutable qui peut se modifier, on ne met pas des types qui peuvent se modifier dans les arguments. Donc là on va dire que c'est un optional liste en fait.

00:54:47 :Optional liste. Et on va lui attribuer non au départ parce que c'est un optional, on peut dire que c'est non. Et en plus ça nous permet de ne pas changer nos appels, c'est-à-dire

00:55:04 :que par défaut quand on va faire if taken avec XY, comme si on ne spécifie pas un historique de position, donc il va lui attribuer non et donc ça va continuer de fonctionner. Par

00:55:16 :contre, si c'est non, en fait nous on veut une liste. Et si c'est pas non, c'est-à-dire qu'il y a un historique dedans donc on n'y touche pas. Et après ce qu'on fait, c'est

00:55:34 :que quand on reçoit un appel à if taken, donc là comme ici, on lui rajoute la position qu'on est en train de parcourir et quand on fait les positions adjacentes ici, on lui donne l'historique. Donc là en gros, sur le premier appel de if taken, comme dans le

00:56:14 :test, il n'y a pas d'historique donc il va être un non. Sur les autres appels, on stocke au fur et à mesure les positions qu'on parcourt et quand on fait un appel récursif, on lui donne l'historique de ce qu'on a parcouru. Donc là on peut lancer, voir si ça tourne,

00:56:30 :mais bon ça ne va rien changer parce que là on n'a pas encore utilisé l'historique.Mais bon, les autres tests fonctionnent, c'est-à-dire qu'on n'a rien cassé. Par contre, il faut

00:56:38 :qu'on utilise l'historique avant. Donc en gros, la question c'est est-ce que la position adjacente actuelle est dans l'historique? Donc c'est cette question. Est-ce que la position

00:57:03 :adjacente est dans l'historique des positions visitées? Si oui, en fait on est déjà passé par là donc on n'y retourne pas. Et sinon, on fait notre test, on fait ce qu'on faisait

00:57:45 :avant, c'est-à-dire de regarder si la position adjacente est prise ou la forme que suit la position adjacente est prise. On va voir ce que ça donne. Et hop, tout est vert. Par

00:57:59 :contre le code est cracra, mais en tout cas on a passé les tests. Donc là ce qu'on a fait, d'ailleurs on peut regarder, on peut peut-être regarder, on peut regarder l'école que ça fait. Donc ça fait 0,1. Donc ici 0,1, c'est le call initial. Après ça fait 1,2,

00:58:21 :donc ça va ici. Après ça fait 1,2, ouais c'est ça. Après ça fait 1,1. Donc là ouais,du coup ici on pourrait, là c'est du formatage, c'est des trucs pas forcément à faire, c'est pour que ça soit un peu plus lisible. A la fin ici, on peut faire un print, juste pour

00:58:42 :que ça saute une ligne. Donc voilà, c'est juste pour avoir cette visu. Donc là on fait le call en 1,1, ici. On visite en 0,1, ici. Après on fait en 1,2. Donc 1,2, c'est ici.

00:59:01 :Donc c'est la position basse de 0,1. Le call initial en fait il est en 0,1 de lui. Sa première position voisine de la même tierce en 1. Après on fait un call récursif donc en 1. Et le

00:59:25 :1,1 regarde en 0,1. Tiens d'ailleurs pourquoi il fait le 1,1? Est-ce que c'est normal ça?Tiens c'est marrant ça parce que dans l'historic, en fait ça a l'air de faire le truc mais on revient sur des mêmes positions j'ai l'impression. Peut-être ça peut valoir le coup. Ah oui

01:00:08 :non mais parce que ici l'appel il est pas là, il est là. Donc voilà c'est plus logique ici. Donc on fait en 1, on regarde en 1,2 mais on regarde rien d'autre. On regarde en 0,1.

01:00:24 :Là ici il y a... Du coup il fait pas l'appel en 1,1 parce qu'il a déjà été vu. On fait l'appel en 1,2. Donc 1,2 ici. Et il fait aucun appel parce que celui-là on l'a déjà fait

01:00:44 :et qu'après toutes les autres positions elles sont prises. Et le dernier call c'est en 1,2.Il revient sur 1,1. Ouais bon. Il faudrait que je travaillais un peu plus là le debug

01:01:01 :et l'analyse des positions. Mais grosso modo, le concept de base c'est quand on fait de la récursion il faut une condition récursive dans quel cas on rentre dans un appel récursif et la clé dans les implémentations récursives il faut une condition de sortie. C'est à

01:01:23 :dire de savoir comment on a fait, quel chemin on doit prendre pour continuer la récursivité et surtout comment on doit s'arrêter. Donc là notre condition récursive c'est, on a

01:01:34 :un degré de liberté. Donc dès qu'on a un degré de liberté c'est à dire que la forme ou ce qu'on est en train de poursuivre de forme elle est libre. Donc on remonte ce degré

01:01:44 :de liberté, c'est le return false ici et ici. Et après la question de comment on fait pour savoir si on doit faire l'appel récursif, donc le parcours qu'on fait récursif, on utilise l'historique de position qui dit dans quelle position on a parcouru et en sachant quelle position on a parcouru ça nous évite de refaire indéfiniment les mêmes parcours

01:02:15 :dans l'arbre d'exploration des solutions. Donc du coup avec cette implémentation, donc là qui est assez naïve, il y a des passes, typiquement il faudrait réécrire les conditions pour les inverser, mais bon là il y avait un côté, je voulais écrire de la documentation et suivre un côté pédagogique, mais là tous les if quelque chose passe ou else passe,

01:02:39 :en fait tout ça on peut les enlever, ils n'ont pas d'intérêt en termes de code. Mais du coup là avec cette formulation, on a les tests qui passent, tous les tests Goban qui passent,donc normalement on est censé avoir implémenté la solution récursive, en tout cas qui passe les tests définis par Open Classroom. On va aller relancer un coup pour être sûr.

01:03:04 :Vous avez des questions? Ok. Après ce que je vous propose, donc là moi je vais,je vais synchroniser les sources, reformater un peu le, enfin quoi que je vais peut-être mettre cette version, comme ça c'est la version live coding, ça peut être aussi intéressant de regarder, ça c'est une version entre guillemets naïve où je l'ai fait en même temps que

01:03:50 :je parlais et que je vous ai expliqué. Après il y a, justement si vous allez sur le GitHub,il y a des pull request de Romain qui a fait une version, du coup elle est mieux écrite,il a pris j'imagine un peu plus de temps pour la faire, qui est bien écrite, j'avais fait

01:04:06 :des retours, il a modifié quelques trucs et là sa version récursive est vraiment intéressante.D'ailleurs ça pourrait valoir le coup peut-être de, s'il y en a d'autres qui se motivent à essayer de faire la version, de voir si on a différentes versions d'implémentation de la récursivité. Après comme il allait assez vite, je lui ai demandé s'il avait

01:04:24 :une idée de comment faire en version non récursive, donc il a fait une proposition qui est très bien aussi, qui fonctionne bien. Du coup ça peut être intéressant de regarder

01:04:33 :sur le repo, donc ici, dans les pull request, il y a la version récursive, il y a la version non récursive, d'ailleurs c'est pas dans l'énoncé la version non récursive, donc ça peut être vraiment intéressant de regarder. Donc là il y a l'historique de comment lui

01:04:49 :il a fait, il a écrit les commits, enfin ses modifications, et après je lui ai fait des retours, on peut faire des retours directement par rapport au code. Et après quand vous

01:05:01 :êtes dans une pull request et à l'intérieur d'une pull request, vous regardez les file change, donc les fichiers qui ont changé, et là ici vous avez accès aux code source,les modifications de code source pour implémenter, enfin qui implémentent, la pull request qui implémente la nouvelle fonctionnalité ou les modifications qu'il propose. Donc il y

01:05:21 :a la conversation qui peut être intéressante dans une pull request à suivre, de quoi on parle, et après si vous voulez regarder les code source, vous allez dans fichiers changés,vous regardez ce qu'il a modifié, et vous pouvez essayer de comprendre ce qu'il a fait.

01:05:35 :Pareil pour la version récursive, donc là il y a une conversation, il y a peut-être moins de choses, ah ouais non il y avait des trucs, bon bref, j'ai fait quelques remarques,et là pareil, vous pouvez regarder les fichiers changés, et vous pouvez regarder son implémentation.

01:05:50 :Du coup, ah ouais du coup je l'avais peut-être, elle a l'air mieux écrite, ouais ok bon.On pourra regarder son implémentation intéressante, parce qu'en plus j'avais passé un peu de temps pour la corriger, donc il y a des trucs intéressants dedans. On pourra se faire une

01:06:06 :mini session là-dessus, si vous voulez regarder cette solution et regarder une solution un peu plus élégante que ce que je vous ai présenté.Donc je vous invite à regarder ce problème, essayer de le résoudre si vous pouvez, d'essayer,vous avez les tests, essayez de faire tourner les tests, essayez d'avancer pour les exécuter

01:06:27 :et qu'ils passent. Si vous souciez ou d'un moment vous avez l'impression de ne pas assez avancer, vous pouvez regarder les solutions. Donc moi je vais pousser la solution qu'on

01:06:38 :a écrite et vous pouvez regarder celle de Romain par exemple. Et après vous pouvez faire une soumission, c'est à dire récupérer, forquer ici le projet, décrire votre solution,une implémentation de votre solution et après de faire une pull request comme Romain a fait.

01:06:54 :Et comme ça on aura une base ici, on pourra avoir une base de plusieurs propositions de plusieurs étudiants. Et s'il y en a assez ou si c'est assez intéressant, on pourra

01:07:02 :se faire une session pour regarder comment chacun a fait à implémenter, à solutionner le problème.Oui, après moi je sais que dans ma solution non récursive, il y avait au moins une amélioration à faire, je pense que c'était dans le dictionnaire, je rajoutais toutes les positions adjacentes,même la position d'origine.

01:07:37 :Ah, j'avais pas fait gaffe. Ok, ouais, ouais. En effet, c'est pas une position intéressante à retester.Ok, bonne remarque. À la rigueur, tu peux même faire une remarque sur ta propre pull

01:07:55 :request. En fait, tu peux annoter dans le code si tu vois un truc qui va pas. Bah attends,je te montre ce que je sais pas faire. Donc c'est dans la version non récursive tu dis.

01:08:04 :Donc dans les fichiers échangés, tac, c'est ici là. C'est ça tu dis? Non attends, c'est quoi?Ouais, c'est ça, dans le dictionnaire je rajoute systématiquement les quatre positions alors qu'il y en a forcément au moins une qui est déjà testée.

01:08:19 :Pourquoi donc? Ça c'est les positions adjacentes, faut que tu les... Non mais en fait le truc c'est sur le premier call, sur le premier call tu dois tester tes quatre positions adjacentes ici.

01:08:34 :Oui, oui, au tout début, mais après, new position.Ah oui, oui, en fait, ouais, t'en as trois, oui, oui, en effet. Ok, je vois ce que tu veux

01:08:44 :dire. Ah oui, ici, position à tester, en fait, c'est ça que tu veux dire? Ici tu pourrais virer... Ouais, ok, d'accord. Donc là après ce que tu peux faire, avec le plus là, tu

01:08:53 :peux te draguer comme ça, et là tu peux ouvrir et faire un commentaire ici, bla bla bla,et ça va notifier, dans ta pull request, ça va notifier à cet endroit, donc ce bloc de code, tu peux, bla bla bla, va apparaître en mode un commentaire qui donne une suggestion,

01:09:12 :et c'est comme ça que je t'ai fait les suggestions de modifications. Ok. C'est un outil intéressant d'ailleurs. Et c'est bien de pouvoir, soit tu peux sélectionner une ligne, comme ça,

01:09:22 :ou soit tu peux sélectionner des blocs, comme ça, c'est trop bien. Et là tu peux, c'est en markdown, donc il y a du preview, genre ici tu peux faire du piston code, bla bla bla,et par là tu peux dire, je te conseillerais de faire plutôt comme ça, par exemple, et

01:09:52 :là en preview tu vois comme ça, par exemple. Piston. Ouais c'est sympa. Guiteub là il a vraiment des trucs, ils sont forts, il n'y a pas de lien. Ils sont forts, ouais. Bon

01:10:06 :dommage qu'il soit autant dans la matrice, mais il reste très fort. Ok cool. D'autres choses? Mesdames et messieurs, je ne sais pas si on a une dame, ou plusieurs même. Je

01:10:24 :ne sais plus, je n'ai pas regardé au début. Ah non c'est que des messieurs, j'ai l'impression.Messieurs et messieurs. Ah, il n'est pas content. Ah non les relois de pas. Ok, cool. Du coup

Implémenter la capture de pierres au Go

Session du 19 juillet 2022 à 20h00

Deviens membre Premium

Premium

Implémenter la capture de pierres au Go

Rechercher sur le site