Pouvez-vous faire un déploiement continu avec des programmeurs juniors?

Il y a un moment où vous commencez à comprendre que, dans l'architecture de micro-services, il est plus effrayant d'attendre une semaine pour déployer tous les micro-services à la fois pour vous assurer que tout fonctionne ensemble, que pour appliquer strictement le versionnage de l'API, écrire beaucoup de tests (un peu de chacun: unitaire et exploratoire, intégration), et déploiement automatique en production dès que votre commit passe comme test sur scène.

Maintenant, cela ressemble à une excellente idée tant que vous vous souvenez d'écrire des tests, de tester vos modifications avant de vous engager, de savoir comment utiliser le versionnage de l'API et que vous n'allez pas supprimer la base de données dans votre script de mise à jour de base de données incrémentielle exécuté lors du déploiement (qui n'est pas un gros problème car il devrait échouer sur scène).

Mais est-il possible de le faire avec des programmeurs juniors? Peut-être que je devrai implémenter un schéma de demande de pull. Cela rendrait-il moins le déploiement continu (c'est ma supposition)?

J'espère que ce n'est pas basé sur une opinion et je peux compter sur vous pour partager votre expérience, merci.

Veuillez noter que je ne pose aucune question sur CI ni sur la livraison continue. Nous l'avons déjà. Ce que nous essayons maintenant, c'est d'en faire un déploiement continu, ce qui signifie que tout est en production juste après l'enregistrement du code.

Pourquoi pas? Toutes les choses que vous décrivez constitueraient un problème, que vous utilisiez ou non un déploiement continu. Le problème, semble-t-il, est que vous craignez que les juniors commettent une erreur catastrophique. Et que cette erreur sera précipitée dans la production avant que quiconque puisse l'attraper.

C'est pourquoi vous faites des revues de code et faites des tests. Avant que quoi que ce soit ne soit fusionné dans votre branche principale et prévu pour publication, exigez qu'il soit revu par du code, à la fois par d'autres juniors (afin qu'ils acquièrent de l'expérience) et par des développeurs seniors (pour utiliser leur expertise pour améliorer le code). Tout le monde devrait rechercher ces bogues catastrophiques. Et cela devrait les arrêter. Si ce n'est pas le cas, vous avez probablement besoin d'un meilleur contrôle qualité / test sur un environnement de transfert (et peut-être de meilleurs développeurs si les revues de code manquent ces choses).

Le déploiement continu fonctionnera bien si vous disposez d'un bon ensemble de tests automatisés.

Les développeurs juniors peuvent se passionner pour leur propre tâche et ne voient pas qu'ils cassent les choses. Vous pouvez résoudre ce problème avec une certaine automatisation. Configurez un serveur de build qui exécutera des tests tout le temps, et procurez-leur un outil comme le notificateur de build CatLight . Cela leur donnera une rétroaction rapide et claire lorsqu'ils cassent des choses.

Ils régleront les petits problèmes au fur et à mesure et maintiendront votre livraison continue.

La seule façon d'apprendre de bonnes habitudes est de les pratiquer, donc oui les développeurs juniors peuvent également pratiquer le déploiement continu. Vous voudrez peut-être réfléchir à l'ajout d'étapes dans le pipeline pour faire des choses comme vérifier la couverture des tests et éventuellement exécuter une analyse de code statique, et échouer la génération si la couverture des tests n'est pas suffisamment élevée. Cela garantira que les développeurs juniors comprennent les attentes avant que quelque chose soit considéré comme terminé.

Non seulement vous pouvez le faire avec des développeurs juniors, mais cela vous est demandé. Tout d'abord, vous réduirez la qualité de votre logiciel autrement, et deuxièmement, cela aidera les développeurs juniors à acquérir de bonnes compétences en développement de logiciels.

Par analogie: Souhaitez-vous que votre médecin ne pratique pas la médecine à sa connaissance, car il aura peur des erreurs d'apprentissage des jeunes? Comment les médecins traitent-ils les dommages potentiels?

De l'expérience passée avec une base de code Big Ball Of Mud qui a évolué naturellement pendant de nombreuses années entre les mains de nombreux développeurs juniors non supervisés, je voudrais souligner ce qui se passe lorsque vous ne pratiquez pas CI avec ces développeurs.

Édition / mise à jour : selon le commentaire de RubberDuck; cette réponse suppose que votre cible de fusion pour l'intégration est une branche de développement plutôt qu'une branche d'évaluation ou de publication.

• De toute évidence, il doit y avoir beaucoup plus de contrôle sur le code pour la publication et le déploiement en direct; s'il n'y a pas de branche de production distincte, il serait utile d'envisager une modification de votre stratégie de branchement / fusion pour exécuter une branche de développement principale (qui est utilisée pour les tests d'intégration et jamais pour la publication) à côté de la branche de publication principale. Cela conserve tous les avantages de CI et les fusions fréquentes sans risquer de casser le code de production.

1. Les développeurs juniors sont moins susceptibles de communiquer avec leurs collègues ou leur superviseur

L'intégration continue n'est pas simplement une question de fusion dans le code, c'est un moment où un développeur est obligé d'interagir avec d'autres parties prenantes.

