Comment maintenir à jour vos bibliothèques tierces?

Disons que j'ai un projet qui dépend de 10 bibliothèques, et dans le coffre de mon projet, je suis libre d'utiliser toutes les versions de ces bibliothèques. Je commence donc par les versions les plus récentes. Ensuite, chacune de ces bibliothèques reçoit une mise à jour une fois par mois (en moyenne). Maintenant, pour garder ma malle complètement à jour, il faudrait mettre à jour une référence de bibliothèque tous les trois jours.

C'est évidemment trop. Même si la version 1.2.3 remplace généralement la version 1.2.2, vous ne savez jamais sans tester. Les tests unitaires ne suffisent pas; s'il s'agit d'un moteur de base de données / fichier, vous devez vous assurer qu'il fonctionne correctement avec les fichiers créés avec des versions plus anciennes, et peut-être vice versa. Si cela a quelque chose à voir avec l'interface graphique, vous devez tout inspecter visuellement. Etc.

Comment gérez-vous cela? Quelques approches possibles:

• Si ce n'est pas cassé, ne le réparez pas . Restez avec votre version actuelle de la bibliothèque tant que vous ne remarquez rien de mal lorsqu'elle est utilisée dans votre application, quelle que soit la fréquence à laquelle le fournisseur de la bibliothèque publie des mises à jour. De petits changements incrémentiels ne sont que du gaspillage.
• Mettez à jour fréquemment afin de limiter les modifications. Étant donné que vous devrez mettre à jour un jour dans tous les cas, il est préférable de le mettre à jour souvent afin que vous remarquiez les problèmes tôt lorsqu'ils sont faciles à résoudre, au lieu de sauter par-dessus plusieurs versions et de laisser les problèmes potentiels s'accumuler.
• Quelque chose entre les deux. Y a-t-il un sweet spot?

Je suis choqué - et même consterné - par le nombre de réponses ici disant "ne mettez pas à jour à moins que vous ne deviez". Je l'ai fait, et même si c'est plus facile à court terme, ça brûle comme un enfer à long terme. Les mises à jour plus fréquentes et plus petites sont beaucoup, beaucoup plus faciles à gérer que les grandes mises à jour occasionnelles, et vous bénéficiez plus tôt de nouvelles fonctionnalités, de corrections de bogues, etc.

Je n'achète pas cette idée que les changements de bibliothèque sont en quelque sorte plus difficiles à tester que les changements de code. C'est la même chose - vous modifiez la base de code, et vous devez la valider avant de vous engager, et plus profondément avant de publier. Mais vous devez déjà avoir des processus pour ce faire, puisque vous faites des changements de code!

Si vous travaillez dans des itérations, d'une durée de deux à quatre semaines, je suggère de faire de la mise à jour des bibliothèques une fois par tâche d'itération, à faire dès que possible après le début, lorsque les choses sont un peu plus détendues qu'avant une itération délai, et le projet a plus de capacité à absorber le changement. Demandez à quelqu'un (ou à une paire si vous faites de la programmation par paire) de s'asseoir, regardez quelles bibliothèques ont été mises à jour et essayez de les intégrer et d'exécuter une reconstruction et un test. Prévoyez une demi-journée à une journée pour chaque itération, peut-être. Si les choses fonctionnent, vérifiez les modifications (je suppose que vous gardez les bibliothèques sous contrôle de code source, comme nous le faisons; je ne sais pas comment vous propageriez le changement de manière contrôlée sinon). Ce sera évidemment beaucoup plus facile si vous avez des tests automatisés que si les tests sont entièrement manuels.

Maintenant, la question est de savoir ce que vous faites si une mise à jour casse des choses - passez-vous du temps à la réparer ou à la laisser de côté? Je suggère de pencher vers ce dernier; si elle peut être corrigée en une heure, faites-le, mais si une mise à jour nécessite un travail important à intégrer, alors augmentez-la comme sa propre tâche de développement, à estimer, prioriser et planifier comme n'importe quelle autre. Les chances sont qu'à moins que cela n'apporte une correction ou une amélioration très cruciale, la priorité sera faible et vous n'y arriverez jamais. Mais vous ne savez jamais, au moment où le prochain jour de mise à jour itérative se déroulera, le problème pourrait s'être résolu; même si ce n'est pas le cas, au moins vous savez maintenant qu'il y a un barrage routier sur le chemin de mise à jour, et il ne vous surprendra pas.

