Comment gérez-vous le code de développement et le code de production?

Quelles sont les meilleures pratiques et règles de base à suivre tout en maintenant le code? Est-ce une bonne pratique d’avoir uniquement le code de production prêt dans la twig de développement, ou le dernier code non testé doit-il être disponible dans la twig de développement?

Comment gérez-vous votre code de développement et votre code de production?

Edit – Question supplémentaire – Est-ce que votre équipe de développement suit le protocole “commit-as-soon-as-possible-souvent-even-the-code-contains-minor-bugs-ou-est-incomplet”? ONLY-perfect-code “protocole en validant le code à la twig de développement?

Tout dépend de la nature séquentielle de votre gestion des versions

Tout d’abord, tout dans votre coffre est-il vraiment pour la prochaine version ? Vous pourriez découvrir que certaines des fonctions actuellement développées sont:

  • trop compliqué et doit encore être affiné
  • pas prêt à temps
  • intéressant mais pas pour cette prochaine version

Dans ce cas, la jonction doit contenir tous les efforts de développement en cours, mais une twig de publication définie avant la prochaine version peut servir de twig de consolidation dans laquelle seul le code approprié (validé pour la prochaine version) est fusionné, puis corrigé pendant la phase d’homologation. et finalement congelé à mesure qu’il entre en production.

En ce qui concerne le code de production, vous devez également gérer vos twigs de correctifs , tout en gardant à l’esprit que:

  • le premier ensemble de correctifs pourrait en fait commencer avant la première mise en production (ce qui signifie que vous allez entrer en production avec certains bogues que vous ne pouvez pas corriger à temps, mais vous pouvez commencer à travailler sur ces bogues dans une twig distincte)
  • les autres twigs de patchs auront le luxe de partir d’un label de production bien défini

En ce qui concerne la twig dev, vous pouvez avoir une seule ligne, à moins que vous n’ayez d’autres efforts de développement à faire en parallèle comme:

  • refactorisation massive
  • test d’une nouvelle bibliothèque technique qui pourrait changer la façon dont vous appelez les choses dans d’autres classes
  • début d’un nouveau cycle de publication où d’importants changements architecturaux doivent être incorporés.

Maintenant, si votre cycle de développement est très séquentiel, vous pouvez aller comme le suggèrent les autres réponses: une ligne et plusieurs twigs de la version. Cela fonctionne pour les petits projets où tout le développement est sûr de passer à la prochaine version, et peut simplement être gelé et servir de sharepoint départ pour la twig de publication, où les correctifs peuvent avoir lieu. C’est le processus nominal, mais dès que vous avez un projet plus complexe, ce n’est plus suffisant.


Pour répondre au commentaire de Ville M.:

  • Gardez à l’esprit que la twig dev ne signifie pas «une twig par développeur» (ce qui déclencherait une «folie de fusion», dans la mesure où chaque développeur devrait fusionner le travail des autres pour voir / obtenir leur travail), mais une twig de développement par développement effort.
  • Lorsque ces efforts doivent être réintégrés dans le tronc (ou toute autre twig “principale” ou version que vous définissez), ceci est le travail du développeur, et non – je le répète, PAS – le gestionnaire SC (qui ne saurait résoudre toute fusion en conflit). Le chef de projet peut superviser la fusion, ce qui signifie s’assurer qu’il commence / se termine à temps.
  • quel que soit votre choix pour faire la fusion, le plus important est:
    • avoir des tests unitaires et / ou un environnement d’assemblage dans lequel vous pouvez déployer / tester le résultat de la fusion.
    • avoir défini une balise avant le début de la fusion afin de pouvoir revenir à l’état précédent si cette fusion s’avère trop complexe ou plutôt longue à résoudre.

Nous utilisons:

  • twig de développement exclusivement

jusqu’à ce que le projet soit presque terminé ou que nous créons une version de jalon (par exemple, une démonstration de produit, une version de présentation), nous allons (régulièrement) relier notre twig de développement actuel au:

  • twig de libération

Aucune nouvelle fonctionnalité n’entre dans la twig de publication. Seuls les bogues importants sont corrigés dans la twig de publication et le code pour corriger ces bogues est réintégré dans la twig de développement.

