Latest / Le Dernier Clic (avant la fin du monde) / 17 - Une application de A à Z : besoins, code, tests et production

Transcript

17 - Une application de A à Z : besoins, code, tests et production · Le Dernier Clic (avant la fin du monde)

• 0:13
  Bonjour et bienvenue dans Le Dernier Clic,
• 0:14
  votre podcast tech,
• 0:15
  IA et no-code.
• 0:16
  On se retrouve comme chaque semaine avec Lulu.
• 0:19
  Comment ça va ?
• 0:20
  Ça va bien.
• 0:21
  Et d'ailleurs,
• 0:22
  je ne te m'en ai pas demandé s'il ne faisait pas trop chaud chez toi.
• 0:24
  Tu n'étais pas encore en mode caniculaire.
• 0:26
  Oui,
• 0:26
  je suis venue,
• 0:27
  c'est signé.
• 0:27
  comme toujours,
• 0:28
  mais bon,
• 0:29
  on arrive à garder du frais à la maison,
• 0:30
  donc ça va.
• 0:32
  Parfait.
• 0:33
  Alors,
• 0:34
  on se retrouve cette semaine pour changer un petit peu des sujets d'IA,
• 0:38
  parce qu'on vous a pas mal parlé d'IA ces dernières semaines et ces derniers épisodes,
• 0:43
  notamment sur l'IA frugale et la semaine dernière quand on vous a parlé également de notre portail.
• 0:50
  Donc,
• 0:50
  on est revenu en fait un petit peu sur ce que ça implique de développer une application en l'illustrant à travers le développement
• 0:57
  de notre application,
• 0:58
  de notre portail qu'on utilise,
• 1:00
  nous,
• 1:00
  au quotidien maintenant pour préparer nos épisodes.
• 1:03
  C'était un épisode côté outils un petit peu thématique et un peu plus particulier.
• 1:07
  Je vous invite à l'écouter si ce n'est pas déjà fait et si le sujet vous intéresse.
• 1:11
  Et aujourd'hui,
• 1:12
  histoire de faire le pont justement avec tout ça et de clarifier un petit peu ce que représente le développement logiciel,
• 1:19
  le développement d'une application au sens un peu plus général.
• 1:23
  qui n'est pas spécifique au wipecoding et au développement assisté par IA,
• 1:27
  qui n'est pas spécifique non plus à la manière dont nous,
• 1:29
  on travaille avec Lulu et ce qu'on vous a présenté la semaine dernière et ce qu'on continuera de vous présenter la semaine prochaine.
• 1:35
  Là,
• 1:36
  l'idée va être de revenir un petit peu sur le développement logiciel au sens large.
• 1:42
  Lulu,
• 1:43
  je te laisse nous dire un petit peu pourquoi aussi on part sur ce sujet-là maintenant.
• 1:48
  En fait,
• 1:49
  on s'était dit...
• 1:50
  Peut-être qu'on continuera juste à parler du développement dans cet épisode-là,
• 1:54
  mais moi,
• 1:55
  en tout cas,
• 1:55
  ça me semblait important de juste prendre le temps de définir les différentes étapes et de revenir un peu sur le vocabulaire aussi.
• 2:02
  Parce que c'est peut-être des expressions qu'on voit beaucoup dans notre bulle,
• 2:08
  mais sans forcément comprendre ce que ça implique de faire des tests,
• 2:12
  sachant qu'il y a différents tests,
• 2:15
  même les différents types de développement.
• 2:17
  Bon,
• 2:17
  là,
• 2:18
  on n'ira pas.
• 2:18
  pas beaucoup dessus.
• 2:20
  On a essayé de condenser pour donner un vernis et une première couche de vocabulaire et savoir ce que ça veut dire quand une application est en prod,
• 2:32
  le côté maintenance,
• 2:34
  vraiment toutes les grandes étapes de développement.
• 2:37
  On est dans de la vulgarisation,
• 2:40
  on sait que c'est différent plus ou moins dans chaque boîte,
• 2:46
  mais là,
• 2:46
  c'est des grandes étapes.
• 2:47
  dans la théorie et a priori,
• 2:51
  on passe par celle-là.
• 2:52
  Oui,
• 2:53
  on va effectivement,
• 2:54
  on va revenir vraiment sur les principes et que vous soyez exposé en fait déjà ou pas au jargon et à certains mots qu'on emploiera.
• 3:02
  L'objectif là justement,
• 3:03
  c'est que ce soit clair pour tout le monde.
• 3:05
  Parce que bien souvent,
• 3:07
  quand on croise des gens dans les boîtes,
• 3:09
  même si votre entreprise est un éditeur de logiciels et qu'elle va le mettre à disposition de clients pour une fonction Voilà.
• 3:17
  pour un usage spécifique ou des usages spécifiques,
• 3:20
  au sein d'une entreprise,
• 3:21
  il est quand même assez fréquent de voir que les gens ne se rendent pas forcément compte de ce qui se passe dans les autres services et du rôle de chacun et du rôle de chaque équipe au niveau d'un produit,
• 3:31
  au niveau d'un logiciel.
• 3:33
  Donc on n'ira pas justement dans le détail de tout,
• 3:35
  comme disait Lulu,
• 3:36
  puisque en fait,
• 3:36
  en fonction de la taille de l'entreprise,
• 3:38
  déjà,
• 3:38
  ça va impacter différemment et avoir des...
• 3:43
  comment dire...
• 3:43
  des dépendances et des sujets plus ou moins vastes et des implications techniques plus ou moins vastes.
• 3:48
  On ne va pas revenir sur tout ça parce que ce serait infini,
• 3:54
  mais bien vous donner les clés de compréhension de ce qu'est un logiciel,
• 3:59
  vraiment de bout en bout,
• 4:00
  en tout cas sur toutes les phases principales et importantes.
• 4:03
  Ça dépend du type de logiciel aussi qui va être développé.
• 4:08
  Il y a autant de spécificités presque de logiciels et d'équipes.
• 4:13
  C'est des grandes phases aussi pour savoir ce que ça implique parce qu'on a l'impression qu'avec l'IA,
• 4:18
  tout est simple et on peut tout aussi bien se lancer soi-même dans le développement ou passer par quelqu'un qui développera.
• 4:25
  Et je pense que c'est important d'avoir ce vocabulaire qu'on soit potentiellement client ou une personne qui va se dire « bon,
• 4:34
  je peux faire un logiciel maintenant juste en comptant » .
• 4:38
  C'est bien de savoir tout ce que ça implique.
• 4:41
  Parce que typiquement quand vous avez un produit dans les mains,
• 4:44
  un logiciel dans les mains,
• 4:45
  il n'y a pas juste eu une étape où vous avez dit je veux tel truc,
• 4:50
  je veux un programme qui me fasse ces trois fonctions et quatre boutons,
• 4:55
  et basta,
• 4:58
  il y a tout un chemin à parcourir pour arriver à deux.
• 5:02
  du début à la fin.
• 5:03
  Et le début de ce chemin,
• 5:05
  en fait,
• 5:05
  il va passer par ce qu'on appelle le recueil des besoins.
• 5:08
  On l'avait déjà évoqué la semaine dernière,
• 5:10
  un petit peu,
• 5:10
  à travers la compréhension des besoins pour notre cas d'usage qui était le portail.
• 5:14
  On s'est dit,
• 5:15
  ben voilà,
• 5:15
  nous,
• 5:16
  aujourd'hui,
• 5:16
  on a des infos éclatées dans plein d'outils,
• 5:19
  on a besoin de tout centraliser,
• 5:20
  et que ça nous aide à faire un épisode de tout en bout.
• 5:24
  Et pour ce faire,
• 5:25
  ben voilà,
• 5:25
  que ce soit sur un usage comme le nôtre ou sur n'importe quel usage,
• 5:27
  vous allez avoir besoin de comprendre et...
• 5:31
  d'interagir et d'aller chercher les informations pour ce fameux recueil de besoins.
• 5:35
  Est-ce que tu peux nous l'expliquer un peu,
• 5:37
  Lulu,
• 5:37
  sur les différentes approches qu'il peut y avoir,
• 5:39
  justement ?
• 5:40
  Oui,
• 5:41
  et juste aussi,
• 5:42
  on en avait parlé dans l'épisode sur l'Igafrugal,
• 5:46
  où déjà de bien définir,
• 5:48
  savoir si ce qu'on veut développer n'a pas déjà une solution,
• 5:51
  de bien répondre à un problème,
• 5:54
  parce que si on se lance tout de suite dans le développement du logiciel,
• 5:57
  on peut le faire de la meilleure manière possible,
• 5:59
  s'il ne répond pas.
• 6:00
  à un problème ou à une douleur,
• 6:03
  il ne va pas forcément servir et ce sera toutes les étapes derrière qui vont juste partir à la poubelle où le logiciel ne sera pas utilisé.
• 6:14
  Et c'est important,
• 6:18
  déjà pour recueillir du besoin,
• 6:22
  et il faut aller chercher du concret,
• 6:23
  donc en général,
• 6:24
  ça passe par des phases de discussion avec des vrais gens qui,
• 6:28
  idéalement...
• 6:29
  ont ces problèmes au quotidien,
• 6:32
  ou des frictions,
• 6:33
  ou ils connaissent un peu leur process.
• 6:38
  Alors là,
• 6:38
  c'est peut-être plus dans un cas de...
• 6:42
  Comment dire ?
• 6:43
  Pas que d'outils internes,
• 6:44
  parce qu'après,
• 6:45
  je pense que c'est encore différent en startup,
• 6:47
  quand tu développes un produit.
• 6:49
  Toi,
• 6:50
  tu connais peut-être un peu plus du côté là,
• 6:52
  mais on va avoir des entretiens,
• 6:54
  on va les observer,
• 6:55
  étudier l'existant,
• 6:56
  que ça soit un logiciel déjà existant.
• 6:59
  ou savoir comment les gens travaillent.
• 7:03
  Et nous,
• 7:04
  pour mettre en parallèle,
• 7:05
  c'était un peu toute notre phase de bricolage,
• 7:06
  savoir par où passer l'information et qu'on ait un peu une idée des flux.
• 7:10
  Je ne sais pas si toi,
• 7:12
  peut-être par rapport à ton expérience...
• 7:14
  Alors,
• 7:15
  déjà,
• 7:16
  effectivement,
• 7:18
  normalement,
• 7:19
  le besoin d'une application,
• 7:20
  le besoin d'un logiciel,
• 7:22
  il l'est habituellement et théoriquement,
• 7:24
  il émerge tout seul.
• 7:26
  Il va émerger tout seul d'un problème que...
• 7:28
  Quelqu'un dans son entourage va rencontrer,
• 7:31
  et dans son entourage que ce soit perso ou pro,
• 7:33
  mais disons qu'on est dans un contexte d'entreprise,
• 7:35
  donc ça va être des collègues qui vont commencer à se plaindre d'avoir besoin de quelque chose pour arriver à leur fin.
• 7:42
  Pour produire un document,
• 7:43
  par exemple,
• 7:43
  de travail,
• 7:44
  ils n'ont pas les informations qu'il faut,
• 7:46
  ou alors ces informations,
• 7:48
  ils sont obligés,
• 7:48
  comme nous,
• 7:49
  d'aller les chercher dans 15 endroits différents,
• 7:51
  ou alors ils n'ont techniquement rien qui leur permette de produire le livrable dont ils ont besoin,
• 7:56
  que ce soit un document,
• 7:56
  que ce soit un PDF,
• 7:57
  que ce soit un...
• 7:59
  pas importe le livrable final,
• 8:02
  quelque part,
• 8:03
  le besoin,
• 8:03
  il part de là.
• 8:04
  Et donc ça,
• 8:05
  c'est une approche de recueillir tout simplement ce qui a été constaté dans une boîte.
• 8:11
  Donc soit parce que la solution n'existe pas,
• 8:13
  soit parce que la solution,
• 8:14
  aujourd'hui,
• 8:15
  elle a été bricolée.
• 8:16
  C'est pour ça qu'on a beaucoup de gens qui utilisent du Excel et qui le détournent ou qui utilisent d'autres outils qu'ils ont à disposition dans l'entreprise et qui vont gruger un petit peu comme ils peuvent dans les différents bouts.
• 8:28
  pour les tordre au mieux et arriver à leur fin.
• 8:32
  Parce qu'à partir du moment où ils n'ont pas l'outil adapté,
• 8:35
  il faut quand même réussir à bosser.
• 8:38
  Et ils vont employer un petit peu tous les moyens à leur disposition pour y arriver.
• 8:43
  Et après,
• 8:43
  il y a le contexte d'éditeurs de logiciels ou de startups,
• 8:46
  peut-être plus propres aux startups ou aux boîtes qui vont démarrer,
• 8:49
  qui vont identifier un besoin qui n'est pas encore couvert par le marché,
• 8:55
  soit qui est...
• 8:56
  partiellement couvert par le marché ou pas de la bonne manière ou alors,
• 8:59
  parce qu'en fait la plupart des besoins dans les boîtes ils sont là depuis très longtemps,
• 9:02
  c'est juste la manière d'y répondre qui va être différente et un point de vue,
• 9:06
  un angle,
• 9:07
  une façon de le faire,
• 9:08
  une technologie nouvelle,
• 9:10
  une interface plus simple enfin voilà,
• 9:11
  il y a plein de choses pour l'amener,
• 9:14
  mais qui va être de repenser le problème d'une manière différente.
• 9:17
  Si on prend des gros outils,
• 9:18
  pour essayer d'aller dans un peu plus de concret,
• 9:20
  des suites logicielles comme
• 9:22
  Word.
• 9:24
  ont apporté de la bureautique pendant très longtemps à travers le classique éditeur de texte,
• 9:30
  le tableur et le PowerPoint,
• 9:34
  l'éditeur de diaporama.
• 9:36
  Google a un peu renversé tout ça quand il a apporté le collaboratif à l'époque de Google Drive et de la suite Google.
• 9:43
  Donc d'un coup,
• 9:44
  on s'est rendu compte qu'on n'avait plus besoin d'installer ces programmes-là sur son ordinateur et que chacun ait sa licence et tout ça pour travailler.
• 9:50
  Mais on pouvait passer,
• 9:51
  même s'il y avait aussi un système de licence.
• 9:53
  mais on pouvait passer directement par des outils en ligne,
• 9:56
  via internet,
• 9:57
  sans avoir à rien installer,
• 9:59
  et quand même avoir du collaboratif où tout le monde travaillait en temps réel sur le même document,
• 10:02
  on voyait les gens interagir.
• 10:04
  Et voilà,
• 10:05
  ça a été une nouvelle façon déjà d'appréhender la suite bureautique avec un aspect neuf.
• 10:10
  Et
• 10:12
  Notion, prononcez-le comme vous voulez,
• 10:15
  l'a apporté encore d'une manière différente plus tard,
• 10:17
  avec cette idée de partir d'une page blanche,
• 10:22
  d'avoir un header qui soit beaucoup plus simple qu'un Word,
• 10:25
  et en même temps d'intégrer dedans des petites bases de données qui ressemblent à des tableaux,
• 10:29
  donc c'est assez familier pour qu'on les prenne en main.
• 10:32
  mais où on va être sur des bases de données relationnelles,
• 10:34
  et du coup chaque tableau,
• 10:36
  chaque colonne ne sera pas un simple,
• 10:39
  ne sera pas que du chiffre,
• 10:41
  sera moins rigide et mieux pensé qu'un Excel,
• 10:45
  ce ne sont pas les mêmes finalités.
• 10:46
  Mais vous voyez qu'à travers ces trois exemples,
• 10:49
  on a trois visions différentes d'une suite bureautique,
• 10:53
  et qui ont évolué forcément à travers les technologies,
• 10:56
  et les phases d'évolution,
• 10:57
  et la prise en main aussi des gens.
• 10:59
  Peut-être qu'un Notion à l'époque de Microsoft Office n'aurait pas du tout fonctionné parce qu'il aurait été trop avant-gardiste.
• 11:04
  Il y a aussi toute une logique quand même de répondre à un besoin,
• 11:07
  mais d'une manière que les gens sont aussi en mesure de s'en saisir et de le prendre en main.
• 11:12
  D'ailleurs,
• 11:13
  les premières versions de Notion n'étaient pas bonnes en termes d'expérience utilisateur et ont dû être repensées.
• 11:18
  Donc généralement,
• 11:19
  quand vous avez un programme aussi dans les mains,
• 11:21
  ne vous dites jamais qu'il est arrivé comme ça,
• 11:23
  tel quel déjà prêt.
• 11:25
  Il est passé par plein de phases en amont.
• 11:27
  Au début,
• 11:28
  c'était probablement une version brouillon,
• 11:30
  un peu éclatée,
• 11:31
  que personne ne comprend,
• 11:32
  avant qu'on identifie ce qui va et ce qui ne va pas dedans,
• 11:35
  pour que ça arrive à quelque chose de propre et d'agréable à utiliser.
• 11:39
  Et voilà.
• 11:41
  Tout ça pour en revenir aux besoins,
• 11:42
  c'est que ça part justement de quelque chose qui est concret,
• 11:46
  et qu'on va pouvoir,
• 11:47
  comme disait Lulu,
• 11:48
  le peaufiner et mieux l'interpréter,
• 11:51
  le comprendre,
• 11:52
  à travers des discussions,
• 11:53
  les fameuses discussions qu'on appelle avec les métiers.
• 11:56
  Donc là,
• 11:56
  ça peut prendre des formes d'atelier métier,
• 11:58
  d'entretien métier.
• 11:59
  Le but,
• 12:00
  c'est de mettre des gens dans la même pièce ou d'interagir et de discuter directement avec des responsables qui font ce boulot au quotidien et qui sont les premiers concernés.
• 12:09
  Ça ou l'étude de marché aussi ?
• 12:14
  Si le produit est destiné pas forcément à une entreprise,
• 12:18
  mais plus à des utilisateurs lambda,
• 12:21
  on peut...
• 12:22
  Oui,
• 12:23
  mais est-ce que...
• 12:23
  Je ne sais pas si on les appellera des métiers,
• 12:25
  les gens,
• 12:26
  si c'est par exemple du SaaS.
• 12:28
  Oui,
• 12:28
  ça dépend,
• 12:29
  effectivement.
• 12:29
  Si tu t'adresses à du particulier ou à de l'entreprise,
• 12:31
  mais en tout cas,
• 12:32
  voilà.
• 12:33
  Il faut discuter avec des gens.
• 12:35
  C'est ça.
• 12:35
  À un moment ou à un autre,
• 12:36
  il faut parler avec des gens qui vont avoir besoin,
• 12:39
  enfin,
• 12:40
  celles et ceux pour qui vous voulez créer le produit et répondre aux besoins.
• 12:45
  Il n'y a pas de meilleur moyen de comprendre leurs problèmes qu'en parlant avec eux.
• 12:50
  Ou après,
• 12:50
  il y a des phases d'observation aussi qui peuvent être faites.
• 12:53
  Donc,
• 12:53
  typiquement...
• 12:53
  dans des contextes d'entreprise,
• 12:55
  d'aller voir un peu comment les gens bossent au quotidien et de se rendre compte qu'ils font du Excel,
• 12:58
  qu'ils font de tels outils bricolés.