La communication est importante, et sans vouloir trop généraliser, elle tend à être une compétence acquise qui arrive moins naturellement aux développeurs inexpérimentés qu'à ceux qui ont l'habitude de travailler en équipe.

Si vous permettez aux développeurs juniors de s'asseoir dans leur cabine et de se défouler sur le code pendant des semaines sans qu'on leur demande des rapports / révisions fréquents, alors ils sont plus susceptibles d'éviter complètement la communication.

2. Le code qu'ils produisent nécessitera probablement un examen plus rigoureux

Avez-vous déjà revu quelque chose de si mauvais que vous auriez aimé l'avoir ramassé plus tôt et l'avoir empêché d'avoir été écrit? Cela arrive souvent.

Vous ne pouvez pas empêcher l'écriture de mauvais code, mais vous pouvez limiter le temps perdu. Si vous vous engagez à effectuer des révisions et des fusions fréquentes, vous réduisez la possibilité de perte de temps.

Le pire des cas est que vous puissiez laisser un développeur junior seul pendant plusieurs semaines sur son propre projet miniature, et quand ils sont enfin prêts pour la révision du code, il ne leur reste tout simplement pas assez de temps pour jeter tout le bordel loin et recommencer à zéro.

De nombreux projets deviennent une grosse boule de boue simplement parce qu'une charge entière de mauvais code a été écrite lorsque personne n'y prêtait attention jusqu'à ce qu'il soit trop tard.

3. Vous devez être moins certain qu'un développeur junior ou un autre nouveau membre de l'équipe a compris les exigences

Parfois, un développeur peut créer la solution parfaite au mauvais problème; celui-ci est triste car il s'agit généralement de simples malentendus qui seraient si faciles à éviter si seulement quelqu'un avait posé les bonnes questions plus tôt dans le processus.

Encore une fois, c'est un problème qui est plus susceptible d'affecter les développeurs inexpérimentés qui sont plus susceptibles d'accepter les «mauvaises» exigences à leur valeur nominale au lieu de repousser et de remettre en question la sagesse de l'exigence.

4. Ils connaissent probablement moins les modèles courants, l'architecture du code existant et les outils et solutions bien connus.

Parfois, un développeur passe beaucoup de temps à réinventer la roue inutilement simplement parce qu'il ne savait même pas qu'une meilleure solution existait. Ou ils pourraient passer des jours à essayer de marteler une cheville carrée dans un trou rond sans réaliser ce qu'ils font de mal.

Encore une fois, ce genre de chose est plus susceptible d'arriver aux développeurs inexpérimentés, et la meilleure façon de résoudre le problème est d'assurer des révisions régulières.

5. De longues périodes entre les validations / fusions de code rendent les défauts plus difficiles à identifier et à corriger

Lorsqu'un bogue émerge immédiatement après plusieurs semaines de modifications de code ont été fusionnées dans la branche principale, le défi d'identifier quel changement peut avoir causé le bogue devient plus difficile.

De toute évidence, votre stratégie globale de branchement entre également en jeu ici; idéalement, tous vos développeurs travailleront soit dans leurs propres branches, soit dans des branches de fonctionnalités (ou les deux), et ne fonctionneront jamais directement depuis le master / trunk.

J'ai vu des situations où des équipes entières travaillent toutes directement dans le maître / tronc en même temps, et c'est un environnement terrible pour CI, mais heureusement, la solution consistant à éloigner tout le monde du maître / tronc offre généralement suffisamment de stabilité pour le travail individuel articles / billets / etc.

Il devrait toujours être "OK" pour tout développeur de rompre la branche maître / tronc, étant entendu que la fusion devrait avoir lieu de manière régulière, que les modifications et les défauts de rupture devraient être identifiés plus rapidement, et donc résolus plus rapidement aussi. Les pires défauts sont généralement ceux qui ne sont pas détectés pendant des mois, voire des années.

En résumé; les principaux avantages de l'intégration continue / du déploiement continu sont:

• La communication entre votre équipe s'améliore
• La qualité du code est généralement maintenue à un niveau plus élevé
• Les exigences sont moins susceptibles d'être manquées ou mal interprétées
• Les problèmes d'architecture et de conception doivent être détectés plus rapidement,
• Les défauts sont plus susceptibles d'être détectés et corrigés à un stade plus précoce

Donc, si vous ne pratiquez pas CI avec vos développeurs juniors, vous acceptez beaucoup de risques inutiles importants, car ce sont les membres de votre équipe qui en ont plus besoin que les autres.

Oui, vous pouvez pratiquer CI avec des développeurs juniors. Il serait stupide de ne pas le faire dans le climat de développement actuel. Il est incroyablement utile de pouvoir pousser pour repo, puis de le fusionner automatiquement en code de mise en scène - et de tout regarder en temps réel dans Travis (ou Bamboo, Pipelines etc ...)!

Emmenez votre gars DevOps et demandez-lui de passer par le processus avec eux, ainsi qu'un développeur senior en veille juste pour surveiller les choses et le relier à leurs révisions de code (vous faites cela, non?)

Si votre souci est que le code shite passe, ce n'est pas sur le CI et ce n'est pas sur les juniors: c'est sur vous .

Alors aidez-les à s'améliorer et à s'habituer à déployer plus rapidement le code stage / prod. Vous vous remercierez à long terme.