Si vous ne faites pas d'itérations de cette longueur, je mettrais en place une sorte de calendrier autonome pour les mises à jour - pas plus d'une fois par mois. Y a-t-il un autre rythme de projet auquel vous pourriez le lier, comme un examen mensuel de l'état d'avancement ou une réunion du conseil d'architecture? Payday? Soirée pizza? Pleine lune? Quoi qu'il en soit, vous devez trouver quelque chose de beaucoup plus court qu'un cycle de publication traditionnel, car essayer de tout mettre à jour en une fois tous les 6 à 18 mois va être douloureux et démoralisant.

Inutile de dire que si vous effectuez des branches de stabilisation avant les versions, vous ne leur appliquerez pas cette stratégie. Là, vous ne mettriez à jour les bibliothèques que pour obtenir des correctifs critiques.

J'évalue.

• Tout d'abord, je cherche les bogues que nous avons soulevés contre cette bibliothèque et je vois s'ils ont été corrigés.
• Deuxièmement, je recherche d'autres correctifs de bogues dans la bibliothèque dont nous pourrions bénéficier (peut-être quelque chose qui est un cas d'angle possible).
• Troisièmement, je recherche des améliorations dans la lib / API, puis j'étudie l'impact de la modification de notre code pour l'utiliser et le compromis bénéfique. J'ai trop souvent mis à jour les bibliothèques de mise à niveau sans vraiment utiliser leurs nouvelles fonctionnalités, idiot vraiment!

J'évalue ensuite tout cela contre le maintien de la bibliothèque existante.

Testez toujours - espérons que vos tests unitaires / d'intégration garantiront qu'aucune régression majeure ne se produira.

Le problème majeur avec les bibliothèques tierces, c'est que vous devez retester VOTRE application lorsque vous les mettez à jour, avant qu'elle ne puisse entrer en production. Donc, sauf si vous avez un bug signalé, qui nécessite la mise à jour d'une bibliothèque, vous ne les touchez pas avant d'avoir le temps de faire un cycle complet d'assurance qualité.

Cela se fait généralement lors de la publication d'une nouvelle version.

Je suggérerais cependant que vous ayez une suite de tests en place pour une construction continue qui vous permette de mettre à jour les bibliothèques dans la branche de développement et de le faire automatiquement. Cela garantira que vous découvrirez tôt quand il se casse, afin que vous puissiez déposer des rapports de bogues dans le projet.

En partie, comme décrit dans les branches des fournisseurs svn . La procédure décrite ici est très utile lorsque vous continuez à utiliser des bibliothèques tierces open source pendant longtemps et que vous avez apporté des modifications pour l'adapter à vos besoins.

Je penserais à mettre à jour toutes les bibliothèques d'un projet juste avant ou juste après une sortie. Cependant, cela pourrait devenir incontrôlable si vous comptez sur plus de 10 ou 15 bibliothèques, auquel cas une sorte de mécanisme de vérification des mises à jour serait très utile. L'avantage de ceci est que vous disposez d'un temps dédié au test de vos bibliothèques et que vous pouvez résoudre tous les problèmes en un seul passage. Vous n'avez pas non plus à constamment garder une trace des mises à jour de chaque bibliothèque, vous vérifiez simplement un certain jour pour les mises à jour.

J'irais également contre tout type de fonctionnalité de mise à jour automatique, même dans une branche de développement. Ce serait frustrant si, au milieu de moi, je travaillais sur quelque chose que le projet a cassé parce qu'une bibliothèque s'est mise à jour automatiquement, ou j'ai tout d'un coup reçu des avertissements d'amortissement pour l'utilisation d'une API qui vient d'être remplacée par autre chose.

Vous devez vous demander, que voulez-vous vraiment de la mise à jour? La plupart des correctifs de sécurité sont en fait des correctifs triviaux, sous la forme de correctifs:

• Off par une erreur où le code arbitraire peut être copié vers un espace inutilisé dans un tampon
• Pointeurs pendants, ou autre chose qui déclenche un comportement indéfini mais (plutôt) déterministe
• Bugs qui permettent une sorte de DoS
• Bogues qui facilitent accidentellement l'espionnage des données privées
• Bévues mathématiques
• Les mainteneurs touchant des choses qu'ils ne devraient pas (bogue SSL Debian, n'importe qui?)

Si vous examinez la plupart des CVE au cours des cinq dernières années, les correctifs qui les corrigent sont généralement assez triviaux, si vous utilisez des bibliothèques ouvertes, ce que j'espère que vous êtes.

Ensuite, vous avez des correctifs de bogues réels, que vous voulez probablement, mais peut-être que vous les avez déjà corrigés vous-même. S'il n'est pas cassé, ne le réparez pas.

Enfin, vous avez de nouvelles fonctionnalités .. et peut-être des fonctionnalités obsolètes. Vous devez examiner attentivement ces notes de version et ces différences. Pouvez-vous les utiliser, même s'ils cassent une API dont dépendent beaucoup d'autres choses? Si oui, il est temps pour la chirurgie .. sinon, choisissez ce que vous voulez et continuez.