• 13:01
  Et c'est là qu'on va voir encore davantage les petites failles et comment ils y auront répondu dans l'immédiat et se dire que c'est des pistes de réflexion,
• 13:10
  de se dire,
• 13:10
  en fait,
• 13:10
  il a pensé à sa solution de telle manière,
• 13:13
  ce qui pourrait sembler complètement pas efficient quand on le voit de l'extérieur,
• 13:17
  mais du coup,
• 13:17
  qui va donner des indices sur la manière dont les gens bossent et pensent leur solution.
• 13:22
  Il va y avoir d'autres approches aussi.
• 13:23
  Donc,
• 13:24
  tu l'as dit,
• 13:24
  la partie études de marché,
• 13:25
  études de l'existant.
• 13:27
  Il y a déjà plein de concurrents,
• 13:28
  il y a plein d'outils.
• 13:29
  On va mettre les mains dedans.
• 13:31
  Et d'ailleurs,
• 13:32
  ça que ce soit dans toutes les logiques produits,
• 13:36
  et quand on pense des nouvelles fonctionnalités,
• 13:38
  quand on va améliorer un logiciel,
• 13:41
  ou le concevoir de toutes pièces aussi,
• 13:42
  on va forcément mettre les mains dans les logiciels qui se rapprochent le plus sur le marché et voir un peu ce qu'ils proposent et ce qu'ils ne proposent pas.
• 13:50
  En fait,
• 13:50
  c'est aussi un des points de compréhension du besoin,
• 13:54
  de se dire que la plupart des acteurs ont mis en avant tel sujet et telle manière d'y répondre,
• 14:00
  parce qu'en fait,
• 14:00
  ils s'adressent,
• 14:01
  je viens de bêtiser,
• 14:02
  tous et toutes aux PME et aux grosses boîtes.
• 14:04
  Mais en fait,
• 14:05
  ce même problème existe chez les TPE,
• 14:07
  et personne ne l'a traité aujourd'hui,
• 14:08
  parce que c'était peut-être trop galère à faire,
• 14:11
  ou trop compliqué,
• 14:11
  ou machin,
• 14:12
  alors qu'il y a un autre angle,
• 14:14
  alors qu'il y a une autre manière d'envisager le problème.
• 14:17
  Et ce n'est pas parce qu'on a...
• 14:19
  un problème,
• 14:21
  nous,
• 14:22
  que ça veut dire qu'il faut forcément faire un produit,
• 14:24
  il faut le confronter,
• 14:25
  c'est pas forcément une phase agréable parce qu'on va se prendre des retours,
• 14:30
  ça va potentiellement modifier l'idée qu'on pouvait avoir de notre solution parce qu'on a souvent tendance à penser directement aux solutions de comment notre application,
• 14:38
  elle,
• 14:38
  pourra faire,
• 14:39
  machin,
• 14:39
  et que au final,
• 14:41
  des fois,
• 14:41
  la solution,
• 14:42
  elle pourrait être beaucoup plus simple,
• 14:44
  moins waouh,
• 14:45
  enfin...
• 14:47
  Et juste d'aller confronter et de se rendre compte que peut-être il y a déjà des solutions qui existent et on peut être tout seul à avoir ce problème.
• 14:55
  Alors c'est assez rare,
• 14:56
  mais ça ne vaut pas le coup de sortir tout de suite le développement,
• 15:00
  de partir à l'étape d'après.
• 15:03
  C'est presque l'étape-là qui est...
• 15:06
  la plus importante,
• 15:08
  alors les autres le sont aussi,
• 15:09
  mais toutes les autres,
• 15:10
  aussi bien qu'elles seront exécutées,
• 15:14
  si la base n'est pas solide,
• 15:15
  parce que si on définit mal un besoin et qu'on se rend compte finalement qu'il y a telle fonctionnalité,
• 15:20
  enfin,
• 15:21
  pas fonctionnelle,
• 15:21
  parce qu'il y a aussi le côté fonctionnel,
• 15:23
  non fonctionnel qu'il faut séparer,
• 15:26
  mais si on se rend compte que finalement il faut qu'on ajuste quelque chose,
• 15:29
  c'est beaucoup plus facile au stade de découverte et de...
• 15:35
  pour définir le besoin et les problèmes,
• 15:38
  qu'au moment où tout est développé,
• 15:39
  il y a des dépendances,
• 15:42
  il faut changer du code et potentiellement des choses qui vont coûter très cher.
• 15:46
  C'est un peu comme passer par un architecte avant de se lancer dans une construction,
• 15:52
  une grosse rénovation.
• 15:53
  Il va faire des plans.
• 15:54
  Peut-être que les plans ne seront pas suivis au millimètre près,
• 15:57
  mais ça donne déjà une idée de l'ordre d'exécution,
• 16:00
  de se projeter aussi.
• 16:01
  Et que si on se dit,
• 16:02
  ah bah tiens,
• 16:03
  finalement,
• 16:04
  je vois...
• 16:05
  plus ma cloison comme ça,
• 16:06
  la cloison,
• 16:07
  on va juste la déplacer un peu dans un logiciel où on gomme et puis on refait notre cloison.
• 16:13
  Alors qu'une fois que c'est monté et qu'on est là et que tout est fait,
• 16:16
  on se dit,
• 16:17
  c'est vrai que ça aurait été bien un peu différemment.
• 16:20
  C'est pareil dans un logiciel,
• 16:21
  il ne suffira pas non plus de juste prompter et dire,
• 16:25
  finalement,
• 16:26
  mon interface,
• 16:27
  je la verrai complètement différente qui va faire aussi modifier complètement le back-end.
• 16:32
  Voilà,
• 16:33
  c'est important.
• 16:34
  Oui,
• 16:35
  mais j'aime bien la métaphore,
• 16:36
  parce qu'effectivement,
• 16:36
  c'est plus facile de pincer les murs à l'avance que de les monter une fois,
• 16:40
  se rendre compte que la moitié ne va pas,
• 16:41
  les casser et les refaire différemment.
• 16:44
  Surtout quand tu vois toutes les couches qui se rajoutent par-dessus,
• 16:47
  ou peut-être elle,
• 16:48
  j'ai fait ta trichoterie,
• 16:50
  ou c'est comme par exemple de se dire,
• 16:53
  tiens,
• 16:53
  dans cette pièce,
• 16:54
  je veux mes prises ici,
• 16:55
  Si on ne se dit pas où est-ce qu'on va penser nos meubles,
• 16:58
  alors ça demande de se projeter pas mal et ce n'est pas ce qu'il y a de plus confortable,
• 17:03
  ça demande pas mal d'énergie.
• 17:05
  Mais il faut savoir qu'il y aura toujours des choses qui vont se passer pas comme prévu.
• 17:09
  Donc tout ce qu'on peut prévoir au départ,
• 17:12
  ça sera de l'argent et du temps gagné pour après.
• 17:17
  Effectivement.
• 17:18
  Et à garder en tête qu'en fait,
• 17:21
  plus tôt vous allez,
• 17:23
  plus vous avez d'infos au départ,
• 17:26
  plus les étapes d'après vont être fluides et pertinentes,
• 17:30
  plus vous bâclez ou vous...
• 17:33
  Prenez pas le temps de réfléchir vraiment aux besoins initiaux et comment on peut y répondre de la manière la plus simple possible.
• 17:40
  Comme disait Lulu,
• 17:40
  plus derrière,
• 17:41
  vous risquez d'avoir un espèce d'effet qui va se décupler en termes d'efforts,
• 17:46
  en termes de temps,
• 17:47
  en termes d'impact et où chaque chose à reprendre sera beaucoup plus galère à faire derrière.
• 17:54
  En soi,
• 17:54
  oui,
• 17:54
  une prise,
• 17:55
  on peut en rajouter un endroit,
• 17:56
  mais ça veut dire refaire une saignée potentiellement dans le mur qui est tout propre,
• 18:01
  qui est tout beau avec...
• 18:03
  le placo qui est déjà mis,
• 18:04
  la plomberie,
• 18:05
  mince,
• 18:06
  on s'en a saigné,
• 18:06
  on tape dans un tuyau.
• 18:09
  Autant imaginer,
• 18:10
  essayer d'imaginer de se projeter dès le départ,
• 18:12
  quitte à passer un peu plus de temps.
• 18:14
  C'est vrai que les personnes techniques ou même les clients ont vite envie de voir quelque chose et d'attaquer le développement,
• 18:22
  parce que c'est là que le projet commence vraiment.
• 18:25
  Et ça peut paraître un peu long,
• 18:27
  cette phase de...
• 18:29
  Demandez de comprendre les process,
• 18:31
  l'entreprise,
• 18:31
  parce qu'aussi,
• 18:32
  il y a un moment où il faudra arrêter et de se dire,
• 18:35
  OK,
• 18:36
  notre produit devra ressembler à ça.
• 18:39
  Et de bien le penser pour que quand même,
• 18:41
  s'il y a des choses qui doivent se rajouter,
• 18:44
  ça puisse se rajouter après dans une deuxième version.
• 18:47
  Mais on ne peut pas non plus juste rajouter au fil de l'eau.
• 18:50
  Il faut quand même imaginer un produit fini et s'y tenir.
• 18:53
  Là,
• 18:55
  on est en train de glisser déjà dans la phase d'après,
• 18:57
  qui est l'étape de conception.
• 18:59
  On va commencer à baliser un petit peu effectivement cette notion de version et des choses qu'on vous a expliquées la dernière fois.
• 19:07
  Juste pour terminer sur cette étape recueil de besoins,
• 19:10
  justement,
• 19:10
  tu l'as évoqué rapidement,
• 19:13
  qu'on doit distinguer justement ce qui est du fonctionnel du non fonctionnel.
• 19:18
  Est-ce que tu peux nous clarifier ça un peu ?
• 19:20
  Le fonctionnel,
• 19:22
  par définition,
• 19:23
  c'est vraiment ce que le système va faire.
• 19:26
  Et le non fonctionnel,
• 19:28
  c'est comment il va le faire.
• 19:29
  Et ça,
• 19:29
  on en avait parlé justement dans l'épisode précédent.
• 19:32
  Toute la phase de
• 19:33
  PRD et les user stories,
• 19:36
  ça va vraiment être dans le fonctionnel.
• 19:39
  Et le non fonctionnel arrive seulement après.
• 19:42
  Ouais.
• 19:44
  En fait,
• 19:44
  disons,
• 19:45
  quand on va réfléchir à nos besoins,
• 19:49
  et prendre les infos et discuter avec les gens,
• 19:51
  etc.,
• 19:51
  on va d'abord se concentrer sur le fonctionnel.
• 19:53
  Donc en gros,
• 19:54
  qu'est-ce que...
• 19:55
  le logiciel doit faire pour répondre à leurs besoins et le non fonctionnel ce sera l'envers du décor et la partie un peu plus technique un peu plus galère de se dire ok
• 20:05
  Ils ont besoin d'un logiciel qui leur permet de cliquer et de faire telle et telle action.
• 20:10
  Mais en fait,
• 20:11
  est-ce qu'ils en ont besoin sur leur ordinateur en ligne,
• 20:15
  sur leur tablette,
• 20:15
  sur leur téléphone ?
• 20:16
  Est-ce qu'ils peuvent se passer du réseau ou pas ?
• 20:21
  Des points comme ça qui vont déterminer après la partie technique qui va être un peu tous les à côté,
• 20:24
  sur l'architecture,
• 20:25
  sur les langages,
• 20:26
  sur l'infrastructure,
• 20:27
  enfin un certain nombre de choses.
• 20:29
  Là où le fonctionnel,
• 20:30
  c'est vraiment dans le quotidien de la personne.
• 20:32
  qu'est-ce qui doit se faire
• 20:34
  avoir à disposition pour que ça marche et que ça...
• 20:37
  Qu'est-ce qu'il y a avant et qu'est-ce qu'il y a après l'utilisation,
• 20:40
  mais sans passer par le comment on va faire pour transformer l'avant et l'après.
• 20:47
  C'est ça.
• 20:48
  Et donc,
• 20:49
  tu l'as dit rapidement,
• 20:50
  l'étape d'après,
• 20:51
  ça va être la partie conception.
• 20:54
  Et là-dessus,
• 20:55
  n'hésitez pas à revenir,
• 20:57
  on vous renvoie vers notre épisode précédent et on va passer un peu rapidement sur ces points-là.
• 21:03
  Mais c'est là en fait où on va s'attaquer au fameux PRD,
• 21:06
  au User Story.
• 21:07
  Donc le PRD en gros c'est le cahier des charges fonctionnel.
• 21:09
  Donc si vous avez bien fait votre affornement et pris toutes les infos,
• 21:12
  vous allez pouvoir le traduire en une espèce de cahier des charges qui va décrire les parcours utilisateurs qui sont souhaités,
• 21:19
  qui va permettre aussi de décrire justement ce qu'on appelle les User Story.
• 21:23
  Donc de dire chaque profil dans mon application,
• 21:28
  que ce soit un administrateur,
• 21:29
  que ce soit un utilisateur,
• 21:30
  que ce soit un...
• 21:32
  super manager,
• 21:32
  etc.,
• 21:33
  chaque niveau de profil doit pouvoir faire des choses différentes dans le programme et on va lister en fait chaque chose qu'il doit faire dans le programme.
• 21:42
  C'est-à-dire,
• 21:43
  il faut qu'il puisse valider un formulaire,
• 21:45
  il faut qu'il puisse rajouter une nouvelle entrée de tel élément,
• 21:49
  il faut qu'il puisse imprimer tel document,
• 21:51
  il faut qu'il puisse télécharger telle chose,
• 21:54
  il faut qu'il puisse avoir telle information à disposition,
• 21:58
  et ainsi de suite.
• 22:01
  Encore une fois,
• 22:01
  on parle un petit peu plus de ces deux points dans l'épisode précédent,
• 22:04
  on vous y renvoie.
• 22:05
  Là,
• 22:05
  l'idée,
• 22:05
  c'est que vous ayez vraiment juste la logique de se dire à chaque fois,
• 22:07
  on passe par ces points-là.
• 22:09
  Et c'est ça qui va commencer à nous permettre de déterminer les différents briques,
• 22:16
  de déterminer les différents éléments techniques dont on va avoir besoin pour aller plus loin et avant de se lancer vraiment dans le développement.
• 22:24
  C'est ça,
• 22:24
  c'est vraiment,
• 22:25
  on va traduire les besoins en architecture.
• 22:27
  Enfin voilà,
• 22:28
  quelles briques ?
• 22:29
  comment ces briques vont communiquer entre elles,
• 22:32
  où vont être les données.
• 22:35
  C'est là où il y a un concept de cohésion forte-couplage faible,
• 22:45
  où chaque brique va faire une seule chose,
• 22:48
  et elle va dépendre le moins possible des autres,
• 22:50
  mais après il va y avoir ce travail de les mettre ensemble pour qu'elles fonctionnent bien.
• 22:55
  En fait,
• 22:56
  la partie...
• 22:57
  Plage fort,
• 22:58
  par exemple,
• 22:58
  pour donner une image,
• 23:00
  c'est comme si tout est un peu soudé et après,
• 23:01
  une fois que c'est mis en place et qu'on veut enlever un élément ou modifier un élément,
• 23:05
  ça va forcément impacter ce qu'il y a autour.
• 23:10
  Mais le coup plage faible,
• 23:12
  ça va être plutôt on va se mettre un rôle par brique et ça sera plus simple de les faire.
• 23:18
  C'est un peu comme ça où ça fonctionne dans certaines boîtes en feature.
• 23:22
  Et après,
• 23:23
  le but,
• 23:24
  c'est de faire de l'assemblage.
• 23:27
  Oui,
• 23:27
  je suis en train de réfléchir à justement si j'avais...
• 23:29
  parce que ça me fait toujours penser aux bases de données,
• 23:31
  aux bases de données relationnelles.
• 23:33
  Oui.
• 23:34
  Mais j'essaie de retrouver un exemple qui soit facile à vous donner.
• 23:39
  Mais en fait,
• 23:40
  l'idée de ce système de briques,
• 23:43
  c'est comme dans un système d'informations,
• 23:44
  justement une base de données où vous allez ranger les informations.
• 23:48
  C'est de se dire que chaque élément,
• 23:50
  dans la mesure du possible,
• 23:52
  doit être indépendant,
• 23:53
  quitte à ce qu'il soit relié les uns les autres.
• 23:55
  mais pour que quand vous allez toucher un point,
• 23:58
  vous n'ayez pas à toucher à tout le reste.
• 24:02
  Surtout si cet élément est amené à bouger,
• 24:05
  ou qu'on va devoir y tirer dessus.
• 24:08
  Si on sait dès le départ qu'il ne va pas rester fixe tel quel,
• 24:11
  il faut autant que possible faire en sorte qu'on puisse le modifier après coup,
• 24:15
  sans impacter toutes les autres fonctionnalités.
• 24:19
  Oui,
• 24:20
  et je donne un exemple un peu cassé avec l'adresse.
• 24:25
  Mais ici on peut reprendre l'adresse.
• 24:27
  En fait,
• 24:27
  par exemple,
• 24:28
  votre adresse,
• 24:28
  ce n'est pas un seul bloc.
• 24:31
  Ça va être plusieurs éléments et si vous allez justement sur n'importe quel formulaire de l'administration et que vous avez besoin de remplir des papiers ou de vous inscrire je ne sais où,
• 24:39
  à chaque fois vous allez voir que vous allez dissocier votre code postal de la ville,
• 24:44
  vous allez dissocier le numéro de votre rue,
• 24:48
  de votre avenue,
• 24:49
  le type de rue ou d'avenue.
• 24:50
  Vous allez voir ensuite l'intitulé de votre avenue.
• 24:53
  Si vous êtes sur un immeuble,
• 24:54
  vous allez voir aussi des étages.
• 24:56
  Vous avez vu qu'en fait,
• 24:57
  toutes ces informations sont à chaque fois séparées.
• 25:00
  Puisque ça va permettre de mettre à jour les différentes informations et les différentes briques qu'il y a derrière de manière indépendante sans avoir à...
• 25:07
  changer toute votre adresse à chaque fois.
• 25:10
  Désolé,
• 25:10
  je ne sais pas si l'exemple est très parlant.
• 25:11
  Enfin,
• 25:12
  visuellement aussi,
• 25:12
  vous voyez un peu le découpage.
• 25:14
  Et en fait,
• 25:14
  il faut vous dire que dans une base de données,
• 25:16
  ça va être le même principe.
• 25:17
  Et après,
• 25:18
  quand vous allez mettre en place des fonctionnalités dans un logiciel,
• 25:21
  ça va être un petit peu la même logique.
• 25:23
  C'est-à-dire qu'on va essayer d'avoir le plus de...
• 25:28
  Comment dire ?
• 25:30
  On va essayer de ne pas réinventer la roue à chaque fois.
• 25:31
  Ah,
• 25:31
  nid de l'huile.
• 25:33
  Globalement,
• 25:33
  en fait,
• 25:33
  c'est ça.
• 25:34
  C'est de se dire qu'aujourd'hui,
• 25:35
  par exemple,
• 25:36
  j'arrive sur une page web où vous avez différents boutons,
• 25:41
  vous avez plusieurs,
• 25:43
  je ne sais pas,
• 25:44
  vous avez deux tableaux,
