Quel est le terme pour un code vraiment gros comme un code source?
Parfois, lorsque nous vérifions l'historique de validation d'un logiciel, nous pouvons voir qu'il y a quelques commits qui sont vraiment gros - ils peuvent modifier 10 ou 20 fichiers avec des centaines de lignes de code source modifiées (Delta). Je me souviens qu'il existe une durée couramment utilisée pour un tel grand comité, mais je ne peux pas me rappeler exactement ce que ce terme est. Quelqu'un peut-il m'aider? Quel est le terme que les programmeurs utilisent habituellement pour se référer à une telle commission importante et géante?
BTW, vous engageons beaucoup de changements ensemble une bonne pratique?
MISE À JOUR: Merci gars pour la discussion inspirante! Mais je pense que "la bombe de code" est le terme que je recherche.
(1) Ben Collins-Sussman : "..." Code Bombs ". C'est ce que tu fais quand Quelqu'un apparaît dans un projet open source avec une nouvelle fonctionnalité gigantesque qui a pris des mois à écrire? Qui a le temps de passer en revue des milliers de lignes de code? ... "
(2) Dan Fabulich : "La bombe du code, ou: le débutant avec de grandes idées ... A Code bombe est un patch qui est si grand que personne ne peut l'examiner. "
(3) - Google Summer of Code: Lignes directrices : "Engagez-vous tôt, commettez souvent ... S'il vous plaît ne pas travailler toute la journée, puis tout pousser dans un seul Code bombe . Au lieu de cela, chaque commit doit être autonome sur une tâche uniquement qui devrait être résumée dans le message de journal. "
(4) Jeff Atwood : "Code-bombes ... Règle n ° 30: ne va sombre .. .
BTW, vous engageons beaucoup de changements ensemble une bonne pratique?
Eh bien, ce n'est pas une bonne pratique de conserver des changements pendant une longue période et de mettre en œuvre une variété de fonctionnalités et de corrections de bugs, puis de les engager, ce qui est un moyen d'être un grand commit.
Une autre façon que cela pourrait arriver est que le refactoring modifie la signature d'une fonction largement utilisée, puis tous ceux qui doivent être changés. Ce n'est pas nécessairement mauvais, et je ne voudrais pas que les développeurs s'abstiennent de nettoyer le code de peur de traverser un seuil.
Donc, il y en a plus que de regarder le nombre de fichiers touchés par commis.
Le terme que j'ai entendu est "chunky check-in". Et je ne suis pas un fan d'eux. J'aime les petits commits qui ne garantissent rien d'autre n'est cassé à une étape raisonnable dans un projet. Le grand commit est généralement semé de problèmes qui résonnent pendant un certain temps sur le moment où cela se produit.
Je l'appelle -"typique svn commit" ou "demain est la date de libération de la sortie"
Autant que j'aime Svn, je suis juste éteint par le fait que je ne peux pas faire des engagements locaux.
EDIT: Ils ont généralement les mots "trucs" et "bière" dans le message de validation.
Éditez à nouveau: commettant beaucoup de changements, mais pas nécessairement une mauvaise pratique, devrait être autant que possible évitée. Je trouve plus facile d'examiner une révision/une commission qui est courte et concise. (associé à un message de validation bien écrit, voir mon édition précédente pour un mauvais exemple)
Un "gros morceau de code à la vapeur chaude". :-)
- COMMIS initiale - le projet qui n'était pas sous contrôle de révision jeté dans SVN
- Refactoring - L'architecte a une idée brillante sur la modification des noms de classe de/à Convention de nommage de Schtroumpf ou modifié la racine de la hiérarchie des packages
- Format de code - L'architecte a décidé de modifier le tiret de code de 4 à 3 espaces ou de modifier les fins de la ligne d'UNIX à Windows (ou revenir)
- Vendredi commit - Joe fait toujours partie de sa semaine de travail les vendredis à 16h30
- UUUPS COMMIT - TED a par erreur le répertoire racine supprimé, a commité cela, et il pompette à nouveau la hiérarchie de fichiers entière dans SVN
Habituellement, de nombreuses personnes ont tendance à prendre beaucoup de commettre à l'utilisation de VC centralisées, en particulier le serveur appliquer une bonne politique de validation. C'est-à-dire que le COMMIS doit passer tous les tests et les tests prennent plus de temps (plus de quelques secondes). Les développeurs ne veulent donc pas attendre si longtemps pour commettre plusieurs fois et décomposer les changements dans plusieurs petits commits.
Et les développeurs qui sont verts à VCS peuvent oublier de décomposer les changements en plusieurs petits engagements. Ils ne se souviennent que de s'engager quand ils libèrent le programme en équipe QA. Pire encore, pour éviter les autres de voir du code de buggy, ils ne s'engagent pas avant de réussir les tests d'assurance qualité. Enfin, ils n'ont pas réalisé qu'ils avaient des fichiers binaires de sortie engagés, des fichiers temporaires et une production de liker, qui produisent réellement "gros" commettre.