Le processus en deux parties avec une twig de développement et une twig stable (publication) nous simplifie la vie, et je ne pense pas que nous pourrions en améliorer une partie en introduisant davantage de twigs. Chaque twig a également son propre processus de construction, ce qui signifie que chaque fois qu’un nouveau processus de génération est généré, nous avons un nouvel exécutable de toutes les versions et twigs de la construction après environ une demi-heure.

De manière occasionnelle, nous avons également des succursales pour un seul développeur travaillant sur une technologie nouvelle et non prouvée, ou créant une preuve de concept. Mais généralement, cela ne se fait que si les modifications affectent de nombreuses parties du code. Cela se produit en moyenne tous les 3 ou 4 mois et une telle succursale est généralement réintégrée (ou supprimée) dans un délai d’un mois ou deux.

En général, je n’aime pas l’idée que chaque développeur travaille dans sa propre twig, parce que vous «passez directement à l’intégration». Je le déconseillerais fortement. Si vous avez un code commun, vous devriez tous travailler ensemble. Cela rend les développeurs plus prudents à propos de leurs checkins et, avec l’expérience, tous les codeurs savent quels changements risquent de casser la construction et les tests sont donc plus rigoureux dans de tels cas.

Sur la première question de l’enregistrement:

Si vous ne souhaitez enregistrer que CODE PARFAIT , rien ne doit être archivé. Aucun code n’est parfait, et pour que le QA le vérifie et le teste, il doit être dans la twig de développement afin de créer un nouvel exécutable.

Pour nous, cela signifie qu’une fois qu’une fonctionnalité est terminée et testée par le développeur, elle est archivée. Elle peut même être archivée s’il existe des bogues connus (non fatals), mais dans ce cas, les personnes affectées par le bogue sont généralement informé. Le code incomplet et le code de travail en cours peuvent également être archivés, mais uniquement s’ils ne provoquent pas d’effets négatifs évidents, tels que des plantages ou des fonctionnalités existantes.

De temps en temps, un code et une vérification de données combinés inévitables rendront le programme inutilisable jusqu’à ce que le nouveau code ait été construit. Le moins que nous fassions est d’append un “WAIT FOR BUILD” dans le commentaire d’enregistrement et / ou d’envoyer un e-mail.

Pour ce que cela vaut, voici comment nous le faisons.

La plupart des développements sont effectués dans le tronc, bien que les fonctions expérimentales ou les éléments susceptibles de briser le système aient tendance à avoir leur propre twig. Cela fonctionne plutôt bien car cela signifie que chaque développeur a toujours la dernière version de tout dans sa copie de travail.

Cela signifie qu’il est important de garder le coffre en ordre de marche, car il est parfaitement possible de le casser complètement. En pratique, cela ne se produit pas souvent et est rarement un problème important.

Pour une version de production, nous allons twigr le tronc, cesser d’append de nouvelles fonctionnalités et travailler sur la correction des bogues et le test de la twig (fusionnant régulièrement dans le tronc) jusqu’à ce qu’elle soit prête pour la publication. À ce stade, nous effectuons une fusion finale dans le tronc afin de nous assurer que tout est bien là, puis relâché.

La maintenance peut alors être effectuée sur la twig de publication si nécessaire, et ces correctifs peuvent être facilement fusionnés dans une jonction.

Je ne prétends pas que ce soit un système parfait (et il a encore quelques trous – je ne pense pas que notre gestion des versions est un processus suffisamment serré), mais cela fonctionne assez bien.

Pourquoi personne n’en parle encore? Un modèle de twigment Git réussi .

C’est pour moi le modèle de twigment ultime!

Si votre projet est petit, n’utilisez pas tout le temps les différentes twigs (peut-être pourriez-vous ignorer les twigs pour les petites fonctionnalités). Mais sinon, c’est la façon de le faire!

modèle de branchement

Code de développement sur les twigs, code Live tagué sur la ligne.

Il n’y a pas besoin d’une règle de “validation uniquement du code parfait” – tout ce qui manque au développeur doit être pris en compte à quatre endroits: la révision du code, les tests de twig, les tests de régression et les tests finaux d’assurance qualité.