• 25:45
  mettons,
• 25:45
  vous avez plusieurs informations au même endroit.
• 25:48
  Tout ça,
• 25:48
  si c'est un seul,
• 25:50
  une seule entité,
• 25:52
  un seul bloc,
• 25:52
  un seul élément,
• 25:53
  et que vous avez besoin de changer juste la couleur de votre bouton,
• 25:57
  en fait,
• 25:57
  potentiellement,
• 25:58
  la couleur de votre bouton est par exemple le lien qui va derrière.
• 26:02
  si tout ça est un seul élément vous avez besoin de retoucher l'entièreté et donc de ça a plein d'applications techniques derrière qui rendent le truc galère alors que si le bouton il est isolé et peut-être même encore mieux d'ailleurs on va prendre le bouton mais d'une manière différente vous
• 26:17
  avez un bouton validé qui est partout dans votre application votre site internet si vous avez un bouton justement qui est indépendant et qui est mutualisé vous allez réutiliser un peu partout si vous changez la couleur à un endroit ça va la changer partout si votre bouton
• 26:30
  il est intégré dans d'autres blocs,
• 26:32
  dans d'autres éléments,
• 26:33
  et qu'il n'est pas indépendant,
• 26:35
  vous allez devoir aller sur chaque page de votre site Internet pour changer la couleur de votre bouton.
• 26:40
  Et c'est un peu tout comme ça,
• 26:41
  globalement.
• 26:42
  Là,
• 26:42
  c'est bien visuel,
• 26:44
  mais c'est là où on dit qu'il ne faut pas le coder en dur,
• 26:48
  et qu'il y a un peu le côté où on va mettre en place des variables qui permettent de changer tout d'un coup.
• 26:56
  Par exemple,
• 26:56
  une charte graphique qui est peut-être amenée à bouger.
• 26:59
  C'est bien de la dissocier de tout le reste et de se dire,
• 27:03
  « Bon,
• 27:04
  bah tiens,
• 27:04
  telle couleur,
• 27:05
  si je la modifie ici,
• 27:06
  ça va la modifier partout dans mon appli,
• 27:11
  dans mon site. »
• 27:11
  Parce que sinon,
• 27:12
  aller remodifier tout à la main,
• 27:15
  c'est impossible.
• 27:16
  Ça,
• 27:17
  c'est aussi quelque chose qu'il faut garder en tête et à laquelle il faut faire attention.
• 27:20
  Parce que ça peut coûter cher.
• 27:22
  Sur le coup,
• 27:22
  on se dit,
• 27:22
  « Ah ouais,
• 27:23
  mon bouton,
• 27:23
  il est bien de cette couleur-là,
• 27:24
  c'est bien,
• 27:25
  la police,
• 27:25
  elle est bien. »
• 27:26
  Et arrivé à la fin,
• 27:27
  on a plein,
• 27:28
  plein de boutons et on se dit,
• 27:29
  « Ah,
• 27:29
  mais c'est vrai qu'un tout petit peu plus gros,
• 27:31
  ça serait pratique. »
• 27:32
  Oui,
• 27:33
  s'il faut aller le faire 20 fois ou 30 fois sur chaque bout d'eau.
• 27:38
  Oui,
• 27:39
  par exemple,
• 27:39
  pour reprendre un exemple que nous,
• 27:40
  on a eu sur notre portail à nous en interne,
• 27:44
  c'est qu'on a plusieurs endroits dans notre portail qui nous permettent de rédiger du texte.
• 27:48
  Puisqu'il y a un endroit où on va préparer la trame de l'épisode,
• 27:51
  on va écrire dedans.
• 27:51
  Il y a des endroits où on va rédiger le texte qui va servir à la diffusion de ce podcast et qui sera présent sur un groupe.
• 27:57
  qu'on va renvoyer sur Ausha et qui arrivera dans votre Spotify,
• 28:00
  dans votre YouTube,
• 28:00
  etc.
• 28:01
  On a un autre endroit où on va pouvoir préparer le texte,
• 28:03
  on va le mettre sur LinkedIn,
• 28:04
  et ainsi de suite.
• 28:05
  On a plein d'endroits comme ça.
• 28:07
  Et là,
• 28:07
  l'idée,
• 28:07
  plutôt que d'avoir là aussi plein de briques du coup indépendantes,
• 28:13
  mais chacun sur leur interface,
• 28:14
  on va dire ça comme ça,
• 28:16
  on a pensé la mutualisation,
• 28:18
  et donc j'ai un éditeur qui va être réutilisé un petit peu partout et qui va partager des fonctionnalités.
• 28:23
  Et dans des cas particuliers,
• 28:25
  lui soit il va être
• 28:26
  il y aura une déclinaison différente de lui,
• 28:29
  soit ce sera complètement un autre éditeur,
• 28:32
  si jamais vraiment on est sur un cas très spécifique et très particulier.
• 28:35
  Mais on va toujours penser,
• 28:36
  voilà,
• 28:37
  tout ce qu'on fait dans une application,
• 28:38
  dans les interfaces,
• 28:39
  on va le penser en système de briques,
• 28:40
  avec qu'est-ce qui est commun,
• 28:41
  qu'est-ce qui est réutilisable,
• 28:43
  qu'est-ce qui vaut mieux dès maintenant,
• 28:45
  penser pour être réutilisé un petit peu partout dans l'application,
• 28:48
  plutôt que de faire que des petits morceaux et de devoir repasser partout à chaque fois qu'il y a une modif,
• 28:53
  et du coup de faire des bêtises.
• 28:55
  Parce que là,
• 28:55
  c'est vrai qu'on est sur du visuel,
• 28:57
  mais si on a une application et qu'on développe,
• 29:00
  par exemple,
• 29:01
  une fonction qui va faire quelque chose,
• 29:02
  on ne va pas avoir plein de fois cette fonction différente.
• 29:06
  Parce que même après,
• 29:07
  en termes de performance,
• 29:08
  ce n'est pas ce qu'il y a de plus efficient non plus.
• 29:10
  Et là,
• 29:11
  ça peut se ressentir au-delà juste du visuel.
• 29:14
  Oui,
• 29:15
  c'est que concrètement,
• 29:16
  si vous avez
• 29:16
  10 pages dans votre outil de tous les jours et que vous avez 10 fois les mêmes choses,
• 29:22
  en fait,
• 29:22
  ça va ramer vachement plus que si vous l'aviez une fois.
• 29:25
  et que c'était la même chose qui était réutilisée un petit peu partout.
• 29:27
  Et c'est plus simple de le penser dès le départ que de se dire après coup,
• 29:30
  comment est-ce que j'optimise mon application ?
• 29:34
  Et là où le raccourci qui peut être fait souvent,
• 29:37
  enfin souvent,
• 29:38
  pas souvent,
• 29:38
  mais en tout cas selon les philosophies,
• 29:40
  selon les cas,
• 29:41
  ça peut être un mauvais réflexe,
• 29:43
  on va dire,
• 29:44
  de se dire bon,
• 29:44
  j'ai envie de sortir vite une nouvelle chose,
• 29:47
  une nouvelle fonctionnalité,
• 29:49
  de vouloir aller au plus court.
• 29:50
  Et souvent,
• 29:50
  le chemin le plus court,
• 29:51
  c'est d'aller pas penser en termes de mutier.
• 29:54
  de mutualisation et de réutilisation.
• 29:57
  et de faire juste la chose la plus simple possible.
• 30:03
  Mais du coup,
• 30:04
  ça a des implications derrière,
• 30:05
  parce qu'une fois qu'on va commencer à empiler des choses là-dessus,
• 30:09
  c'est d'autant plus dur.
• 30:10
  On en revient à l'exemple de tout à l'heure avec le coup de la maison.
• 30:13
  C'est que typiquement,
• 30:16
  si vous faites une canalisation un petit peu à l'arrache,
• 30:19
  et que le reste suit,
• 30:21
  vous allez commencer à mettre votre sol par-dessus.
• 30:24
  du coup vos meubles,
• 30:25
  votre tapis,
• 30:25
  vos machins et qu'après vous vous rendez compte qu'en fait il faut refaire toutes les canalisations parce que vous en avez pensé qu'une et qu'il en fallait trois,
• 30:31
  vous allez devoir littéralement tout virer et tout reprendre pour ensuite aller faire les différents chemins derrière.
• 30:37
  Alors ça n'impliquera pas de tout recasser mais en tout cas de tout bouger.
• 30:40
  Ou de faire du bricolage et de ne pas faire aussi bien que si ça avait été pensé dès le départ.
• 30:44
  Et aussi optimiser,
• 30:46
  voilà.
• 30:46
  Ça demande de prendre en compte l'existant,
• 30:48
  de ne pas tout enlever.
• 30:51
  Alors dans tous les cas,
• 30:52
  Enfin voilà.
• 30:53
  On ne peut pas tout prévoir,
• 30:56
  mais il faut quand même se poser.
• 31:01
  Là,
• 31:01
  juste pour passer aussi un peu à la partie d'après,
• 31:03
  parce qu'au final,
• 31:04
  on parle,
• 31:05
  on parle.
• 31:06
  Là,
• 31:06
  je pense que tu seras peut-être plus apte à en parler,
• 31:08
  tout ce qui est développement et versionnage.
• 31:10
  Parce que c'est vrai que maintenant,
• 31:11
  avec le développement assisté par IA,
• 31:13
  le vibe coding,
• 31:15
  on parle beaucoup de Git et GitHub sans forcément savoir ce que ça implique.
• 31:21
  comment ça fonctionne et pourquoi c'est utile aussi.
• 31:25
  Oui.
• 31:26
  Alors,
• 31:27
  on va reprendre dans l'ordre.
• 31:29
  Donc,
• 31:30
  jusque-là,
• 31:32
  d'accord,
• 31:33
  on a été parler avec des gens,
• 31:34
  on a trouvé un problème,
• 31:36
  on a identifié du coup qu'est-ce qui pourrait y répondre.
• 31:39
  À partir de là,
• 31:40
  on s'est posé pour réfléchir à de quoi on a besoin dans notre application pour répondre à ce problème et on a pensé un petit peu les interfaces et tout ça.
• 31:50
  Donc normalement arrivé à ce moment là,
• 31:51
  on a un petit peu tout sur papier ou sur numérique,
• 31:54
  on a une maquette,
• 31:55
  on a plein de cahiers de décharge,
• 31:56
  on a plein d'informations.
• 31:58
  On voit vraiment ce qu'on veut faire et on voit vraiment les interfaces,
• 32:03
  donc grosso modo ce qu'on veut vous mettre dans les mains pour que vous puissiez vous en servir.
• 32:08
  Maintenant,
• 32:09
  il va falloir s'attaquer au développement.
• 32:11
  Mais le développement,
• 32:13
  je vais prendre le cas d'une équipe avec plusieurs personnes pour que ce soit un peu plus prudent.
• 32:19
  si chacun...
• 32:20
  doit bosser.
• 32:21
  En mettant que vous avez trois développeurs et développeuses,
• 32:24
  ces trois personnes vont devoir travailler.
• 32:26
  Elles ne vont pas pouvoir bosser sur le même sujet en même temps.
• 32:29
  Puisque techniquement,
• 32:31
  en fait,
• 32:32
  ça ne va pas le faire.
• 32:34
  L'intercom de l'analogie d'un document partagé en ligne où on veut travailler tous sur le même paragraphe en écrivant,
• 32:42
  effaçant,
• 32:44
  c'est juste impossible.
• 32:46
  Oui,
• 32:46
  voilà,
• 32:46
  exactement.
• 32:47
  Ça ne marchera pas.
• 32:47
  Il faut se séparer,
• 32:48
  se dire dans ce document,
• 32:50
  On a trois parties,
• 32:51
  chacun va bosser sur une partie.
• 32:53
  Et voilà,
• 32:55
  ça va être le postulat de départ.
• 32:57
  Mais pour que ça puisse fonctionner,
• 32:59
  et que chacun puisse bosser de son côté sur sa partie,
• 33:02
  et qu'on puisse après tout réunifier en un seul document,
• 33:06
  il faut mettre en place un protocole,
• 33:08
  et on va mettre en place ce qu'on appelle un protocole qui permet de faire du versionnage,
• 33:13
  et un des plus utilisés aujourd'hui,
• 33:15
  c'est Git.
• 33:16
  Alors je ne vais pas rentrer dans l'historique maintenant,
• 33:18
  déjà parce que je ne l'ai plus trop en tête.
• 33:20
  mais en gros ce protocole va être très utilisé notamment par GitHub et GitLab qui sont deux des plus gros acteurs dont vous avez pu entendre parler,
• 33:30
  ou en tout cas voir le nom.
• 33:32
  Mais il y en a d'autres,
• 33:32
  il y a d'autres systèmes de versionning,
• 33:34
  certains qui s'appuient aussi sur Git mais qui ont une façon de le gérer différemment,
• 33:37
  d'autres qui n'utilisent pas Git et qui font encore autre chose.
• 33:41
  Mais dans tous les cas,
• 33:41
  le principe de Git c'est de se dire on a notre document final qu'on va appeler le main.
• 33:50
  qui va être vraiment notre...
• 33:52
  C'est la page commune,
• 33:54
  c'est la page que la personne va voir à la fin,
• 33:57
  que l'utilisateur va voir à la fin.
• 33:59
  Et c'est là que tout doit arriver.
• 34:01
  Mais on ne peut pas mettre à disposition et en lecture le brouillon.
• 34:05
  Parce que pendant que les gens bossent sur chaque partie,
• 34:07
  ce ne sont que des brouillons de chaque partie.
• 34:10
  Donc sur cette page,
• 34:11
  on va attendre que chacun ait terminé.
• 34:13
  Et pour faire ça,
• 34:14
  le protocole va permettre à chacun d'aller travailler sur ce qu'on appelle les branches.
• 34:20
  des branches.
• 34:21
  Vous n'êtes pas obligé d'utiliser des branches,
• 34:22
  mais quand vous êtes une équipe,
• 34:23
  normalement,
• 34:24
  c'est ce qui se fait.
• 34:25
  C'est que chacun travaille sur une branche.
• 34:27
  Et en fait,
• 34:28
  sur chaque branche,
• 34:30
  donc globalement,
• 34:31
  dites-vous qu'en fait,
• 34:31
  le document principal,
• 34:32
  pour l'instant,
• 34:33
  il a juste une introduction.
• 34:34
  Vous avez fait trois copies de ce document.
• 34:37
  Chaque personne travaille sur une partie différente de ce document.
• 34:40
  Et au fur et à mesure que chaque personne va avoir une partie ou un paragraphe qui est terminé,
• 34:45
  on va dire un paragraphe,
• 34:47
  c'est comme s'il appuyait sur enregistrer.
• 34:49
  Et à partir de là,
• 34:50
  ça va faire ce qu'on appelle un commit.
• 34:53
  Donc en gros,
• 34:54
  il va valider cette section-là,
• 34:57
  enfin voilà,
• 34:57
  ce paragraphe,
• 34:58
  il va le valider,
• 34:58
  il va dire OK.
• 35:00
  ça c'est bon,
• 35:01
  je considère qu'il est prêt,
• 35:03
  et même si j'ai besoin d'aller rajouter des choses plus tard au travail,
• 35:07
  mais en tout cas cette partie elle est enregistrée,
• 35:09
  elle est disponible,
• 35:10
  elle est visible sur ma branche,
• 35:12
  et du coup même les collègues s'ils viennent regarder ma partie,
• 35:14
  ils ne verront pas le deuxième paragraphe sur lequel je suis encore en train de bosser,
• 35:17
  et par contre le premier ils vont le voir.
• 35:19
  Et en fait chacun fait ça de son côté,
• 35:22
  et à partir de là,
• 35:23
  une fois que chacun fait tous ses commits,
• 35:26
  donc tous ses paragraphes et que les trois parties sont à peu près prêtes,
• 35:29
  Et voilà,
• 35:29
  ça peut être à des rythmes différents en fonction des personnes.
• 35:31
  Et puis de la charge aussi,
• 35:32
  parce que ça fait partie aussi des logiques de développement.
• 35:35
  C'est de se dire qu'en fait,
• 35:36
  tout le monde n'a pas forcément la charge,
• 35:38
  le même effort de travail sur une partie.
• 35:40
  Il y en a des plus courtes,
• 35:41
  il y en a des plus longues.
• 35:42
  Et chacun peut avoir ses spécialités aussi.
• 35:45
  Et voilà,
• 35:46
  qui vont avoir du coup des choses qui peuvent bloquer d'autres gens.
• 35:50
  Par exemple,
• 35:50
  la partie 3,
• 35:51
  peut-être que la personne va pouvoir faire les deux premiers paragraphes,
• 35:54
  mais pour le troisième,
• 35:54
  elle ne pourra pas le rédiger tant qu'elle n'aura pas les parties 1 et 2 qui sont terminées.
• 35:58
  Il peut y avoir comme ça des systèmes de dépendance.
• 36:01
  Dans l'idée,
• 36:02
  on va répartir en parallèle le travail de chacun.
• 36:05
  Une fois que les trois parties sont prêtes,
• 36:08
  ils vont faire ce qu'on appelle des pull requests.
• 36:12
  Le mot fait très peur,
• 36:13
  mais le concept est très simple.
• 36:15
  C'est de se dire,
• 36:16
  j'ai fini ma partie,
• 36:18
  je l'envoie à relire et à valider par les copains.
• 36:22
  Et en fait,
• 36:24
  cette partie-là n'arrivera pas dans le document principal tant que...
• 36:28
  les collègues devs n'auront pas relu.
• 36:31
  Ils vont venir,
• 36:32
  ils vont regarder.
• 36:33
  OK,
• 36:33
  en fait,
• 36:34
  tu as écrit ce paragraphe.
• 36:36
  OK,
• 36:36
  ça,
• 36:36
  c'est bien.
• 36:36
  Ah,
• 36:37
  là,
• 36:37
  il y a un petit souci.
• 36:39
  Du coup,
• 36:40
  on va le pointer en disant,
• 36:41
  en fait,
• 36:41
  cette partie-là,
• 36:42
  il faut un petit peu la remanier parce qu'elle ne me semble pas bonne.
• 36:47
  Il y a un truc qui ne va pas.
• 36:48
  Donc là,
• 36:49
  la personne qui a rédigé justement la partie,
• 36:51
  elle va venir,
• 36:52
  elle va faire la petite modif.
• 36:53
  Hop,
• 36:53
  elle va resoumettre à validation.
• 36:55
  Et donc là,
• 36:55
  on va du coup...
• 36:56
  Les collègues vont dire,
• 36:57
  ok,
• 36:57
  très bien,
• 36:58
  cette pull request,
• 37:00
  cette
• 37:01
  PR, si jamais on vous entendait parler de PR,
• 37:03
  c'est ça en fait.
• 37:06
  Là,
• 37:07
  je parle de paragraphe,
• 37:07
  mais dites-vous que c'est du code.
• 37:09
  Depuis tout à l'heure,
• 37:10
  je vulgarise comme ça avec l'exemple du document,
• 37:12
  mais à la place du texte,
• 37:14
  dites-vous que c'est du code.
• 37:16
  Et donc,
• 37:16
  une fois que la PR est prête,
• 37:18
  elle va être validée et elle va partir,