Certains peuvent être en désaccord avec moi, mais je refuse d'utiliser une bibliothèque sans code source.

Cela varie en fonction de choses comme les bibliothèques, de leur utilisation, de leur omniprésence dans votre code, du coût (en termes de temps et d'argent) de la mise à niveau, etc.

Idéalement, vous auriez toujours la dernière version en tout temps, mais si la nouvelle version n'est pas rétrocompatible, alors quoi? Vous devrez peut-être suspendre cette mise à jour pour une prochaine version jusqu'à ce que vous puissiez gérer la modification avec soin. Il pourrait y avoir un changement subtil de comportement (tel que "vous devez maintenant définir la propriété X avant d'appeler la méthode Y, ou vous obtenez une fuite de mémoire lente") qui est difficile à vérifier lors des tests.

D'un autre côté, la nouvelle version pourrait avoir de sérieux correctifs de sécurité, vous devez donc en tenir compte également.

Version courte: à prendre au cas par cas.

Cela dépendrait de vos calendriers de sortie.

Mais mon conseil serait d'installer un ensemble de bibliothèques sur toutes les machines des développeurs. Considérez-le comme un standard si vous souhaitez l'appeler quelque chose, puis lancez le développement de cette version.

Ce n'est qu'une fois que la version a été déployée et que vous êtes dans la phase de post-publication, réévaluez vos bibliothèques, leurs versions et leurs fonctionnalités. S'ils offrent des améliorations importantes ou de nouvelles fonctionnalités, installez-les avant le début du prochain cycle de développement.

N'installez de nouvelles versions qu'en cas de problème majeur ou de bug qui doit être corrigé avant de déployer le logiciel.

Cela signifie que vous manquerez certaines versions, mais cela devrait vous éviter des maux de tête et des problèmes de version vous permettant de vous concentrer sur le développement de votre application.

Subversion Externals

Ce qui est génial dans cette fonctionnalité, c'est que vous pouvez spécifier la révision que vous souhaitez.

Veuillez noter que les mises à jour seront plus lentes si vous avez de nombreux externes.

J'installe actuellement quelque chose comme ça:

• 1 repo mercuriel pour chaque extension de mon application
• un dépôt mercurial qui rassemble des versions spécifiques de plusieurs bibliothèques tierces
• un dépôt SVN pour les ressources / travaux graphiques (mais peut changer pour autre chose)
• un dépôt mercurial pour mon application, qui utilise la fonction de sous-dépôt mercurial pour utiliser une version spécifique du dépôt 3ème parie, et certaines des extensions de base

Maintenant, lorsque j'ai besoin de travailler sur une extension qui n'est pas "de base" (implicitement incluse en tant que sous-référentiel dans le référentiel d'application), je me contente de cloner le référentiel dans le dossier d'extensions et de laisser CMake générer les projets et les solutions pour l'ensemble de l'application.

De cette façon, je peux:

• changez les tiers dans un clone, vérifiez que cela fonctionne avec l'application, poussez-le dans le référentiel de 3e partie, puis mettez à jour la version subrepo du référentiel d'application vers la nouvelle version de référentiel tiers
• travailler sur des extensions indépendamment, tous ensemble ou simplement choisir des
• ne pas avoir à se soucier d'avoir à lier des projets entre eux, cela se fait par Cmake juste en faisant scanner les sous-projets avec l'ensemble du dépôt d'application.

Je n'ai pas encore beaucoup d'expérience avec cette organisation, mais je pense que c'est assez utile.

Si votre logiciel est critique pour la sécurité, vous devez le mettre à jour dès que possible, sans excuses. Vous ne voulez pas qu'un petit bogue dans une bibliothèque graphique rende votre programme vulnérable.

Sinon, quand la bibliothèque est mature, c'est "Si ce n'est pas cassé, ne le répare pas." pour moi. Tôt ou tard, j'ai peut-être besoin d'une fonctionnalité d'une version ultérieure et je n'ai pas d'autre choix que de mettre à jour, mais jusque-là, l'effort est difficile à justifier. D'un autre côté, lorsque je travaille avec une bibliothèque ou un framework relativement nouveau, comme Grails ou ExtJS, je reste à jour avec la dernière version car ces produits ne semblent pas encore complètement matures, donc la mise à jour est susceptible de me sauver de courir dans l'un de ces bogues, la dernière version a été corrigée.

J'utilise NuGet pour maintenir à jour mes bibliothèques tierces.

Lorsqu'un ami, un collègue ou un blog m'informe qu'une de mes DLL tierces est obsolète, NuGet facilite la mise à jour.