Voici une explication pas à pas plus détaillée:

  1. Faites tout le développement sur une twig, en vous engageant régulièrement au fur et à mesure.
  2. Code indépendant Révision des modifications une fois que tout le développement est terminé.
  3. Puis passez la twig à Testing.
  4. Une fois le test de twig terminé, fusionnez le code dans la twig Release Candidate.
  5. La twig Release Candidate est testée après chaque fusion.
  6. QA final et UA Testing effectués sur RC après la fusion de toutes les twigs de développement.
  7. Une fois que QA et UAT sont passés, fusionnez la twig release dans la twig MAIN / TRUNK.
  8. Enfin, marquez la ligne de réseau à ce stade et déployez cette balise sur Live.

dev va dans le tronc (svn style) et les versions (code de production) obtiennent leurs propres twigs

C’est le “modèle d’objective par twig” (figure 3 dans L’importance des modèles de twigment /! \ Pdf)

Nous résolvons ce problème en séparant complètement le code de production (le tronc principal) du code de développement (où chaque développeur a sa propre twig).

Aucun code n’est autorisé dans le code de production avant d’avoir été soigneusement vérifié (par les réviseurs d’assurance qualité et de code).

De cette façon, il n’y a pas de confusion sur le code qui fonctionne, c’est toujours la twig principale.

Oh oui – une autre chose – nous gardons du code de non-production (c.-à-d. Ce qui ne sera JAMAIS publié – par exemple des scripts d’outils, des utilitaires de test) dans cvs HEAD. Habituellement, il doit être clairement marqué pour que personne ne le lâche “accidentellement”.

Nous nous développons sur le tronc qui est ensuite ramifié toutes les deux semaines et mis en production. Seuls les bogues critiques sont corrigés dans la twig, le rest peut attendre encore deux semaines.

Pour le trunk, la seule règle est que le commit ne doit rien casser. Pour gérer le code Wip et le code non testé, nous ajoutons simplement les statuts if appropriées pour activer et désactiver facilement le code.

Fondamentalement, il serait possible de twigr le tronc à tout moment et de le mettre en production.

J’utilise git et j’ai 2 twigs: master et maint

  • master – code de développement
  • maint – code de production

quand je libère du code en production, je le tague et je fusionne le master pour la twig maint . Je déploie toujours à partir de la twig maint . Les correctifs de la twig de développement Je les sélectionne pour les twigr et les déployer.

Nous avons une twig “release” qui contient ce qui est actuellement en production ou sera déployée sous peu (déjà passée la plupart des QA)

Chaque projet, ou dans certains cas une autre unité, possède sa propre twig qui est issue de la version.

Les modifications sont engagées par les développeurs du projet dans la twig de leur projet. Périodiquement, la version est fusionnée dans une twig de développement.

Une fois que les lots de travaux de la twig sont tous QA (test unitaire, test du système, révision du code, contrôle de la qualité, etc.), la twig est fusionnée dans la twig de publication. Les nouvelles versions sont créées à partir de la twig de publication et la validation finale a lieu sur cette version.

Le processus est fondamentalement OK jusqu’à ce qu’un problème soit découvert après une fusion. Si un WP est “bloqué” après sa fusion, il conserve tout ce qui suit jusqu’à ce qu’il soit corrigé (nous ne pouvons pas faire une autre version tant que celui bloqué n’est pas sorti).


C’est également quelque peu flexible – un changement très sortingvial pourrait se produire directement sur la twig de publication si elle était diffusée sur une très courte période (environ 1 à 2 jours par exemple).

Si une modification était apscope directement à la production pour une raison quelconque (un problème de production critique pour le client qui nécessitait un changement de code immédiat), ces modifications seraient remises dans BRANCH_RELEASE. Cela n’arrive presque jamais.

Cela depend du projet. Notre code Web est archivé de manière cohérente, alors que notre code d’application est uniquement archivé s’il est compilé. J’ai remarqué que cela ressemble beaucoup à la manière dont nous publions les choses. Les contenus Web montent chaque fois que possible pendant que les applications atteignent un délai très court. Je n’ai pas vu une perte de qualité dans l’une ou l’autre méthode cependant.