• 37:21
  justement,
• 37:21
  elle va fusionner avec la page principale,
• 37:25
  donc avec le main.
• 37:27
  Et ensuite,
• 37:27
  du coup,
• 37:27
  on va continuer comme ça.
• 37:28
  Chaque fois,
• 37:29
  les pull requests vont avoir plus ou moins de...
• 37:32
  Soit elles vont être validées directement,
• 37:33
  soit elles vont demander plusieurs allers-retours,
• 37:36
  plusieurs correctifs,
• 37:37
  mais ça va être cette logique-là.
• 37:38
  Et des fois,
• 37:38
  il peut y avoir aussi deux PR qui vont être en conflit.
• 37:42
  C'est-à-dire que,
• 37:44
  justement,
• 37:44
  chacun bossait sur une partie différente,
• 37:46
  partie 2 et partie 3,
• 37:48
  mais en fait,
• 37:49
  il y avait un paragraphe qui était commun entre les deux et que les deux personnes n'ont pas la même version du paragraphe.
• 37:55
  Il y a une phrase ou deux qui diffèrent.
• 37:57
  Et bien là,
• 37:57
  au moment de fusionner,
• 37:58
  il va falloir choisir avant de fusionner quelle version du paragraphe on garde,
• 38:04
  et laquelle en fait est la plus récente,
• 38:05
  la plus à jour,
• 38:06
  et la plus logique par rapport à l'ensemble du document.
• 38:09
  Puisque en même temps,
• 38:11
  comme je disais,
• 38:11
  on travaille en parallèle,
• 38:12
  donc il peut y avoir d'autres gens qui ont avancé davantage sur d'autres bouts,
• 38:15
  et qu'on n'avait pas forcément conscience à ce moment-là,
• 38:18
  et donc voilà,
• 38:18
  on fait une relecture.
• 38:20
  D'où l'importance de ces phases qu'on appelle des phases de review,
• 38:24
  vraiment,
• 38:25
  du PR,
• 38:26
  donc de relire.
• 38:27
  le document et la partie de document.
• 38:29
  Une fois que tout est prêt,
• 38:31
  à chaque fois,
• 38:32
  on va fusionner,
• 38:32
  on envoie dans le document principal et les pages s'ajoutent.
• 38:35
  Évidemment,
• 38:36
  vous l'aurez compris,
• 38:37
  cette page principale,
• 38:38
  ce document principal,
• 38:39
  c'est votre code de l'application et ça se traduit pour vous en tant qu'utilisateur en une interface avec des choses à cliquer,
• 38:46
  avec des pages,
• 38:47
  avec plein de choses comme ça.
• 38:49
  Est-ce que sur cette partie-là,
• 38:50
  Lulu,
• 38:50
  tu veux que je clarifie d'autres points ?
• 38:52
  Je ne sais pas si tu avais d'autres points.
• 38:54
  Non,
• 38:54
  ça me semble...
• 38:56
  Ça me semble bien et ça montre d'autant plus l'intérêt d'utiliser ces techniques-là,
• 39:01
  même si on développe tout seul avec plusieurs agents.
• 39:04
  Parce que là,
• 39:05
  d'autant plus,
• 39:07
  on se rend compte que le code avec IA va produire du code où tout est plus ou moins dépendant.
• 39:14
  Ce n'est plus forcément séparé par section claire,
• 39:16
  surtout si on n'a pas bien défini en amont et qu'on envoie notre agent.
• 39:24
  coder sur une fonctionnalité mais on ne l'a pas forcément bien découpé donc ça va toucher à plusieurs endroits du code.
• 39:31
  Donc imaginez,
• 39:32
  vous avez plusieurs agents qui travaillent en même temps sur un projet qui est en local,
• 39:37
  ils vont peut-être essayer de modifier des choses au même moment,
• 39:41
  au même endroit,
• 39:42
  et là après ça peut tout casser,
• 39:44
  ou induire des doublons,
• 39:46
  enfin voilà.
• 39:47
  C'est pour ça que c'est important,
• 39:48
  même si on développe tout seul,
• 39:51
  d'utiliser d'utiliser et...
• 39:54
  Git,
• 39:54
  bon après même si c'est en local,
• 39:55
  on peut utiliser Git quand même,
• 39:56
  mais après GitHub permet aussi de...
• 39:59
  Enfin,
• 39:59
  c'est vrai qu'il y avait la distinction,
• 40:00
  moi avant je ne connaissais pas forcément la distinction Git-GitHub,
• 40:04
  pour moi c'était la même chose et Git c'était en mode...
• 40:06
  Juste le raccourci,
• 40:09
  l'abréviation.
• 40:10
  Je vais juste effectivement clarifier un peu ce point-là.
• 40:12
  C'est que le protocole Git,
• 40:13
  à la base,
• 40:13
  il permet de travailler sur son propre ordinateur avec ce système de version,
• 40:17
  de se dire à chaque fois,
• 40:18
  je fais une nouvelle version.
• 40:20
  Je vous ai parlé là des fusions et tout,
• 40:22
  mais je n'ai même pas revenu sur le terme de version.
• 40:25
  Mais du coup,
• 40:26
  le fait d'avoir des commits et après votre pull request et ensuite de venir justement fusionner tout ça,
• 40:30
  ça vous permet d'avoir une nouvelle version.
• 40:33
  Vous n'êtes pas obligé de faire des pull requests pour quand même...
• 40:36
  versionnés petit à petit au fur et à mesure des changements.
• 40:39
  J'ai pris l'exemple du contexte entreprise où on est à plusieurs et d'où les fameuses PR.
• 40:44
  Et effectivement,
• 40:45
  ce que vous allez avoir comme du GitHub ou du GitLab permet en fait d'avoir ce code et ces versions de code et tous les changements qui partent sur un serveur cloud.
• 40:55
  Donc chez GitHub,
• 40:56
  c'est chez du Microsoft aujourd'hui.
• 40:59
  Et
• 41:00
  GitLab, je pense que c'est juste GitLab d'ailleurs,
• 41:03
  je crois qu'ils n'ont pas d'instance au-dessus.
• 41:06
  Mais l'avantage de ça,
• 41:07
  c'est que du coup,
• 41:07
  le code va être centralisé sur un espace commun sur Internet.
• 41:12
  Et donc,
• 41:12
  n'importe quel développeur ou développeuse va pouvoir bosser sur son ordi en local,
• 41:17
  faire toute sa partie jusqu'au bout.
• 41:19
  Et une fois que sa partie est prête,
• 41:20
  elle va pouvoir faire le point avec ce qui est disponible en ligne.
• 41:23
  Et elle va l'envoyer en ligne et justement soumettre à validation pour lecture,
• 41:27
  etc.
• 41:27
  Et c'est aussi des fois d'ailleurs comme ça qu'on se rend compte qu'il y a des conflits.
• 41:31
  Autre personne,
• 41:31
  en bossant sur son ordi,
• 41:32
  au moment où elle a envoyé le code,
• 41:33
  elle est plus avancée que moi sur un truc qui était commun,
• 41:36
  et ainsi de suite.
• 41:37
  Et sur la manière de bosser en solo avec des agents,
• 41:43
  il y a plein de manières de le faire,
• 41:45
  avec plus ou moins de pull requests,
• 41:47
  avec plus ou moins d'enregistrements,
• 41:49
  etc.
• 41:49
  Mais ce qu'il faut garder en tête,
• 41:52
  c'est que
• 41:53
  Git, du coup,
• 41:54
  enfin Git ou un autre protocole de versionning,
• 41:57
  est très important,
• 41:59
  parce que ça vous permet en fait...
• 42:01
  de sauvegarder petit à petit votre progression et ce qui a été fait côté code,
• 42:05
  ça donne aussi des points de restauration.
• 42:07
  Donc en fait,
• 42:08
  si vous avez un pépin et que vous vous rendez compte que vous avez fait quelque chose qui ne marche pas et qui casse votre application,
• 42:13
  vous pouvez revenir en arrière sur une version antérieure.
• 42:16
  Et voilà,
• 42:16
  ce qui est fondamental,
• 42:18
  que ce soit tout seul ou à plusieurs.
• 42:20
  Et l'autre intérêt aussi de bosser comme ça,
• 42:24
  justement avec des branches,
• 42:25
  avec des versions et tout,
• 42:28
  c'est de se dire qu'en fait,
• 42:29
  à tout moment,
• 42:30
  Quelqu'un peut arriver sur votre repository,
• 42:33
  donc en gros sur votre dossier avec tout votre code,
• 42:37
  et qui peut reprendre le travail.
• 42:38
  De se dire,
• 42:39
  demain,
• 42:39
  s'il y a un dev qui arrive,
• 42:40
  qui prend mon code,
• 42:43
  il va pouvoir savoir où j'en suis,
• 42:44
  il va avoir l'historique de tout ce que j'ai développé,
• 42:46
  s'il y a une fonctionnalité qui fonctionne bien ou pas bien,
• 42:49
  il va pouvoir remonter,
• 42:50
  du coup,
• 42:51
  voir non seulement le détail du code,
• 42:53
  mais aussi l'historique qui est associé,
• 42:55
  et être à même de comprendre d'où vient le problème.
• 42:59
  ou qu'est-ce qu'il pourrait faire pour l'améliorer ou comment on va rajouter une nouvelle fonctionnalité,
• 43:03
  etc.
• 43:04
  D'où l'intérêt de bien documenter,
• 43:06
  de bien commenter aussi son code.
• 43:08
  Alors,
• 43:09
  c'est sûr que quand on est avec de l'IA,
• 43:11
  on ne va pas forcément lire le code,
• 43:12
  mais je pense que même pour suivre un projet,
• 43:15
  ça peut être intéressant de juste voir comment c'est fait et que ce soit pour qu'un humain ou une IA reprenne derrière des noms de fonctions clairs qui disent exactement ce qu'elles font,
• 43:25
  ou bien découpés.
• 43:27
  aussi une fonction à tout faire et de bien commenter,
• 43:32
  de bien documenter.
• 43:33
  Parce que que ce soit une IA,
• 43:36
  vous dans six mois ou quelqu'un d'autre,
• 43:39
  vous serez content de retrouver les commentaires et il faut penser à ceux qui viennent après.
• 43:46
  Petite référence à Claire Obscur.
• 43:48
  J'ai réussi.
• 43:50
  Alors,
• 43:51
  du coup,
• 43:52
  est-ce qu'on se lance sur la partie d'après ou est-ce qu'on s'en tient là pour aujourd'hui,
• 43:55
  Lulu ?
• 43:56
  Je me dis qu'on peut quand même attaquer les tests parce que tu vas peut-être en parler pas mal la semaine prochaine et ça serait bien de dire au moins les différents...
• 44:06
  Parce que c'est pareil,
• 44:08
  notre application,
• 44:09
  à la fin,
• 44:10
  on ne va pas se dire
• 44:11
  « Ah bah tiens,
• 44:12
  je vais la tester à la fin » .
• 44:14
  C'est vraiment quelque chose qu'il y a à mettre en place à chaque étape de développement aussi et de se demander aussi,
• 44:22
  même avant de commencer à développer,
• 44:24
  de définir ses tests.
• 44:27
  En partie,
• 44:28
  mais je pense que là,
• 44:29
  tu en parleras un petit peu mieux parce qu'il y a différents types de tests.
• 44:33
  On entend parler,
• 44:35
  tu avais parlé aussi de recettes la semaine dernière.
• 44:38
  Et après,
• 44:39
  il y a les tests de régression,
• 44:41
  tests unitaires.
• 44:42
  Ça aussi,
• 44:42
  c'est du vocabulaire qui peut paraître un peu barbare quand on n'est pas dedans.
• 44:47
  Oui,
• 44:48
  effectivement.
• 44:49
  Ok,
• 44:50
  alors,
• 44:51
  parce qu'on a déjà fait un petit peu long sur les trois premières parties,
• 44:54
  donc là,
• 44:54
  on va essayer d'aller un peu plus vite sur les trois suivantes.
• 44:57
  mais que vous ayez le panel complet justement du cycle de développement dès aujourd'hui n'hésitez à nous faire basculer sur deux épisodes pour
• 45:06
  vous n'ayez pas à vous en mettre trop dans la tête d'un coup.
• 45:09
  Mais en même temps,
• 45:11
  je pense que ce serait un peu frustrant de s'arrêter aussi à la moitié.
• 45:13
  Donc,
• 45:14
  je rejoins Guillaume.
• 45:14
  Au pire,
• 45:15
  vous écouterez en deux fois.
• 45:17
  Oui,
• 45:17
  c'est ça.
• 45:17
  Ce sera pareil.
• 45:19
  Et alors,
• 45:19
  les tests.
• 45:20
  Les tests,
• 45:21
  les tests.
• 45:21
  Effectivement,
• 45:22
  il va y avoir plusieurs choses.
• 45:23
  On ne pourrait pas en parler longuement parce que ce que vous avez sous le nom d'assurance qualité ou de QA dans les entreprises,
• 45:30
  en tout cas chez les éditeurs de logiciels,
• 45:32
  c'est les services des...
• 45:35
  volontaire ou désigné volontaire pour aller casser les produits et les logiciels et trouver toutes les failles et les remonter aux développeurs qui vont râler parce qu'ils ont des nouvelles failles et des nouveaux bugs à corriger mais qui est fondamental pour éviter que ces bugs arrivent dans les mains des gens à la fin.
• 45:49
  Donc la première chose ça va être effectivement de penser les tests dès le départ donc ça on en avait déjà aussi parlé dans l'épisode précédent c'est de se dire quand on écrit une user story et qu'on dit tel profil doit pouvoir faire telle chose dans l'application
• 46:04
  on va y associer des critères d'acceptation,
• 46:07
  donc de dire en fait,
• 46:08
  pour valider que cette fonction-là,
• 46:11
  donc quand il clique dans ce bouton,
• 46:12
  ça marche,
• 46:13
  en fait,
• 46:13
  c'est les critères qui vont dire qu'est-ce qui fait que ça marche ou pas.
• 46:16
  Et associé à ça,
• 46:18
  en fait,
• 46:18
  on va avoir justement un carnet de tests ou un cahier de tests ou un carnet de recettes,
• 46:23
  enfin bon,
• 46:24
  plusieurs appellations.
• 46:26
  Mais en fait,
• 46:26
  en face de chacune de ces user stories,
• 46:29
  on va mettre des tests pour se dire,
• 46:32
  pour que tout...
• 46:34
  Ce bouton,
• 46:35
  il doit,
• 46:35
  par exemple,
• 46:36
  permettre d'ajouter une ligne dans mon tableau.
• 46:40
  Mais du coup,
• 46:40
  il faut que je teste tous les cas possibles et impossibles,
• 46:45
  c'est où ça devient rigolo,
• 46:47
  les fameux cas limites,
• 46:47
  de se dire en utilisation normale,
• 46:49
  la personne va remplir ces deux champs,
• 46:52
  cliquer sur le bouton,
• 46:53
  ça rajoute une ligne.
• 46:53
  Et en fait,
• 46:54
  si dans ces deux champs,
• 46:56
  j'ai un champ nom,
• 46:56
  j'ai un champ prénom,
• 46:57
  à la place,
• 46:57
  si elle met des chiffres,
• 46:58
  qu'est-ce qu'il se passe ?
• 46:59
  Si elle met des caractères spéciaux,
• 47:00
  qu'est-ce qu'il se passe ?
• 47:01
  Si elle ne met rien,
• 47:02
  qu'est-ce qu'il se passe ?
• 47:03
  Si elle met un script,
• 47:04
  qu'est-ce qui se passe ?
• 47:06
  Si elle met un script,
• 47:06
  qu'est-ce qui se passe ?
• 47:07
  Ou si elle met...
• 47:08
  Alors ça,
• 47:08
  c'est un des tests qui est assez rigolo,
• 47:10
  d'ailleurs,
• 47:10
  quand on les voit passer.
• 47:12
  Si on met un texte sans fin dedans avec
• 47:14
  2000 caractères,
• 47:15
  qu'est-ce qui se passe ?
• 47:18
  Et voilà.
• 47:19
  Et ensuite,
• 47:20
  à partir de là,
• 47:20
  on en déduit les tests à faire et la perce.
• 47:25
  Pas faire tout à fait dans ce temps-là.
• 47:27
  À ce moment-là,
• 47:28
  vous avez déjà un scénario de test qui est associé à chaque...
• 47:31
  un ou plusieurs scénarios de test qui sont associés à chaque fonctionnalité,
• 47:35
  globalement.
• 47:36
  C'est vraiment plus large et ça ne va pas tester juste un petit bout.
• 47:39
  On est vraiment dans le...
• 47:41
  On teste une fonctionnalité,
• 47:45
  une user story.
• 47:46
  On va tester une fonction dans le code.
• 47:48
  Là,
• 47:49
  on est vraiment sur presque le plus haut niveau de test,
• 47:54
  je pense.
• 47:55
  Oui,
• 47:56
  c'est ça.
• 47:56
  C'est-à-dire qu'en fait,
• 47:58
  on va avoir plusieurs niveaux de test.
• 47:59
  Il va y avoir les tests...
• 48:00
  unitaire donc ça ça va être vraiment purement au niveau du code de se dire ben voilà le développeuse a créé a développé ce bouton qui permet de valider d'ajouter la nouvelle ligne avec les noms prénoms elle va mettre en place un test unitaire au niveau du code pour dire ben en fait quand je clique ça
• 48:19
  fait exactement ça insère donc un ajout du nom prénom dans la ligne de ces deux champs voilà typiquement test unitaire il va être là
• 48:29
  C'est une brique,
• 48:30
  on teste vraiment juste une petite brique,
• 48:33
  indépendamment du reste.
• 48:35
  C'est ça.
• 48:36
  On va avoir des tests d'intégration.
• 48:40
  Selon les cas,
• 48:41
  ils viennent à des moments un peu différents,
• 48:42
  mais qui vont être là un petit peu pour l'environnement.
• 48:45
  Je vais en reparler juste après de cette notion d'environnement.
• 48:48
  Et donc,
• 48:49
  ils vont être un peu plus sur la partie vraiment technique,
• 48:52
  globalement,
• 48:52
  mais technique,
• 48:54
  pas du code,
• 48:55
  mais tout ce qu'il y a autour.
• 48:56
  le fait que le programme est disponible,
• 48:58
  où est-ce qu'il est disponible,
• 48:59
  de quelle manière il est disponible,
• 49:00
  un petit peu plus ces choses-là.
• 49:02
  Et on va avoir les tests dits end-to-end,
• 49:06
  qui sont en fait les tests type utilisateur,
• 49:10
  c'est-à-dire vraiment les tests de ce qui se passe quand on navigue sa souris dans le logiciel,
• 49:15
  ou sur le téléphone par exemple,
• 49:18
  et qu'on clique directement sur les boutons,
• 49:20
  etc.
• 49:22
  On reproduit le comportement d'une...
• 49:24
  personnes utilisant vraiment l'application.
• 49:27
  Et ces trois tests-là,
• 49:31
  déjà,
• 49:31
  on va pouvoir les...
• 49:33
  Comment dire ?
• 49:34
  On va pouvoir les automatiser,
• 49:35
  déjà.
• 49:36
  Test unitaire,
• 49:36
  intégration,
