Quelle est l'importance des constructions quotidiennes? [fermé]

Un des critères du test Joel est la construction quotidienne. L'idée est que si le build est cassé, celui qui l'a cassé est là pour le réparer. Si la construction ne peut pas être corrigée, tout le monde devra vérifier une ancienne version et y travailler. Je peux comprendre comment cela peut être assez mauvais sur le contrôle de version centralisé où il est important d'éviter la fusion et la ramification autant que possible, mais cela ne ressemble qu'à une nuisance mineure pour le contrôle de version distribué. Es-tu d'accord avec ça? Y a-t-il d'autres raisons pour lesquelles les versions quotidiennes sont importantes?

Je pense que ce qui est important à noter ici, c'est que les versions régulières aident à détecter les erreurs le plus tôt possible . Il n'a pas a être tous les jours, mais assez souvent. Idéalement, il peut également exécuter vos tests unitaires.

Le but est de savoir quand une build se casse avant la phase de test finale, pour les retrouver le plus rapidement possible.

Il vous suffit de le configurer pour créer votre ou vos branches de développement principales.

Nous l'utilisons au travail (bien que nous construisions toutes les heures), et souvent lorsque nous oublions de le configurer, nous découvrons des problèmes quelques heures seulement avant la sortie.

Besoin d'ajouter un peu à cela (et @GoodEnoughs):

mais cela ne ressemble qu'à une nuisance mineure pour le contrôle de version distribué.

Surtout non - ce que fait une build "serveur", c'est vous dire que votre tronc va construire et passer ses tests plus ou moins de clean (le moins c'est la quantité de configuration que vous devez faire de votre environnement).

J'envisage de passer au DVCS, mais même après l'avoir fait, vous tirerez mon intégration continue de mes mains froides et mortes.

Pour prendre un exemple simple - vous développez la fonctionnalité "a" il développe la fonctionnalité "b" distribuée ou non à un moment donné, vous devez tout assembler - si, lorsque vous vous engagez, vous oubliez d'ajouter un fichier que l'application va créer sur votre machine, mais il ne sera nulle part ailleurs. Ainsi, lorsque vous poussez la build vers votre "tronc", l'intégration continue se déclenchera et la build échouera et vous saurez et, espérons-le, avant que quiconque ne tire votre code pas si complet, vous pourrez prendre des mesures.

Si vous travaillez sur un projet avec plusieurs développeurs, vous devez être en mesure de définir d'où viennent les versions des versions - le tronc en vigueur - cela est vrai quelle que soit la façon dont votre contrôle de version fonctionne.

Si vous avez ajouté une fonctionnalité - en particulier une sur laquelle d'autres personnes ont une dépendance - pour être sûr que lorsqu'elle est poussée à "vivre" qu'elle construit et passe des tests ailleurs que dans votre environnement de développement, c'est énorme. Plus que cela, je déploie à partir des builds de mon serveur de build - son genre de façon dont on spécifie la build "définitive". En fin de compte, je vais avoir des builds de déploiement déclenchés par l'utilisateur. Son pas bon de dire que vous pouvez travailler autour d' elle - vous ne pouvez pas si vous en avez besoin (et j'ai brouillé les boîtes de dev rondes dans un bureau pour trouver et valider les fichiers manquants).

Est-ce que c'est un peu fort? Je ne sais pas - mais mon serveur de build est une de ces choses que je n'ai pas envie de rendre.

Je pense que les versions quotidiennes sont très importantes. Si vous avez une équipe répartie dans différents fuseaux horaires, il est préférable de trouver l'heure qui est à peu près la «fin de journée» pour la plupart de l'équipe. De plus, si les versions quotidiennes ont un composant de test automatisé, il est plus souhaitable.

À l'époque des systèmes de contrôle de source centralisés, je préconiserais des builds continus exécutés toutes les 5 à 10 minutes lorsque quelque chose est changé dans le code source. Puisqu'une erreur de compilation a le potentiel de ralentir la plupart de l'équipe. Pour les organisations exécutant des systèmes de contrôle de source distribués, une construction continue peut ne pas être autant nécessaire car les développeurs touchent directement la base de code «vierge» moins souvent.

Idéalement, à moins que vous ne construisiez quelque chose d'énorme qui prend plus d'une demi-journée à construire, vous construirez plus d'une fois par jour. Une fois que vous avez configuré un serveur d'intégration continue, comme Hudson ou TeamCity , les builds se produisent automatiquement, généralement toutes les heures ou à chaque validation, et vous serez averti en cas de problème.

C'est un bon moyen de détecter les erreurs tôt, surtout si vous exécutez également des tests automatisés dans le cadre de la génération. Il est particulièrement utile pour trouver des erreurs de configuration lorsque la build fonctionne sur la machine d'un développeur mais ne fonctionne pas ailleurs car quelque chose a été omis du référentiel ou de l'environnement.

Les serveurs d'intégration continue plus avancés vous permettent également de suivre les mesures au fil du temps (par exemple, pourcentage de couverture de code, temps de génération, lignes de code, etc.)

Les versions quotidiennes sont correctes. Vous en avez vraiment besoin si vous n'avez rien d'autre que pour être honnête, je pense que le test de Joel est un peu dépassé ces jours-ci.

À mon avis, vous devez construire en continu tout au long de la journée, exécuter vos cas de test de niveau unitaire, système et fonctionnel et idéalement empaqueter et déployer sur un environnement de type stade en même temps tout en vérifiant que tous les mécanismes de version de base de données et d'environnement que vous avez en place fonctionnent comme prévu.

Si les temps de construction ou de déploiement sont excessifs, envisagez d'éliminer certains de ces problèmes avec les disques RAM physiques ou logiciels, les connexions Internet plus rapides, la mise en parallèle des builds, etc. .

Les versions quotidiennes ne sont pas importantes. Les versions quotidiennes qui réussissent toujours sont (ou celles où elles ne sont interrompues que pendant une heure). Avoir CI lorsque la construction est interrompue dans 70% des cas n'est pas très utile, car si la chose est principalement cassée, cela ne vous aide pas à identifier une erreur.

Je pense qu'il devrait être construit, testé et déployé quotidiennement sur un serveur intermédiaire.

L'idée derrière la «construction quotidienne» est de toujours avoir quelque chose de prêt que les testeurs et les chefs de projet peuvent exécuter afin que tout le monde ait une idée de l'état réel du projet.

Dans le passé, avec les applications de bureau après la `` construction quotidienne '', un testeur ou un chef de projet pouvait immédiatement exécuter l'application, de sorte qu'aucune étape de déploiement ne devait être mentionnée.