• 49:37
  etc.
• 49:37
  Les tests end-to-end,
• 49:38
  en fait,
• 49:39
  quand on les automatise,
• 49:40
  c'est qu'on va littéralement avoir un programme qui reproduit des clics à l'écran et qui reproduit des actions utilisateurs.
• 49:47
  Donc ça,
• 49:47
  c'est assez marrant à voir quand vous le faites.
• 49:49
  Et voilà,
• 49:50
  d'ailleurs,
• 49:50
  si vous développez avec de l'IA et que vous faites du vibe-coding,
• 49:53
  ben...
• 49:54
  demandez enfin j'espère que vous faites des tests end to end et quand il s'est le cas justement amusez vous à regarder les fenêtres de tests pendant qu'il les fait pour voir justement ce ces interactions en temps réel et
• 50:06
  Il y a des programmes qui sont dédiés,
• 50:07
  etc.
• 50:08
  pour faire ça.
• 50:09
  Mais les familles de tests,
• 50:10
  en gros,
• 50:11
  ça va être là-dessus.
• 50:12
  Après,
• 50:12
  on va avoir des tests de non-régression.
• 50:15
  Donc les tests de non-régression,
• 50:16
  en fait,
• 50:17
  entre guillemets,
• 50:17
  il peut y avoir un peu tout ça dans le lot,
• 50:19
  mais le but,
• 50:21
  c'est de se dire,
• 50:23
  en gros,
• 50:23
  quel est notre panel de tests dans les différentes familles qui valident et vérifient que notre programme n'est pas cassé et qu'on a...
• 50:33
  pas cassé un bout du logiciel en ajoutant une nouvelle fonctionnalité,
• 50:36
  même si,
• 50:37
  a priori,
• 50:38
  la nouvelle fonctionnalité n'avait rien à voir.
• 50:40
  Parce que ça,
• 50:41
  c'est un des cas,
• 50:42
  justement,
• 50:42
  des effets de bord,
• 50:43
  c'est de se dire en fait,
• 50:45
  je sais pas,
• 50:45
  je rajoute une nouvelle page dans mon programme,
• 50:47
  cette nouvelle page elle permet de faire des...
• 50:50
  de rajouter des tableaux alors qu'avant j'en avais pas,
• 50:52
  mais en fait,
• 50:52
  quand elle rajoute des tableaux,
• 50:53
  elle utilise un bouton qui était utilisé à un autre endroit et qu'en fait,
• 50:56
  ce bouton,
• 50:56
  du coup,
• 50:57
  on l'a retouché sans se rendre compte qu'il était utilisé à un autre endroit et ça va casser à ce moment-là.
• 51:02
  Ça marchera bien sur la page avec le tableau,
• 51:03
  mais ça marchera plus sur l'autre page qui utilisait le même bouton.
• 51:06
  Voilà,
• 51:07
  les tests de non-régression,
• 51:08
  en fait,
• 51:08
  ils sont là pour empêcher ça,
• 51:10
  enfin,
• 51:10
  pour empêcher ça,
• 51:11
  pour se rendre compte de ça.
• 51:12
  Parce que là,
• 51:13
  en plus,
• 51:14
  on parle de boutons où c'est visible,
• 51:16
  mais ça peut être des choses qui s'accumulent sans qu'on s'en rende compte,
• 51:19
  jusqu'à un point où c'est pour ça que c'est vraiment important de le penser et de garder ça en tête et de se dire que c'est pas parce que je modifie une partie là,
• 51:29
  d'autant plus si c'est en développement assisté par IA ou...
• 51:32
  On peut avoir un peu de code spaghetti,
• 51:33
  où il y a tout qui s'entremêle.
• 51:35
  Se dire,
• 51:36
  non,
• 51:36
  mais ça va,
• 51:37
  visuellement,
• 51:37
  je ne modifie que quelque chose qui est là,
• 51:39
  mais derrière,
• 51:40
  au final,
• 51:40
  ça va aller toucher d'autres choses et on ne s'en rendra pas compte avant de peut-être modifier autre chose ailleurs aussi.
• 51:46
  Donc,
• 51:47
  ça peut être vraiment exponentiel.
• 51:50
  Oui,
• 51:50
  et là,
• 51:50
  c'est vrai que je parle beaucoup de boutons et de choses.
• 51:53
  Pour que vous arriviez à avoir quelque chose en tête,
• 51:56
  parce que déjà qu'on est quand même très abstrait sur plein de sujets,
• 51:59
  concepts,
• 52:00
  parce que si vous n'avez jamais fait de développement,
• 52:02
  C'est normal,
• 52:02
  ça fait beaucoup de nouveautés,
• 52:04
  de nouvelles idées,
• 52:05
  de nouvelles choses à intégrer.
• 52:07
  Mais dans la réalité des faits,
• 52:08
  effectivement,
• 52:09
  la majorité des cas et des bugs viennent de choses qu'on ne voit pas de prime abord.
• 52:14
  Même s'il y a aussi des petits tests,
• 52:16
  il peut y avoir des petits bugs d'interface,
• 52:18
  il peut y avoir des caractères.
• 52:19
  Il y a des choses qui sont visuelles,
• 52:21
  mais les soucis et les bugs les plus embêtants,
• 52:24
  comme disait Lulu,
• 52:24
  on ne les voit pas.
• 52:26
  C'est ça,
• 52:26
  et aussi de se rendre compte à quel moment on a cassé.
• 52:29
  parce que si on se rend compte que...
• 52:31
  rapidement,
• 52:33
  ça peut être facile de corriger tout de suite,
• 52:35
  de revenir à une ancienne version,
• 52:36
  de refaire autrement.
• 52:38
  Mais si on s'en rend compte plusieurs jours,
• 52:40
  plusieurs semaines après,
• 52:41
  et ça c'est vrai qu'IA accélère énormément le développement,
• 52:45
  les pull requests,
• 52:46
  et au final c'est le lenteau nord,
• 52:50
  le goulot d'étranglement,
• 52:51
  il est au niveau de la revue de code maintenant,
• 52:53
  et avec tout ça qui arrive très très vite,
• 52:56
  s'il y a quelque chose qui...
• 52:57
  passe à la trappe,
• 52:58
  mais on va rajouter d'autres choses,
• 52:59
  d'autres fonctionnalités,
• 53:00
  ce qui fait qu'on ne pourra pas juste se dire « je reviens en arrière au moment où ça a pété » ,
• 53:04
  parce qu'il y a d'autres choses qui sont rajoutées en même temps et c'est là qu'on se retrouve à faire des choses pas très propres en général.
• 53:12
  Oui,
• 53:13
  c'est là qu'on se retrouve avec de la dette technique,
• 53:15
  notamment.
• 53:16
  En fait,
• 53:17
  la dette technique,
• 53:18
  sur les cas où vous pouvez,
• 53:20
  les plus criards,
• 53:21
  vous pouvez en avoir,
• 53:22
  ça va être justement quand,
• 53:23
  au début,
• 53:23
  vous aviez une fonctionnalité à faire.
• 53:26
  vous voulez rajouter une nouvelle chose et en fait vous voulez la rajouter le plus vite possible sans vous prendre la tête à vous dire,
• 53:31
  en fait,
• 53:31
  est-ce que pour la faire bien,
• 53:33
  ça prendrait vachement de temps,
• 53:35
  c'est vachement complexe et il faut anticiper plein de choses.
• 53:37
  Moi,
• 53:37
  je veux juste que les utilisateurs et les utilisatrices l'aient très vite dans les mains.
• 53:41
  Je la fais de la manière la plus printée et la plus express.
• 53:45
  Sauf que la manière dont elle est conçue,
• 53:48
  effectivement,
• 53:50
  ça va pour deux semaines et un cas défini.
• 53:53
  Mais en fait,
• 53:54
  dès qu'on va vouloir...
• 53:55
  rajouter des choses sur cette fonctionnalité,
• 53:57
  on va se rendre compte que non,
• 53:59
  ce n'est pas possible parce que ce n'est pas qu'elle est mal conçue,
• 54:02
  c'est qu'elle n'est pas pensée pour évoluer.
• 54:06
  Ça ne prend pas forcément beaucoup de temps de faire des tests à chaque étape.
• 54:12
  C'est aussi à penser et que ça peut vraiment sauver son application après.
• 54:17
  Alors,
• 54:18
  oui,
• 54:19
  justement,
• 54:19
  c'est là où je voulais revenir.
• 54:21
  Là,
• 54:21
  déjà,
• 54:22
  il y a de la technique juste de...
• 54:24
  de ne pas avoir anticipé assez ou d'avoir voulu aller trop vite et de manière qui ne peut pas évoluer derrière.
• 54:32
  Et par-dessus ça,
• 54:33
  on va rajouter les problèmes et les bugs liés au manque de tests et au manque de tests de qualité qui ne vont pas permettre de se rendre compte que cette fonctionnalité qu'on a développée très vite,
• 54:45
  elle a des problèmes qui sont visibles dès maintenant et qu'on va retarder.
• 54:49
  Et parmi ça,
• 54:50
  il peut y avoir par exemple des soucis de performance.
• 54:53
  Typiquement,
• 54:53
  il peut y avoir des...
• 54:55
  Vous rajoutez une nouvelle page qui va vous permettre de rajouter,
• 54:59
  en plus de votre nom,
• 55:00
  prénom,
• 55:00
  vous allez pouvoir rajouter votre adresse.
• 55:02
  Mais en fait,
• 55:04
  toute cette partie-là,
• 55:04
  elle est très mal faite.
• 55:06
  elle a été faite à l'arrache,
• 55:08
  elle n'est pas évolutive,
• 55:08
  et surtout elle consomme énormément de ressources.
• 55:10
  Et en fait,
• 55:11
  sur le moment,
• 55:12
  ça passe,
• 55:12
  parce que vous ne rajoutez que ça,
• 55:14
  mais vous allez vouloir rajouter une suite au formulaire pour aller prendre des informations complémentaires,
• 55:19
  et en fait,
• 55:20
  chaque fois que vous rajoutez des blocs sur votre formulaire,
• 55:22
  vous vous rendez compte que ça devient très très lent,
• 55:25
  et que toute la page ram.
• 55:27
  Et en fait,
• 55:28
  le problème va venir d'un des tout premiers composants,
• 55:30
  votre adresse.
• 55:32
  qui,
• 55:32
  rien que le fait qu'elle tourne sur la page,
• 55:33
  va consommer vachement de ressources de votre navigateur
• 55:36
  Chrome et va faire des ralentissements.
• 55:39
  Mais dès que vous allez faire d'autres choses supplémentaires,
• 55:41
  rajouter des composants,
• 55:42
  ça va rendre tout ça exponentiel.
• 55:44
  Chaque composant va rajouter le même ralentissement et à la fin,
• 55:47
  vous allez retrouver,
• 55:49
  quand vous cliquez,
• 55:49
  qu'il va devoir attendre plusieurs secondes pour qu'il se passe quelque chose,
• 55:52
  par exemple.
• 55:53
  Ça,
• 55:53
  c'est un cas de technique classique de l'IA de la performance qui peut être décelé notamment à travers des tests automatisés.
• 56:00
  Parce qu'en fait,
• 56:01
  dans les tests automatisés ou pas automatisés d'ailleurs,
• 56:04
  puisque c'est là,
• 56:05
  on va se rendre compte qu'il y a un problème.
• 56:07
  Si quand on clique sur le bouton,
• 56:08
  ce n'est pas immédiat et instantané et que ça prend 10 secondes,
• 56:11
  c'est qu'il y a quelque chose qui ne va pas quelque part.
• 56:13
  Et donc dans la QA,
• 56:15
  dans les services d'assurance qualité,
• 56:18
  comme ça,
• 56:18
  ils vont être en mesure de faire les deux,
• 56:20
  la partie test automatisé,
• 56:21
  mais aussi la partie test vraiment humaine,
• 56:24
  de se dire,
• 56:24
  OK,
• 56:25
  la machine,
• 56:25
  j'ai pu mettre en place un certain nombre de trucs pour que ça tourne tout seul.
• 56:29
  Parce qu'en fait,
• 56:29
  on invite des centaines de tests.
• 56:31
  Et donc,
• 56:31
  à chaque fonctionnalité,
• 56:32
  on ne peut pas faire des centaines de tests à la main.
• 56:36
  Mais à côté de ça,
• 56:36
  il y a besoin d'avoir ce regard humain pour se dire,
• 56:38
  attention,
• 56:39
  parce qu'en fait,
• 56:40
  ce truc-là,
• 56:41
  je n'ai pas pensé qu'on pouvait le prendre de telle ou de telle manière.
• 56:46
  Ou alors,
• 56:46
  le test que j'ai mis en place,
• 56:48
  il est bien,
• 56:48
  mais en fait,
• 56:48
  il ne dira pas si,
• 56:50
  justement,
• 56:51
  quand on va rajouter la prochaine fonctionnalité qui est prévue avec l'équipe,
• 56:54
  ça risque de poser souci.
• 56:55
  Et là,
• 56:56
  du coup,
• 56:56
  la personne...
• 56:57
  les personnes justement dans le service qualité apportent énormément de valeur côté produit et information.
• 57:03
  Au même titre que les utilisateurs finaux justement qui vont se servir de votre produit,
• 57:06
  mais à la qualité,
• 57:08
  en fait,
• 57:08
  ils vont avoir un regard tellement complet sur votre application qu'ils sont en mesure de vous montrer des choses,
• 57:15
  d'essoler des choses que vous ne pourriez pas faire différemment,
• 57:17
  que vous n'auriez pas pu voir différemment.
• 57:19
  On va dire ça comme ça.
• 57:20
  Et juste pour terminer justement sur ce sujet des tests,
• 57:26
  pour faire le lien avec notre...
• 57:29
  Là,
• 57:30
  tu as parlé des tests de non-régression,
• 57:32
  mais il y a aussi les tests de régression encore.
• 57:35
  En fait,
• 57:35
  techniquement,
• 57:36
  c'est les tests de non-régression qui te font valider l'absence de régression.
• 57:40
  Ah,
• 57:41
  oui,
• 57:42
  d'accord.
• 57:43
  Parce que moi,
• 57:44
  j'avais tendance à entendre tests de régression,
• 57:46
  mais c'est tests de non-régression.
• 57:50
  Du coup,
• 57:50
  je dis peut-être une bêtise sur le vrai terme officiel,
• 57:53
  mais j'ai toujours dit tests de non-régression,
• 57:54
  c'est un balut
• 57:55
  le principe étant que justement t'es toute ta suite de tests automatisés pour t'assurer comme on disait avant que quand t'as rajouté quelque chose,
• 58:01
  en tout cas t'as un palier de sécurité qui a tourné tout seul et voilà qui sont parmi les différents tests qu'on a déjà évoqué avant mais qui vont être aussi une sélection et il y a aussi le fameux smoke test,
• 58:17
  je ne sais pas si tu veux nous en parler de celui-là ça je l'ai découvert en préparant l'épisode c'est un à...
• 58:25
  Test,
• 58:25
  alors,
• 58:26
  il vient,
• 58:26
  c'est test de fumée,
• 58:30
  pour traduire littéralement,
• 58:31
  qui vient de l'électronique.
• 58:33
  En gros,
• 58:33
  c'est on va allumer et s'il y a de la fumée qui sort,
• 58:37
  on arrête et on considère que ce n'est pas bon.
• 58:41
  Voilà,
• 58:41
  donc en logiciel,
• 58:43
  on va lancer,
• 58:45
  on va faire des vérifications qui sont vitales.
• 58:49
  Et si ça ne passe pas,
• 58:50
  juste on ne va pas continuer à faire d'autres tests et investir du temps sur cette...
• 58:55
  partie-là du logiciel ou sur cette version du logiciel,
• 58:57
  parce que ça serait une perte de temps et de ressources.
• 59:02
  Oui.
• 59:03
  Je suis en train de penser à mes usages,
• 59:06
  mais effectivement,
• 59:07
  c'est un test qui va à l'essentiel.
• 59:11
  Si ça,
• 59:11
  ça ne passe pas,
• 59:12
  on ne va pas aller vérifier si le bouton a la bonne couleur.
• 59:16
  Il y a d'autres choses à vérifier en amont.
• 59:21
  Et c'est vrai que quand tu parlais du formulaire aussi,
• 59:24
  On se dit,
• 59:25
  mais comment est-ce qu'on peut tester tout ?
• 59:27
  Parce qu'au final,
• 59:28
  c'est presque infini ce qui peut se passer.
• 59:31
  Et justement,
• 59:32
  on va essayer de choisir à chaque fois des valeurs ou des tests qui vont être représentatifs d'un intervalle ou qui vont être représentatifs de plusieurs tests qui vont permettre,
• 59:44
  par exemple,
• 59:45
  si on peut mettre des numéros,
• 59:49
  on va se dire,
• 59:49
  bon,
• 59:50
  on va tester,
• 59:50
  par exemple,
• 59:51
  je ne sais pas,
• 59:51
  0,
• 59:51
  1.
• 59:53
  après on va tenter sans tester après aussi à chaque borne où on peut mettre,
• 59:57
  c'est souvent là où ça peut bugger si on met un nombre négatif si on met un chiffre à virgule et ça va pas être pertinent de tester tous les chiffres tous les nombres et juste prendre un
• 1:00:13
  test ou une valeur qui va représenter une famille de valeurs ouais et en fait il faut Ouais.
• 1:00:21
  à garder en tête,
• 1:00:21
  c'est qu'on ne peut pas tout tester.
• 1:00:24
  C'est juste pas possible.
• 1:00:25
  Et aucun logiciel n'a pas de bug.
• 1:00:31
  L'idée,
• 1:00:31
  c'est de ne pas avoir de bug visible,
• 1:00:34
  entre guillemets,
• 1:00:35
  et les traiter au fil de l'eau,
• 1:00:39
  justement de ne pas attendre qu'ils s'accumulent et qu'ils s'agglutinent,
• 1:00:42
  et surtout de traiter tous les problèmes majeurs le plus rapidement possible,
• 1:00:45
  mais sans pour autant délaisser les petits bugs mineurs,
• 1:00:47
  parce qu'en fait,
• 1:00:48
  il y a des soucis.
• 1:00:49
  Il peut y avoir des...
• 1:00:50
  petits pépins et des petits bugs moins importants mais qui sont pénibles dans l'utilisation quotidienne et qui sont aussi nécessaires de corriger petit à petit.
• 1:00:59
  Mais typiquement,
• 1:01:01
  il peut y avoir des cas où vous avez des bugs qui sont connus,
• 1:01:04
  qui ne sont pas traités volontairement parce qu'on sait que telle page ou tel composant,
• 1:01:09
  on va le faire évoluer.
• 1:01:10
  C'est déjà prévu qu'il évolue dans deux semaines,
• 1:01:12
  dans un mois.
• 1:01:14
  Et l'effort que ça prendrait de corriger le bug est beaucoup trop important.
• 1:01:19
  au vu du fait que de toute façon,
• 1:01:23
  cette partie-là va être refaite différemment et on ne va pas faire le boulot deux fois.
• 1:01:28
  Donc c'est ce qui fait aussi des fois que vous avez des bugs dans certains logiciels que vous allez voir,
• 1:01:32
  vous savez qu'ils sont là.
• 1:01:33
  Donc des fois,
• 1:01:33
  ils ne sont pas traités de suite parce qu'en fait,
• 1:01:35
  il n'y a plus prioritaire avant,
• 1:01:37
  il y a plus important et plus urgent et plus critique dans l'application.
• 1:01:42
  Et d'autres fois,
• 1:01:43
  mais en fait,
• 1:01:43
  ils sont connus,
• 1:01:45
  acceptés,
• 1:01:45
  tolérés parce que...
• 1:01:48
  la fonctionnalité ou le composant va être amené à changer.
• 1:01:51
  Et dans ces cas-là,
• 1:01:52
  soit il faut prendre son mal en patience,
• 1:01:53
  soit ne pas hésiter aussi à solliciter les services support,
• 1:01:56
  les équipes support qui ont généralement...
• 1:01:58
  C'est tout à l'aimant.
• 1:02:01
  Oui.
• 1:02:01
  Généralement,
• 1:02:02
  des astuces et des contournements à vous donner qui ne sont pas forcément idéaux,
• 1:02:06
  mais qui peuvent vous permettre de vous débloquer pour quand même arriver à vos fins sans avoir à attendre justement que la fonctionnalité soit terminée et que la nouvelle version soit disponible.
• 1:02:17
  C'est vrai que c'est compliqué de trouver un peu cet équilibre entre la partie maintenance et régler des problèmes qui remontent,
• 1:02:27
  et la partie innovation où on veut rajouter des nouvelles fonctionnalités,
• 1:02:30
  parce que c'est sûr qu'il y a ce côté-là où le produit doit quand même vivre,
• 1:02:34
  l'application doit vivre,
• 1:02:35
  et on ne peut pas juste tout régler parce qu'il y a d'autres choses qui vont arriver,
• 1:02:41
  comme tu disais,
• 1:02:41
  au fil de l'eau.
• 1:02:43
  trouver un peu ce sweet spot entre on fait quand même évoluer l'appli,
• 1:02:46
  mais en même temps il ne faut pas qu'on casse tout et qu'on construit sur quelque chose qui est bancable.
• 1:02:53
  C'est pour ça qu'il y a certains moments aussi,
• 1:02:56
  on verra,
• 1:02:57
  où c'est mieux de recommencer.
• 1:02:59
  Ce n'est pas agréable,
• 1:03:02
  ça peut être compliqué,
• 1:03:03
  ça peut coûter,
• 1:03:04
  mais ça peut aussi coûter d'essayer de continuer à essayer de maintenir et de...
• 1:03:09
  pu avoir d'innovation et de se faire potentiellement dépasser par quelqu'un qui lance son nouveau logiciel.
• 1:03:16
  Oui,
• 1:03:16
  après,
• 1:03:17
  voilà,
• 1:03:17
  ça serait complètement vrai,
• 1:03:19
  mais ça va dépendre aussi de l'envergure de l'application et de l'objectif.
• 1:03:23
  Si vous faites du vape coding et que vous développez une application toute seule ou toute seule sur votre ordi,
• 1:03:29
  globalement,
• 1:03:30
  votre appli,
• 1:03:30
  une fois qu'elle est terminée et qu'elle répond à vos besoins,
• 1:03:33
  vous n'aurez peut-être jamais besoin de la faire évoluer pendant des années,
• 1:03:36
  et puis au bout d'un moment,
• 1:03:37
  juste...
• 1:03:38
  passer sur un autre produit ou faire une nouvelle version,
• 1:03:40
  enfin,
• 1:03:41
  peu importe.
• 1:03:42
  Et la même chose sur certains modules et certaines applis.
• 1:03:46
  Des fois,
• 1:03:46
  vous allez remplacer un logiciel entier par un nouveau qui est pensé différemment et qui correspond davantage à vos besoins.
• 1:03:53
  Ou au contraire,
• 1:03:53
  du coup,
• 1:03:54
  effectivement,
• 1:03:55
  des logiciels qui vont durer très longtemps vont de temps en temps changer des bouts de moteur et des bouts de l'application complète et ne changeront jamais tout d'un coup.
• 1:04:08
  Enfin,
• 1:04:08
  ça peut arriver en réalité,
• 1:04:10
  mais généralement c'est une nouvelle version qui va cohabiter avec une ancienne.
• 1:04:14
  Et le souci de cette Ausha,
• 1:04:17
  c'est que souvent,
• 1:04:18
  quand on a besoin de repartir de zéro avec un nouveau moteur et des technologies plus modernes,
• 1:04:22
  on ne peut pas répliquer à l'identique un logiciel qui existait depuis 20 ans et qui avait 20 ans de développement avec toutes ses fonctionnalités.
• 1:04:28
  Dans ces moments-là,
• 1:04:29
  on est obligé de trancher dans le vif,
• 1:04:32
  de sélectionner que les choses les plus critiques et les plus importantes dans la nouvelle version qui sera.
• 1:04:37
  fluide,
• 1:04:37
  rapide,
• 1:04:38
  modernisé,
• 1:04:38
  etc.
• 1:04:39
  tout très bien,
• 1:04:40
  mais qui perdra forcément un grand nombre de choses par rapport à l'ancienne.
• 1:04:43
  En partant du principe qu'on va vous mettre dans les mains la nouvelle version au top,
• 1:04:48
  et vous rajouter ce qui manque petit à petit.
• 1:04:51
  et que les bookings seront rajoutés petit à petit,
• 1:04:53
  ils seront mieux pensés,
• 1:04:55
  plus rapides et tout.
• 1:04:56
  Mais voilà,
• 1:04:57
  et ça c'est un des cas que j'ai déjà vu justement dans différentes boîtes où en fonction du client et de l'utilisateur final,
• 1:05:05
  ça va être
• 1:05:06
  « Ok, je préfère rester sur l'ancienne version,
• 1:05:08
  donc la nouvelle n'est pas assez mature,
• 1:05:10
  elle n'a pas ce dont j'ai besoin dans mon quotidien »
• 1:05:13
  ou au contraire,
• 1:05:14
  les fonctionnalités qu'il y a dans la nouvelle version,
• 1:05:16
  c'est juste ce dont j'ai besoin.
• 1:05:17
  Et c'est parfait,
• 1:05:18
  je peux basculer dessus.
• 1:05:19
  J'avais deux,
• 1:05:19
  trois broutilles que j'aimais bien raconter,
• 1:05:21
  mais je peux m'en passer pour le moment.
• 1:05:24
  Parce que les langages aussi ont différentes versions.
• 1:05:30
  Et on ne peut pas juste,
• 1:05:31
  quand un nouveau,
• 1:05:32
  par exemple,
• 1:05:32
  un nouveau langage en Java sort,
• 1:05:34
  se dire,
• 1:05:34
  on fait la mise à jour et puis notre application,
• 1:05:36
  on passe au nouveau langage,
• 1:05:40
  à une nouvelle version de Java qui apporte des nouvelles fonctionnalités,
• 1:05:44
  des meilleures performances.
• 1:05:47
  Parce qu'il y a des choses qui ne marcheront plus.
• 1:05:49
  C'est un moment où on ne peut pas juste mettre à jour aussi facilement.
• 1:05:55
  Et c'est comme ça qu'on se retrouve.
• 1:05:57
  C'est ce qu'on appelle des refontes,
• 1:05:59
  quand on refait une partie.
• 1:06:02
  Et ça,
• 1:06:02
  c'est très connu,
• 1:06:03
  par exemple,
• 1:06:04
  dans le système bancaire,
• 1:06:05
  assurance.
• 1:06:06
  On va dire des boîtes qui ont des logiciels historiques.
• 1:06:10
  On va trouver peut-être encore des bouts de cobol aussi,
• 1:06:12
  qui est un très,
• 1:06:13
  très vieux langage.
• 1:06:15
  ça dans la banque c'est encore autre chose parce qu'ils sont un peu banque à l'aéroport etc ils ont des outils tellement critiques qui font durer et traîner des choses qui sont très technologiquement où il y a peu de gens qui sont encore en mesure de le réparer c'est
• 1:06:30
  ça et puis des fois la refonte va prendre tellement de temps qu'elle sera déjà obsolète donc on se retrouve à faire des refontes de refontes et c'est sans fin donc voilà après ça c'est plus Aïe !
• 1:06:43
  C'est à l'échelle vraiment d'une plus grosse boîte et tout ce qui est,
• 1:06:47
  on va dire,
• 1:06:47
  plus historique aussi.
• 1:06:49
  Automobile.
• 1:06:51
  Après,
• 1:06:51
  je pense que tu l'as peut-être rencontré dans des trucs plus récents,
• 1:06:54
  dans des contextes plus récents aussi.
• 1:06:56
  Oui,
• 1:06:57
  ce n'est pas forcément une taille de boîte,
• 1:06:58
  c'est vraiment plus une durée de vie du logiciel.
• 1:07:03
  Parce qu'en fait,
• 1:07:03
  tu peux avoir un petit programme qui est concerné,
• 1:07:05
  tout simplement,
• 1:07:06
  parce qu'il sera utilisé pendant 10 ans,
• 1:07:08
  pendant 5 ans,
• 1:07:10
  en plus.
• 1:07:11
  et pour lesquels,
• 1:07:12
  au bout d'un moment,
• 1:07:12
  il va y avoir certaines technologies ou certaines dépendances.
• 1:07:16
  On ne tirera pas là-dessus maintenant,
• 1:07:19
  mais dites-vous juste qu'un programme,
• 1:07:22
  quand vous le faites et quand vous le développez,
• 1:07:24
  vous ne développez jamais tout de zéro.
• 1:07:26
  Vous allez généralement vous appuyer sur des librairies,
• 1:07:29
  donc des bout de code qui ont été réalisés par d'autres,
• 1:07:32
  pour ne pas réinventer la roue à chaque fois.
• 1:07:34
  Mais la contrepartie de ça,
• 1:07:35
  c'est qu'il y a des briques qui peuvent ne plus être maintenues ou ne plus être compatibles avec des nouvelles versions.
• 1:07:41
  pour différentes raisons.
• 1:07:43
  Il peut y avoir des briques,
• 1:07:44
  justement,
• 1:07:45
  de dépendance qui se retrouvent avec des failles de sécurité dont on doit se passer pour aller sur quelque chose d'autre parce que les failles de sécurité ne peuvent pas être corrigées ou même si elles ont été corrigées,
• 1:07:55
  du coup,
• 1:07:55
  c'est un trop gros risque,
• 1:07:56
  etc.
• 1:07:56
  Enfin,
• 1:07:56
  il y a des considérations à prendre en compte.
• 1:07:59
  Il peut y avoir le fait de ne pas avoir pris de dépendance,
• 1:08:02
  d'avoir voulu coder soi-même une fonctionnalité et de se rendre compte qu'en fait,
• 1:08:06
  on n'était pas en mesure de bien la couvrir parce qu'elle était complexe techniquement.
• 1:08:09
  Il se retrouvait à utiliser des dépendances
• 1:08:11
  payantes ou des outils tiers qu'on va connecter aussi avec différents systèmes comme des API.
• 1:08:17
  Il y a plein de paramètres qui peuvent rentrer en jeu dans le fait de faire une refonte ou pas et que la refonte soit que sur des petits bouts,
• 1:08:25
  sur des grands bouts.
• 1:08:29
  On va prendre peut-être un exemple tout bon,
• 1:08:32
  mais aujourd'hui il y a beaucoup de logiciels et d'applications qui s'appuient sur Stripe qui fait toute la partie paiement.
• 1:08:40
  du coup ça devient une dépendance.
• 1:08:42
  Demain si Stripe pour une raison politique ou de sécurité ou comme ça,
• 1:08:50
  est plus compatible avec nos réglementations en France,
• 1:08:54
  du coup ça fait que toutes les boîtes qui s'habituent,
• 1:08:56
  elles l'ont dans l'offre,
• 1:08:56
  c'est qu'il faut soit qu'elles trouvent un autre équivalent à Stripe pour gérer toute la partie paiement de leur boîte,
• 1:09:03
  soit qu'elles développent eux-mêmes,
• 1:09:04
  et auquel cas c'est vraiment délicat parce que du coup dans les parties paiement il y a plein de choses qui sont vraiment...
• 1:09:09
  très sensible.
• 1:09:10
  Et puis même après,
• 1:09:11
  je pense qu'en termes réglementaires d'agrémenter tout,
• 1:09:13
  il y a des choses aussi à vendre.
• 1:09:14
  Mais voilà,
• 1:09:15
  pour citer un exemple de dépendance qui n'est pas une librairie pour le coup,
• 1:09:19
  qui est un outil tiers,
• 1:09:20
  mais qui est un outil tiers qu'on va intégrer et qui va être intégré dans plein plein de logiciels parce que c'est une brique tellement difficile à mettre en œuvre qu'on s'appuie sur de l'existant mais que cet existant a des contraintes.
• 1:09:31
  C'est vrai que quand il y a eu aussi la mise en application du
• 1:09:34
  RGPD.
• 1:09:35
  Tout simplement,
• 1:09:35
  là,
• 1:09:36
  ça a demandé beaucoup de modifications,
• 1:09:38
  et là,
• 1:09:38
  c'est une réglementation qui évolue,
• 1:09:41
  et là,
• 1:09:41
  ça demande de mettre à jour,
• 1:09:44
  de rajouter des choses qui n'étaient pas prévues au départ dans un logiciel,
• 1:09:48
  et là,
• 1:09:49
  ça demande...
• 1:09:50
  Pas mal de boulot,
• 1:09:51
  je sais que ça a été compliqué dans pas mal de boîtes,
• 1:09:55
  la question RGPD.
• 1:09:56
  Oui,
• 1:09:57
  parce que le RGPD implique ne serait-ce que de pouvoir exporter tes données en tant qu'utilisateur.
• 1:10:03
  Donc en fait,
• 1:10:04
  il faut dans le logiciel en mettre en œuvre tout ce qu'il faut pour récupérer toutes tes données un peu partout et te permettre de les sortir de là,
• 1:10:12
  de les exporter,
• 1:10:13
  d'en avoir une copie complète.
• 1:10:14
  Et ils sont aussi censés te permettre de supprimer ou d'anonymiser en fonction des cas.
• 1:10:19
  peut être supprimé ou pas,
• 1:10:20
  parce qu'il y a des choses que techniquement tu ne vas pas pouvoir supprimer,
• 1:10:22
  mais du coup tu vas devoir basculer en anonymisation pour pas qu'on puisse remonter ta trace et en même temps que le logiciel continue à fonctionner.
• 1:10:31
  Quand elles sont reliées entre elles,
• 1:10:34
  si tu casses un bout,
• 1:10:35
  tu peux casser beaucoup de choses à côté,
• 1:10:36
  donc la suppression n'est pas si simple.
• 1:10:39
  Et après,
• 1:10:40
  en plus,
• 1:10:40
  tu dois rajouter d'autres contraintes,
• 1:10:41
  puisque notamment sur les parties RGPD,
• 1:10:43
  ça peut rentrer en
• 1:10:45
  contradiction avec d'autres règles de sécurité informatique en fonction de ton secteur et de la sensibilité,
• 1:10:50
  par exemple dans la santé ou d'autres domaines,
• 1:10:53
  la durée de rétention des données n'est pas la même.
• 1:10:55
  Et du coup,
• 1:10:56
  c'est toujours celle qui est en vigueur la plus critique,
• 1:10:58
  on va dire,
• 1:10:59
  qui va prendre le pas sur le RGPD et qui va le rendre caduque.
• 1:11:03
  Parce que si le RGPD te dit combien d'années il faut en standard pour la rétention des données,
• 1:11:12
  mais si d'un point de vue légal,
• 1:11:13
  on te dit que non,
• 1:11:14
  sur cet usage-là de santé,
• 1:11:16
  il faut garder les logs et la traçabilité pendant 10 ans.
• 1:11:19
  Pendant 10 ans,
• 1:11:19
  tu ne vas pas ni supprimer ni anonymiser parce que c'est une obligation légale d'avoir ces infos-là.
• 1:11:25
  Du coup,
• 1:11:25
  c'est des choses à prendre en compte,
• 1:11:27
  à mettre en œuvre d'un point de vue métier et d'un point de vue technique,
• 1:11:30
  ce qui peut amener plein de galères.
• 1:11:32
  C'est là qu'on peut se rendre compte que c'est pertinent d'essayer au maximum de découper pour qu'on puisse presque y aller de manière chirurgicale pour modifier.
• 1:11:42
  Alors,
• 1:11:42
  ça ne sera pas possible
• 1:11:44
  de ne pas impacter et juste avoir des Legos qui sont fixés de manière,
• 1:11:50
  on va dire,
• 1:11:51
  simple,
• 1:11:51
  sans dépendance.
• 1:11:53
  Mais à un moment,
• 1:11:53
  il faudra quand même impacter d'autres fonctionnalités.
• 1:11:56
  Mais si c'est bien découpé,
• 1:11:59
  ça se passera mieux que si c'est un gros mélange où il faut se dire,
• 1:12:07
  si je modifie là,
• 1:12:08
  qu'est-ce que ça va casser autour ?
• 1:12:10
  mais en même temps,
• 1:12:11
  si je casse tout ça,
• 1:12:13
  est-ce que c'est...
• 1:12:13
  plus grave que de ne pas être en conformité.
• 1:12:17
  C'est là que typiquement,
• 1:12:18
  avoir une base de données bien structurée est fondamentale.
• 1:12:21
  Parce que tes éléments vont quand même être liés les uns les autres entre les différentes tables,
• 1:12:26
  entre les différentes entités d'information.
• 1:12:29
  Mais plus cette structure est efficiente,
• 1:12:32
  plus justement tu vas pouvoir identifier les infos qui vont bien,
• 1:12:36
  jongler d'une relation à une autre pour prendre ce que tu as besoin ou justement supprimer ou analyser ce que tu as besoin.
• 1:12:43
  sans tout casser.
• 1:12:44
  Et là où,
• 1:12:45
  comme on disait au tout début,
• 1:12:48
  comme le cas de l'adresse ou ce genre de choses,
• 1:12:50
  si c'est un seul tenant,
• 1:12:51
  un seul bloc d'informations,
• 1:12:52
  et dedans vous avez une info à enlever,
• 1:12:53
  mais qu'en fait,
• 1:12:55
  si vous enlevez cette info,
• 1:12:56
  vous êtes obligé d'enlever l'entièreté de l'adresse.
• 1:13:00
  Sinon,
• 1:13:00
  on va prendre l'exemple de l'adresse.
• 1:13:02
  Mais en fait,
• 1:13:02
  dans votre adresse,
• 1:13:03
  vous n'êtes plus à l'étage,
• 1:13:04
  vous êtes au rez-de-chaussée.
• 1:13:06
  Et si c'est un seul tenant,
• 1:13:09
  vous cassez toute l'adresse,
• 1:13:10
  vous supprimez toute l'adresse.
• 1:13:12
  Dans notre cas,
• 1:13:12
  vous allez juste mettre à jour une information de moi.
• 1:13:15
  Ça ou par exemple si l'adresse c'est un seul bout,
• 1:13:19
  de se dire,
• 1:13:19
  je ne sais pas,
• 1:13:20
  demain il y a la réglementation qui change et les codes postaux changent.
• 1:13:25
  Ça peut être pratique que le code postal soit isolé tout seul et qu'on n'ait pas à remodifier tout et peut-être essayer de l'isoler alors que tout est imbriqué.
• 1:13:35
  Je pense que ça a été un peu le cas avec ce qui se passait avec le RGPD.
• 1:13:39
  penser aussi dedans comment est-ce que notre chemin de données,
• 1:13:43
  comment est-ce que c'est stocké,
• 1:13:45
  comment est-ce que les données sont séparées,
• 1:13:47
  comment est-ce que les rends accessibles...
• 1:13:50
  Et même d'ailleurs,
• 1:13:51
  aujourd'hui,
• 1:13:51
  quand tu fais un programme de zéro,
• 1:13:53
  si tu ne penses pas à ta conformité à RGPD au début,
• 1:13:55
  on ne va pas se mentir,
• 1:13:57
  c'est chiant.
• 1:13:58
  Comme l'accessibilité,
• 1:14:01
  c'est à penser dès le début et pas à la fin.
• 1:14:03
  Oui,
• 1:14:03
  clairement.
• 1:14:06
  Allez,
• 1:14:07
  on embraye.
• 1:14:07
  On a bientôt fini,
• 1:14:08
  si vous êtes encore avec nous.
• 1:14:10
  on est presque alors on va terminer plus rapidement donc suite au test on a fait tout le panel et on va revenir au fameux concept de mise en production de quoi on parle ?
• 1:14:23
  Quand on développe alors on va avoir une structure classique,
• 1:14:28
  encore une fois selon les boîtes il peut y avoir plus ou moins d'environnement mais là le standard ça va être de se dire on a trois environnements,
• 1:14:34
  un qui est là pour le développement
• 1:14:36
  Donc c'est là où vos équipes de développement,
• 1:14:38
  vos développeurs et développeuses vont faire justement les différentes briques de code dont on a parlé tout à l'heure et leurs différentes versions,
• 1:14:45
  leurs PR,
• 1:14:45
  et balancer tout ça quelque part et ça arrivera généralement en dev.
• 1:14:49
  où vous avez la version de votre Google Doc dont on parlait tout à l'heure,
• 1:14:54
  de votre document complet.
• 1:14:55
  Vous avez la version la plus à jour,
• 1:14:57
  la plus fraîche,
• 1:14:58
  mais celle qui est aussi le plus fragile parce qu'elle a eu des tests unitaires,
• 1:15:02
  etc.
• 1:15:02
  Elle peut avoir plus ou moins de tests end-to-end et tout,
• 1:15:05
  selon le process de la boîte,
• 1:15:06
  mais elle est dans un environnement qui est prévu pour être cassée,
• 1:15:10
  en quelque sorte.
• 1:15:11
  OnDev,
• 1:15:11
  c'est vraiment votre environnement de bordel.
• 1:15:16
  Au-dessus,
• 1:15:16
  vous allez avoir...
• 1:15:17
  L'environnement dit de staging ou de pré-production,
• 1:15:21
  ça peut être deux environnements différents.
• 1:15:23
  Vous pouvez avoir un environnement dit de recette,
• 1:15:25
  un environnement de staging.
• 1:15:28
  Là,
• 1:15:28
  vous pouvez avoir plusieurs paliers,
• 1:15:30
  mais si on part du principe que vous en avez qu'un,
• 1:15:32
  c'est un environnement de pré-production.
• 1:15:36
  En gros,
• 1:15:37
  lui,
• 1:15:38
  il est là pour ressembler le plus possible à votre production.
• 1:15:42
  L'environnement de production étant celui que vous,
• 1:15:44
  vous avez dans les mains en tant qu'utilisateur et utilisatrice.
• 1:15:47
  Mais en fait derrière un environnement de production,
• 1:15:49
  ou un environnement des autres,
• 1:15:51
  il y a plus que juste l'écran et le bout de code,
• 1:15:55
  il y a aussi toute la partie infrastructure.
• 1:15:58
  Parce que concrètement,
• 1:15:59
  votre équipe de développeurs,
• 1:16:02
  s'ils sont 5,
• 1:16:03
  du coup ils n'ont pas besoin d'avoir énormément de ressources matérielles derrière pour faire tourner l'application.
• 1:16:08
  Ils n'ont besoin que d'une version légère.
• 1:16:10
  Mais en revanche sur la production,
• 1:16:11
  si vous avez 10 000 utilisateurs,
• 1:16:13
  il faut que derrière vous ayez des serveurs des ordinateurs,
• 1:16:15
  des machines,
• 1:16:16
  un réseau des mesures de sécurité des tests,
• 1:16:20
  des sauvegardes etc qui soient proportionnés pour supporter ces 10 000 utilisateurs et en fait le staging va être l'entre-deux votre environnement de pré-production il va être déjà plus sécurisé plus
• 1:16:35
  vérifié que l'environnement de dev il peut avoir éventuellement des données enfin pas
• 1:16:41
  pas forcément issus de la production,
• 1:16:42
  mais en tout cas qui reflètent des données de production,
• 1:16:44
  qui sont des données plus complètes,
• 1:16:46
  là où on dev,
• 1:16:46
  on va avoir un peu plus de données vraiment de tests,
• 1:16:49
  de brouillons,
• 1:16:49
  on va aussi avoir des vraies applications pour s'entraîner,
• 1:16:52
  mais voilà,
• 1:16:53
  qui va être un peu à part.
• 1:16:56
  Et votre staging,
• 1:16:57
  donc,
• 1:16:58
  c'est vraiment l'hybride de se dire,
• 1:17:00
  il doit ressembler le plus possible à la production en termes de type de données,
• 1:17:05
  en termes de type d'exemples,
• 1:17:06
  en termes de profil utilisateur,
• 1:17:08
  en termes de
• 1:17:09
  pas de nombre de gens,
• 1:17:10
  ça ne pourrait jamais répliquer autant,
• 1:17:12
  ou alors si,
• 1:17:12
  d'ailleurs je dis ça,
• 1:17:13
  mais il y a des tests qui permettent de le faire,
• 1:17:15
  mais voilà,
• 1:17:15
  c'est votre entre-deux,
• 1:17:17
  et justement,
• 1:17:17
  la fameuse mise en production,
• 1:17:18
  c'est de se dire,
• 1:17:19
  ok,
• 1:17:20
  donc sur staging,
• 1:17:21
  on a tout qui est bon,
• 1:17:22
  tout a été testé par le service qualité,
• 1:17:25
  tout est arrivé jusque-là,
• 1:17:27
  on s'est rendu compte aussi que sur notre environnement de staging,
• 1:17:30
  qui ressemble le plus possible à la prod,
• 1:17:32
  entre dev et là,
• 1:17:33
  on a eu un problème quand on est passé de l'un à l'autre,
• 1:17:37
  problème de déploiement,
• 1:17:38
  de...
• 1:17:39
  où,
• 1:17:39
  en fait,
• 1:17:39
  quand on a mis à jour,
• 1:17:41
  on s'est rendu compte qu'il y a un truc qui ne s'est pas bien passé côté infrastructure,
• 1:17:44
  parce qu'il y avait un tunnel qui était bouché,
• 1:17:47
  ou parce qu'il y avait un truc de réseau qui ne marchait pas bien,
• 1:17:49
  ou parce qu'il y avait une fonctionnalité qui marchait bien dans l'environnement de développement,
• 1:17:53
  mais en fait,
• 1:17:54
  sur l'environnement de pré-production,
• 1:17:56
  on se rend compte qu'il y a un truc qui ne passe pas et que,
• 1:17:58
  je ne sais pas moi,
• 1:17:59
  les administrateurs par exemple,
• 1:18:00
  peuvent plus se connecter à l'application.
• 1:18:02
  Voilà,
• 1:18:02
  c'est ce genre de choses qu'on va pouvoir identifier quand on passe d'un environnement à l'autre.
• 1:18:06
  Et l'idée,
• 1:18:07
  c'est qu'en staging,
• 1:18:07
  on verrouille
• 1:18:09
  tout ou quasiment tout,
• 1:18:11
  pour que quand on envoie en production,
• 1:18:12
  donc quand on fait la fameuse mise en production,
• 1:18:15
  le programme arrive,
• 1:18:17
  prêt,
• 1:18:18
  il tourne.
• 1:18:19
  On sait là où il peut y avoir des pépins et on est prêt à les corriger dans la foulée.
• 1:18:24
  On a vérifié que tout ce qui était critique est bon.
• 1:18:28
  On fait de la surveillance et on garde le tout à l'œil.
• 1:18:33
  Et pendant la mise en production,
• 1:18:35
  c'est le moment où les équipes sont au taquet,
• 1:18:37
  prêtes à intervenir.
• 1:18:38
  pour soit corriger les pépins s'il y en a au moment où ça arrive la mise à jour est terminée soit si,
• 1:18:46
  c'est le pire scénario,
• 1:18:46
  si la mise à jour elle casse tout et qu'on n'arrive pas à débloquer le cas,
• 1:18:50
  de pouvoir faire ce qu'on appelle un revert enfin revenir à une version antérieure et ça pareil,
• 1:18:56
  il y a plein de manières de revenir,
• 1:18:58
  enfin plusieurs manières en tout cas de revenir à la version antérieure mais de s'assurer que la production elle est coupée le moins longtemps possible si jamais elle doit avoir un mètre.
• 1:19:09
  Et j'ai parlé de recettes sans expliquer ce que c'était,
• 1:19:11
  mais en fait la recette ça va être un peu l'ensemble des scénarios qu'on doit valider avant d'envoyer en production.
• 1:19:21
  Donc de se dire,
• 1:19:22
  on a un panel de tests,
• 1:19:24
  où il y a,
• 1:19:25
  je viens de bêtise,
• 1:19:25
  1000 tests possibles,
• 1:19:27
  et on va estimer que ces 1000 tests doivent être remplis avant d'envoyer en production,
• 1:19:32
  ou alors on va estimer qu'il n'y en a que 700 qui sont nécessaires,
• 1:19:35
  ou 300,
• 1:19:35
  etc.
• 1:19:35
  Après ça,
• 1:19:36
  ça va dépendre un peu d'eux.
• 1:19:37
  la tambouille de chaque boîte,
• 1:19:38
  le niveau de complexité,
• 1:19:41
  la criticité aussi de la mise à jour.
• 1:19:43
  En fait,
• 1:19:43
  il y a des mises à jour qu'on va envoyer en production et sur lesquelles on sait qu'il y a peu de risques et donc un panel de recettes plus léger peut être raté.
• 1:19:52
  accepté et ben nécessité moins de temps,
• 1:19:56
  moins de risques etc.
• 1:19:57
  Là où ben en fait justement si on a fait une refonte plusieurs refontes de se dire ah oui mais non là il faut vraiment que tout tout soit vérifié jusque le plus possible pour qu'on ait le moins de pépins possible arrivé.
• 1:20:10
  Voilà dans l'idée sur les trois gros environnement est ce que représente une mise en production et raison pour laquelle on évite de la faire le vendredi parce qu'en cas de pépins vous vous flinguez un bout de week-end
• 1:20:22
  Voilà,
• 1:20:22
  ça c'est dans les pires cas.
• 1:20:24
  Et de manière générale,
• 1:20:25
  une des bonnes pratiques de mise en production,
• 1:20:27
  c'est de le faire en dehors des horaires où vos utilisateurs sont sur l'application.
• 1:20:34
  Et scénario,
• 1:20:35
  encore idéal,
• 1:20:36
  si jamais vous êtes obligé de le faire,
• 1:20:38
  enfin le coquin n'est pas idéal,
• 1:20:39
  mais si jamais c'est obligé de le faire pendant des heures d'ouverture où les gens sont là,
• 1:20:43
  parce que ça va prendre trop de temps de faire les changements,
• 1:20:46
  quand il y a des grosses refontes,
• 1:20:46
  etc.
• 1:20:47
  On peut avoir un temps de coupure qui est absolument nécessaire.
• 1:20:50
  Et dans ces cas-là,
• 1:20:50
  on prévient à l'avance de se dire « Attention,
• 1:20:53
  ce jour-là,
• 1:20:53
  de telle heure à telle heure,
• 1:20:54
  il peut y avoir des perturbations parce qu'on met une nouvelle version. »
• 1:20:57
  Ou alors
• 1:20:58
  « Pendant de telle heure à telle heure,
• 1:21:00
  le produit sera juste complètement indisponible. »
• 1:21:03
  Et voilà,
• 1:21:06
  prenez vos mesures et soyez attentifs à ça.
• 1:21:11
  Et ce jour-là,
• 1:21:12
  vous pourrez.
• 1:21:14
  Aujourd'hui,
• 1:21:14
  même chose en fonction du domaine et du niveau d'importance de l'application.
• 1:21:19
  généralement il y a aussi des...
• 1:21:22
  je vais pas voir le terme mais en gros il y a tout un plan qui enfin il y a un nom pour les plans qui permettent de fonctionner en mode dégradé et donc quand justement l'application est pas disponible en entièreté ou est coupée pour x raisons de
• 1:21:37
  quand même pouvoir faire tourner le programme dans une manière plus légère pour pouvoir bosser parce qu'on peut dire en fait ce jour là j'ai des fonctionnalités qui marchent pas mais au moins je peux bosser de bout en bout et ça théoriquement
• 1:21:49
  il faudrait avoir ce concept-là dans toutes les boîtes,
• 1:21:52
  de se dire,
• 1:21:53
  est-ce qu'il y a un mode dégradé dans l'application que j'utilise qui me permettra de bosser dans tous les cas ?
• 1:21:57
  Et si jamais ce n'est pas le cas,
• 1:21:59
  est-ce que j'ai un plan B,
• 1:22:01
  tout simplement ?
• 1:22:02
  J'ai des outils de secours qui vont me permettre de bosser ?
• 1:22:05
  Je ne sais pas si tu as le terme en tête,
• 1:22:06
  Lulu,
• 1:22:06
  pour le plan de...
• 1:22:08
  Non,
• 1:22:09
  je ne l'ai pas forcément,
• 1:22:10
  mais...
• 1:22:12
  Bon,
• 1:22:12
  j'essaierai de remettre la note dessus.
• 1:22:14
  En plus,
• 1:22:14
  il y en a quelqu'un dans la communauté de code qui...
• 1:22:17
  qui est spécialisé sur le sujet,
• 1:22:18
  qui en avait déjà pas mal parlé et fait du contenu dessus,
• 1:22:20
  mais je peux avoir l'appel à ça.
• 1:22:24
  Est-ce qu'on est bon sur la mise en production ?
• 1:22:25
  Et comme ça,
• 1:22:26
  on termine très rapidement pour la partie maintenance.
• 1:22:29
  Ouais,
• 1:22:29
  ça me semble bien.
• 1:22:32
  Là,
• 1:22:32
  je pense que vous avez compris pourquoi est-ce que on développe pas sur la partie qui est en prod.
• 1:22:37
  Je pense que là,
• 1:22:38
  c'est à peu près bon.
• 1:22:39
  Est-ce que on connaît,
• 1:22:41
  tout le monde connaît quelqu'un qui le fait,
• 1:22:42
  qui l'a fait ?
• 1:22:44
  C'est d'autant plus vrai.
• 1:22:46
  à l'ère du vibe coding et développement par IA ou même l'application qui est en ligne et de se dire je vais juste faire un petit fixe,
• 1:22:53
  je vais juste changer un petit truc et au final ça casse tout et c'est plus accessible c'est effectivement le vibe coding donc le développement assisté par IA que même si vous bossez seul même si vous bossez,
• 1:23:08
  d'autant plus normalement si vous bossez en équipe vous avez déjà les bons réflexes mais si vous bossez seul et que vous découvrez prenez le temps de vous former sur les
• 1:23:15
  les méthodes et les techniques de développement,
• 1:23:18
  et ne serait-ce que,
• 1:23:19
  parce qu'en fait,
• 1:23:19
  ça s'applique aussi.
• 1:23:20
  Alors,
• 1:23:20
  vous n'êtes pas obligé d'avoir un staging au milieu,
• 1:23:22
  mais en fait,
• 1:23:24
  vous avez quand même besoin d'éprouver ce que vous faites sur un environnement de développement,
• 1:23:29
  donc généralement en local,
• 1:23:31
  sur votre machine,
• 1:23:32
  et ensuite de l'envoyer en production,
• 1:23:34
  donc vraiment sur la partie que les gens utilisent.
• 1:23:37
  Mais aussi,
• 1:23:38
  dans le vibe coding,
• 1:23:39
  il y a moyen d'avoir des environnements de pré-production.
• 1:23:42
  Par exemple,
• 1:23:43
  sur Supabase,
• 1:23:44
  qui est un outil qui fait back-end,
• 1:23:48
  donc base de données,
• 1:23:49
  authentification,
• 1:23:49
  plein de choses,
• 1:23:50
  permet d'avoir des branches qui sont conformes d'un point de vue infrastructure avec la production.
• 1:23:56
  Et du coup,
• 1:23:56
  vous pouvez soit faire vos tests en local,
• 1:24:00
  puis envoyer directement sur la prod une fois que c'est validé,
• 1:24:04
  soit faire vos tests en local,
• 1:24:05
  puis passer par une branche dite de preview et de là envoyer vers la production,
• 1:24:11
  soit faire un espace d'hybride où vous faites vos tests.
• 1:24:14
  directement sur la branche de preview,
• 1:24:16
  vu qu'elle est prévue pour ça,
• 1:24:17
  dans tous les cas.
• 1:24:18
  Et voilà,
• 1:24:18
  il y a plusieurs approches,
• 1:24:19
  mais en tout cas,
• 1:24:19
  même en white coding,
• 1:24:21
  et différents outils le permettent,
• 1:24:23
  Gano le permet,
• 1:24:23
  enfin,
• 1:24:24
  voilà.
• 1:24:25
  Il y a plusieurs approches,
• 1:24:26
  mais en tout cas,
• 1:24:27
  la notion d'environnement et de ne pas bosser directement sur ce que les gens ont dans les mains est fondamentale.
• 1:24:31
  Et après tout ça,
• 1:24:35
  donc,
• 1:24:38
  dernier point,
• 1:24:39
  dernière étape,
• 1:24:41
  votre application est en production.
• 1:24:43
  les gens s'en servent,
• 1:24:44
  la dernière chose qui reste,
• 1:24:46
  c'est la maintenance et le support.
• 1:24:49
  C'est là où on va repartir un petit peu dans un cycle comme on a...
• 1:24:52
  On va refaire un peu tout le cycle,
• 1:24:53
  en fait.
• 1:24:54
  C'est-à-dire que les gens vont vous signaler des soucis,
• 1:24:58
  soit des bugs,
• 1:24:59
  soit des choses qui seraient bien de faire évoluer,
• 1:25:01
  soit des choses qui manquent et qui auraient besoin de nouvelles fonctionnalités.
• 1:25:05
  Et ça va repartir dans l'étape recueil du besoin pour comprendre tout ce qu'on vous demande.
• 1:25:10
  Est-ce que c'est pertinent ou pas ?
• 1:25:13
  Comment on peut le faire ?
• 1:25:14
  Comment on peut le traduire ?
• 1:25:14
  Quand c'est le cas d'un bug,
• 1:25:15
  est-ce qu'il est important,
• 1:25:16
  pas important ?
• 1:25:17
  À quel niveau ?
• 1:25:18
  qu'est-ce que ça implique comme effort de développement pour le réparer rapidement ou pas.
• 1:25:24
  Et ça repart dans tout le cycle derrière,
• 1:25:27
  de développement,
• 1:25:27
  de relecture,
• 1:25:28
  de test,
• 1:25:30
  des différents environnements,
• 1:25:31
  etc.
• 1:25:32
  Et c'est pour ça que,
• 1:25:33
  de toute façon,
• 1:25:34
  même si un bug est corrigé le jour même,
• 1:25:37
  ça ne veut pas dire que vous l'aurez le jour même,
• 1:25:38
  parce qu'il faut qu'il repasse par toutes les étapes.
• 1:25:41
  Et qu'on ne fait pas une mise en production à la légère.
• 1:25:46
  Donc vous avez besoin...
• 1:25:49
  d'attendre généralement d'avoir plusieurs choses qui sont prêtes et développées en même temps avant de faire une mise en production.
• 1:25:55
  Et selon les boîtes,
• 1:25:56
  vous pouvez avoir une mise en production chaque semaine,
• 1:25:58
  chaque deux semaines,
• 1:25:59
  chaque mois,
• 1:25:59
  chaque deux mois,
• 1:26:00
  enfin du coup c'est très variable.
• 1:26:04
  Mais c'est ça le principe.
• 1:26:05
  Et sachant que chaque correction que vous pouvez faire peut vous amener d'autres effets de bord et d'autres problèmes à côté.
• 1:26:11
  D'où l'importance des tests et de chaque étape qu'on a citée au paradis.
• 1:26:16
  Et c'est aussi pour ça que dans les boîtes,
• 1:26:17
  vous aurez généralement les équipes de support.
• 1:26:19
  Et pour avoir bossé dans le support dans pas mal d'années et dans plusieurs boîtes,
• 1:26:25
  je vous confirme que généralement,
• 1:26:26
  les équipes de support sont celles avec les équipes de qualité qui connaissent le mieux le produit dans son entièreté,
• 1:26:33
  parce qu'elles sont amenées à travailler au contact des gens et des retours utilisateurs directement,
• 1:26:38
  donc au contact des métiers,
• 1:26:40
  un terme qu'on a déjà évoqué pas mal de fois,
• 1:26:42
  et en même temps qui manipulent un petit peu.
• 1:26:45
  tout le programme de bout en bout et donc ils sont les plus à même de dire et de savoir il y a ça qui ne marche pas mais en même temps on a une nouveauté à tel endroit qui doit pouvoir impacter ici ou alors il y a peut-être un contournement par tel biais et ainsi de suite et voilà d'où l'importance aussi de la communication entre les différents services dans les boîtes parce que au
• 1:27:05
  développement et d'autant plus quand la boîte va être plus grosse et le produit plus volumineux et qu'il va commencer à avoir de...
• 1:27:13
  du legacy,
• 1:27:13
  donc du code qui est hérité parce que le programme a
• 1:27:16
  5 ans,
• 1:27:17
  10 ans,
• 1:27:17
  15 ans,
• 1:27:18
  20 ans.
• 1:27:19
  C'est impossible d'avoir tout en tête à chaque fois qu'on fait quelque chose,
• 1:27:22
  peu importe le service.
• 1:27:23
  Et à ce titre-là,
• 1:27:26
  c'est de la communication entre les différents services qui va déterminer la qualité de votre produit et de votre application.
• 1:27:31
  Parce que si les infos transitent et que le support est en mesure de vous remonter,
• 1:27:35
  les choses qui vont et qui ne vont pas,
• 1:27:36
  et là où les utilisateurs râlent le plus,
• 1:27:38
  ou les pépins qu'ils ont le plus,
• 1:27:40
  la qualité...
• 1:27:41
  quand ils font les tests,
• 1:27:42
  si vous écoutez ce qu'ils vont vous dire et les évolutions et les ajustements qui seraient intéressants,
• 1:27:46
  c'est vraiment fondamental aussi et après les devs aussi ont leur mot à dire parce qu'ils sont complètement en mesure d'identifier quand il y a des problèmes de performance quand il y a des problèmes de des suggestions dites du hits par exemple un développeur qui va vous faire toute l'interface même
• 1:28:03
  si elle a été maquettée par un designer et par quelqu'un d'autre,
• 1:28:06
  peut très bien vous dire en fait là non
• 1:28:08
  vous m'avez donné ça comme consigne et je suis censé faire tel écran,
• 1:28:11
  mais en fait,
• 1:28:11
  il y a des choses pour moi qui ne vont pas à l'utilisation,
• 1:28:14
  ça va coincer pour telle et telle raison.
• 1:28:16
  Et voilà,
• 1:28:17
  donc à mon sens,
• 1:28:19
  la base d'une bonne application,
• 1:28:22
  ce sera la communication entre les différents intervenants d'un programme,
• 1:28:26
  de bout en bout,
• 1:28:27
  et de tenir compte du fait que chaque étape est importante et chaque personne que vous avez à chaque étape est importante.
• 1:28:34
  Et c'est vrai que j'avais vu certaines boîtes justement où...
• 1:28:38
  Parfois,
• 1:28:38
  on peut avoir l'idée que les devs sont un peu déconnectés de ce qui se passe et comment le produit est utilisé.
• 1:28:45
  Et justement,
• 1:28:45
  de faire tourner les devs aussi sur le support pour qu'ils soient au contact des utilisateurs et de se dire,
• 1:28:52
  ça fait une,
• 1:28:53
  deux fois qu'on me demande ça.
• 1:28:55
  Bon,
• 1:28:55
  je n'ai pas envie qu'on me redemande la prochaine fois,
• 1:28:57
  donc je vais le corriger.
• 1:28:58
  Et ça peut donner d'autant plus de sens à un geste qui va être soit correctif,
• 1:29:07
  adaptatif ou perfectif.
• 1:29:09
  Ça,
• 1:29:09
  c'est les différentes modifications qu'on peut faire.
• 1:29:13
  Mais c'est là où c'est intéressant de pas juste rester cloisonné.
• 1:29:18
  C'est vrai que c'est quelque chose qui est assez français,
• 1:29:21
  de cloisonner les différents métiers,
• 1:29:24
  les différentes compétences.
• 1:29:25
  Là où,
• 1:29:26
  par contre,
• 1:29:26
  par exemple,
• 1:29:27
  aux États-Unis,
• 1:29:27
  ils vont plus travailler par feature.
• 1:29:29
  Donc là,
• 1:29:30
  ça va être vraiment,
• 1:29:31
  on va travailler sur une fonctionnalité et...
• 1:29:35
  Il y a du bon et du moins bon dans chaque modèle,
• 1:29:38
  mais parfois,
• 1:29:40
  on peut manquer un peu de prise de hauteur et de se dire comment est-ce que ça s'intègre.
• 1:29:48
  tout le parcours parce que forcément chaque...
• 1:29:51
  compétences,
• 1:29:52
  chaque personne va avoir un biais par rapport à ce qu'il fait et de se dire,
• 1:29:56
  moi c'est plus important alors que le support va dire autre chose,
• 1:29:59
  le développeur va dire autre chose et en même temps,
• 1:30:01
  côté marketing ils vont encore dire autre chose et voilà,
• 1:30:04
  il faut réussir à faire communiquer tout ça et encore une fois la communication,
• 1:30:10
  de s'ouvrir aussi même sans forcément savoir le faire et que ça devienne nos compétences,
• 1:30:18
  là c'est un peu ce qu'on essaye aussi de faire avec cet épisode,
• 1:30:20
  de donner les clés pour
• 1:30:21
  pour pouvoir communiquer avec quelqu'un qui le fera ou si on a envie de se mettre à développer,
• 1:30:28
  d'avoir ce qu'il faut en tête pour avancer et apprendre.
• 1:30:32
  Oui,
• 1:30:33
  et là,
• 1:30:34
  on n'a pas détaillé toutes les méthodes parce qu'on vous en doutait.
• 1:30:37
  Là,
• 1:30:37
  on vous a donné les grandes lignes de choses qui reviennent à chaque fois dans un développement d'application.
• 1:30:42
  Mais il y a plusieurs méthodes de le faire,
• 1:30:45
  plusieurs méthodes de travail en équipe,
• 1:30:48
  il y a plein d'organisations,
• 1:30:49
  il y a plein de...
• 1:30:50
  Et voilà,
• 1:30:50
  comme on l'a dit,
• 1:30:51
  en fonction de la taille de boîte,
• 1:30:52
  en plus,
• 1:30:53
  ça va jouer.
• 1:30:54
  Mais ce qui est important de retenir,
• 1:30:57
  c'est les différentes étapes qu'on vous a données aujourd'hui pour que vous ayez en tête que quand quelqu'un fait un programme,
• 1:31:04
  qu'il soit tout seul ou que ce soit une équipe de 10 ou de 20 ou de 2000,
• 1:31:08
  derrière,
• 1:31:09
  ce n'est pas juste j'ai besoin de ça et on le couche sur un écran une journée.
• 1:31:15
  Même quand c'est rapide,
• 1:31:16
  même quand c'est tout seul avec du développement assisté parier,
• 1:31:18
  etc.
• 1:31:19
  Il y a tout un cheminement à avoir,
• 1:31:21
  toute une logique à avoir si on veut faire les choses bien.
• 1:31:23
  Et c'est là où il faut être aussi méfiant et vigilant quand on fait du vibe coding.
• 1:31:27
  Ça ne veut pas dire qu'il ne faut pas faire de développement assisté par IA,
• 1:31:29
  ça ne veut pas dire que tout ce qui est fait en vibe coding sera mauvais ou sera bon,
• 1:31:34
  parce que si il est fait,
• 1:31:35
  il le fera bien et tout.
• 1:31:36
  On a déjà évoqué le sujet,
• 1:31:38
  l'IA reste un outil.
• 1:31:40
  Potentiellement un très bon exécutant,
• 1:31:42
  mais derrière,
• 1:31:43
  c'est à vous de driver et d'avoir en tête le chemin justement et les logiques.
• 1:31:49
  Je j'ose espérer.
• 1:31:50
  En tout cas,
• 1:31:50
  je vous souhaite que la prochaine fois que vous discutiez avec quelqu'un de votre boîte ou un collègue ou de la famille ou des amis qui bosse dans un des services qu'on a évoqués aujourd'hui,
• 1:32:00
  ce soit un peu moins obscur pour vous de savoir quel rôle il a dans le chemin d'une application en tout cas.
• 1:32:09
  Même si effectivement,
• 1:32:09
  on n'est pas rentré dans le détail de chaque service.
• 1:32:14
  C'est de se dire que ce sont les grandes étapes d'un logiciel,
• 1:32:16
  mais après,
• 1:32:17
  ça peut être aussi une partie dans le logiciel.
• 1:32:19
  Et c'est là où on va justement arriver sur différents modèles,
• 1:32:23
  juste rapidement.
• 1:32:24
  Parce que je pense que tout le monde connaît l'agilité,
• 1:32:27
  la méthode agile.
• 1:32:28
  C'est vrai qu'on n'en a pas forcément parlé,
• 1:32:30
  mais là,
• 1:32:31
  ce qu'on a un petit peu décrit,
• 1:32:35
  c'est la méthode en cascade.
• 1:32:38
  même si c'est pas forcément celle qui qui me
• 1:32:42
  marche le mieux si on le fait à l'échelle d'un logiciel parce que là,
• 1:32:44
  c'est ok,
• 1:32:45
  on met des besoins,
• 1:32:46
  on développe,
• 1:32:47
  on développe,
• 1:32:47
  et puis à la fin le client,
• 1:32:48
  il a quelque chose et c'est potentiellement pas forcément ce qu'il attendait,
• 1:32:53
  donc c'est là où il...
• 1:32:56
  En fait,
• 1:32:57
  avec une approche itérative,
• 1:32:58
  t'as quand même ces cycles-là,
• 1:33:00
  d'une manière ou d'une autre.
• 1:33:01
  Oui,
• 1:33:01
  mais en plus petit.
• 1:33:05
  Enfin,
• 1:33:05
  c'est...
• 1:33:05
  Ouais,
• 1:33:06
  en plus petit.
• 1:33:07
  Sur un périmètre peut-être plus petit aussi.
• 1:33:09
  C'est ça,
• 1:33:09
  sur ton périmètre.
• 1:33:10
  c'est-à-dire que tu ne vas pas attendre 6 mois avant de donner ta première version,
• 1:33:14
  tu vas le faire,
• 1:33:15
  comme je disais,
• 1:33:16
  ça peut être une fois par semaine,
• 1:33:17
  toutes les deux semaines,
• 1:33:18
  tous les un mois,
• 1:33:19
  selon la taille de boîte et selon les versions.
• 1:33:21
  Mais ce cycle-là de développement,
• 1:33:25
  de test,
• 1:33:26
  de mise en prod,
• 1:33:27
  etc.,
• 1:33:27
  tout ça,
• 1:33:27
  il faut quand même y passer,
• 1:33:28
  le recueil des besoins aussi.
• 1:33:29
  Mais c'est vrai que dans la partie itérative,
• 1:33:33
  quand on va penser une nouvelle fonctionnalité,
• 1:33:34
  le recueil des besoins,
• 1:33:35
  on va le faire différemment.
• 1:33:37
  On va aller discuter avec les gens,
• 1:33:38
  on va aller faire...
• 1:33:39
  des fois des maquettes ou des prototypes qu'on va leur mettre dans les mains,
• 1:33:44
  qui ne seront pas dans la version finale que tout le monde utilise,
• 1:33:46
  mais qui seront réservées à un petit groupe d'utilisateurs et d'utilisatrices qui vont pouvoir utiliser cette version-là un peu bricolée et dire « en fait,
• 1:33:54
  ça,
• 1:33:55
  ça marche bien,
• 1:33:55
  ça,
• 1:33:55
  ça ne marche pas bien » .
• 1:33:56
  Et à partir de là,
• 1:33:57
  on va développer la vraie version qui sera intégrée au logiciel.
• 1:34:01
  Et dans les parties recueil de besoins,
• 1:34:03
  justement,
• 1:34:03
  ça va être plus ou moins long.
• 1:34:04
  Dans la partie développement,
• 1:34:05
  ça va être sur le prototype qui sera plus ou moins gros,
• 1:34:07
  qui sera intégré à une prochaine version.
• 1:34:10
  En tout cas,
• 1:34:10
  les grandes étapes sont là,
• 1:34:12
  même en mode itératif et même avec d'autres approches,
• 1:34:15
  mais effectivement avec des durées différentes,
• 1:34:19
  avec des périmètres différents et avec des actions qui peuvent être un peu différentes aussi.
• 1:34:24
  Il n'y a pas une méthode qui est meilleure que les autres.
• 1:34:27
  Ça va vraiment dépendre du type de logiciel développé,
• 1:34:30
  du type d'équipe.
• 1:34:33
  Il y a même des moments où la cascade ou le cycle en V reste pertinent par rapport...
• 1:34:39
  à une méthode agile,
• 1:34:40
  même mal appliquée,
• 1:34:41
  où on va faire un peu d'agilité de façade,
• 1:34:44
  ou du scrum.
• 1:34:45
  Il y a certains...
• 1:34:49
  contextes,
• 1:34:50
  notamment réglementaires ou alors qui vont toucher à toute la partie hardware,
• 1:34:54
  qui vont faire qu'un framework de développement sera plus pertinent qu'un autre.
• 1:34:58
  Donc c'est pas genre,
• 1:35:00
  si je me mets à développer,
• 1:35:01
  il faut forcément que ce soit avec une méthode agile.
• 1:35:06
  Il faut aussi se poser ces questions,
• 1:35:08
  c'est comme un peu dire il y a un meilleur outil qu'un autre,
• 1:35:11
  il y a un meilleur langage qu'un autre pour développer.
• 1:35:14
  A chaque fois,
• 1:35:14
  c'est en fonction,
• 1:35:15
  c'est qu'un outil qui va répondre.
• 1:35:17
  qui va aider à répondre du mieux possible à un besoin.
• 1:35:20
  Comme il y a,
• 1:35:20
  voilà,
• 1:35:21
  si elle peut être pertinente,
• 1:35:22
  c'est bien,
• 1:35:23
  mais ce n'est pas forcément une finalité.
• 1:35:26
  Oui,
• 1:35:27
  on est vraiment d'accord.
• 1:35:29
  Bon,
• 1:35:30
  on a fait notre plus gros et plus long numéro jusqu'à présent,
• 1:35:35
  mais au moins,
• 1:35:35
  vous avez le chemin complet.
• 1:35:38
  J'espère que ça vous aura plu.
• 1:35:39
  Il y a toute la partie sécurité aussi,
• 1:35:41
  mais ça,
• 1:35:42
  on peut le mettre dans les tests.
• 1:35:44
  Il y aurait,
• 1:35:45
  mais après,
• 1:35:45
  il y aurait...
• 1:35:46
  Mais voilà.
• 1:35:46
  Le bon logiciel,
• 1:35:47
  ce n'est pas infini,
• 1:35:48
  mais oui,
• 1:35:49
  il y aurait la partie sécurité,
• 1:35:50
  il y aurait la partie sauvegarde,
• 1:35:51
  mais tu as d'autres choses dans la maintenance,
• 1:35:53
  dans le support.
• 1:35:54
  C'est ça,
• 1:35:54
  mais ça,
• 1:35:54
  c'est comme on a dit pour les tests,
• 1:35:56
  il faut aussi la penser à chaque étape.
• 1:35:58
  Ce n'est pas à la fin,
• 1:35:58
  on vérifie que notre application est sécurisée.
• 1:36:02
  On va demander à Cloud Code,
• 1:36:04
  on vérifie si l'application est sécure et que c'est bon,
• 1:36:09
  les gens peuvent effectuer des paiements,
• 1:36:10
  créer des comptes sans souci dessus.
• 1:36:13
  Non,
• 1:36:13
  c'est aussi à chaque étape et ça inclure aussi dans les tests.
• 1:36:17
  Parfait.
• 1:36:18
  Merci Lulu de m'avoir accompagné sur cet épisode.
• 1:36:21
  On se retrouve la semaine prochaine pour la suite de notre épisode côté outils sur le développement de notre portail.
• 1:36:30
  Maintenant qu'on vous a expliqué tout ça,
• 1:36:32
  ce sera beaucoup plus simple à suivre.
• 1:36:34
  Et rassurez-vous,
• 1:36:36
  l'épisode sur la suite du portail sera plus court.
• 1:36:39
  J'espère qu'il sera plus court maintenant qu'on a pris le temps de tout expliquer.
• 1:36:43
  Oui,
• 1:36:43
  on a déjà fait une première moitié.
• 1:36:45
  pour vraiment aller montrer comment on a mis les mains dans le cambouis et puis avec des côtés,
• 1:36:50
  enfin outils là pour le coup.
• 1:36:54
  Oui.
• 1:36:54
  Voilà.
• 1:36:56
  Merci à tous et à toutes de nous avoir écoutés.
• 1:36:59
  On vous souhaite une bonne journée ou bonne fin de journée selon quand vous nous écouterez et on se retrouve la semaine prochaine avec Lulu.
• 1:37:06
  Salut.