Combien de temps dure le code?

Je suis en train de revenir sur certains des TODO les plus mineurs de mon code. L’un d’entre eux est dans une classe qui gère les dates partielles, par exemple janvier 2001. Cela fonctionne bien pour les dates qui seront vues dans notre système (1990 – 2099) et échouera avec grâce pour d’autres dates.

Le TODO que je me suis laissé est que je ne gère pas les dates du siècle 2100 et au-delà. Je ne pense pas vraiment que cela vaut la peine de résoudre ce problème particulier, mais je suis au courant des bogues de Y2k. Si nous étions en 2080 déjà je pense que je penserais différemment et corrigerais le bug.

Alors combien de temps dure le code? Dans quelle mesure devons-nous prévoir que nos systèmes continuent à fonctionner?

Mettre à jour

Ok, merci pour toutes vos consortingbutions. Je pense que je vais pour l’option de laisser le TODO dans le code et ne rien faire. Les pensées que j’ai trouvées les plus intéressantes étaient:

  • @Adrian – Eternity, je pense que c’est l’hypothèse la plus correcte, votre sharepoint vue sur les VM est bon.
  • @ jan-hancic – Ça dépend, oui c’est le cas.
  • @ chris-ballance – Je suppose que je serai mort au moment où cette ressortingction sera atteinte, afin qu’ils puissent venir me souiller s’ils le veulent, mais je serai mort, alors je vais juste hanter son cul.

La raison pour laquelle j’ai décidé de ne rien faire était simple. Cela a ajouté une valeur commerciale négligeable, les autres choses à examiner ont ajouté de la valeur, alors je les ferai d’abord et si j’obtiens le temps je le réparerai, mais ce ne sera rien de plus qu’un exercice académique.

Plus long que prévu.

Éternité.

Étant donné que l’ancien système continue à fonctionner sur les machines virtuelles, nous devons supposer que tout code utile fonctionnera pour toujours. Il y a beaucoup de systèmes qui fonctionnent depuis les années 60, par exemple le code backend dans le secteur financier, et rien ne semble indiquer que ces systèmes seront jamais remplacés. (Et entre-temps, le frontend est remplacé tous les deux ans avec la dernière mode de la technologie Web. Donc, plus votre code est proche du cœur de votre système, plus il est probable qu’il fonctionnera pour toujours.)

Vous ne pouvez pas avoir de réponse générale ici. Cela dépend du type de projet que vous construisez. Si vous écrivez un logiciel pour une sonde spatiale, vous voudrez peut-être le coder pour qu’il fonctionne pendant les 100 prochaines années et plus. Mais si vous programmez une offre spéciale de Noël pour la page Web de votre entreprise, quelques semaines devraient suffire …

Supposons que quiconque maintiendra le code soit un psychopathe et a votre domicile .

Personne ne le sait vraiment. La programmation professionnelle existe depuis 30 à 40 ans, donc personne ne sait vraiment si le code durera 100 ans. Mais si le bogue de l’an 2000 est une indication, c’est que beaucoup de code va restr pendant plus longtemps que prévu par le programmeur. Gardez à l’esprit que même si vous en tenez compte, cela pourrait restr plus longtemps que prévu. Peu importe combien vous vous préparez, il pourrait encore survivre à l’espérance de vie prévue.

Mon conseil est de ne pas prévoir de code pour 100 ans. Essayez plutôt de vous assurer que tout votre code fonctionnera pendant le même laps de temps, c’est-à-dire qu’une partie de celui-ci ne devrait pas échouer dans deux ans, tandis que l’autre partie devrait échouer dans 100 ans. Rappelez-vous que vous devez toujours corriger le lien le plus faible en premier, il est donc inutile de renforcer le lien le plus fort.

Parfois, le code dure plus longtemps que vous ne le pensez. Mais, plus important est l’ argument de la pente glissante . Une fois que vous vous pardonnez un peu de résistance aux balles, vous pouvez être tenté d’optimiser davantage et de limiter l’exactitude logique, jusqu’à ce qu’il vous morde finalement.

Par ailleurs, je recommande d’avoir un ID de problème (tel que le numéro de dossier FogBugz) dans chaque commentaire TODO, afin que les utilisateurs puissent s’inscrire et suivre ce TODO.

dans les mots immortels de Dan Bernstein: ne consortingbuez pas au problème Y10K!

Je ne pense pas que le code durera aussi longtemps. Pensez à toutes les inventions et à tous les progrès réalisés au cours des 90 dernières années.

En 2100, nous n’aurons pas à écrire de code. Il y aura une sorte d’interface cerveau-machine.

Eh bien, nous avons récemment créé un format d’horodatage dans lequel l’heure est stockée dans un entier non signé de 64 bits sous forme de microsecondes à partir de 1970. Elle durera jusqu’à l’année 586912, ce qui devrait être suffisant.

Coder pour “pour toujours” est inutile – bien sûr, vous pouvez utiliser BigIntegers et autres, mais pourquoi? Juste être préparé pour plus de 5 ou 10 ans. Le code de production vieux de vingt ans n’est pas tout à fait inhabituel de nos jours, et je pense que le cycle de vie moyen sera encore plus long dans un avenir proche.

Cela dépend de la valeur commerciale du code et des ressources nécessaires pour l’écrire à partir de zéro. Plus la valeur et les ressources sont importantes, plus cela dure longtemps. Dix ans et plus est typique pour le code commercial “travaux, ne touchez pas”.

J’ai toujours essayé de coder comme mes applications doivent fonctionner “pour toujours”. Je suis sûr que je ne serai plus là en 2100, mais savoir que la date d’expiration de mon logiciel ne me permet pas de me sentir bien. Si vous connaissez de telles choses, essayez de les éviter! Vous ne saurez jamais, mais certains programmeurs inconnus dans le futur peuvent être reconnaissants.

Jusqu’au moment où il se brise ou cesse de servir, puis un peu plus longtemps après

Les choses essentielles sont:

  1. Quelle est la qualité de votre classe de date interne (obtenez une version de bibliothèque très robuste et respectez-la!)

  2. Ce n’est pas seulement le passage du temps, mais aussi la croissance de la gamme d’intrants que veulent vos utilisateurs. Par exemple, peut-être avez-vous maintenant un emprunt hypothécaire de 30 ans, mais le mois prochain, quelqu’un décidera d’introduire un bail de 99 ans avec une échéance de 2110, ou un emprunt Disney de 100 ans!

Si vous acceptez les entrées d’année à deux chiffres avec un guichet de date, réfléchissez bien à la manière dont cela s’applique aux dates de début et de fin, et donnez beaucoup de commentaires immédiats.

Voici mes deux cents:

Lorsque nous concevons un projet, nous le déclarons généralement “au moins” 5 ans. Généralement pas plus de 10 ans avant que nous le re-concevions et construisions tout. (Nous parlons ici de projets de taille moyenne à grande).

Ce qui se produit habituellement, c’est que le nouveau projet que vous construisez est censé remplacer l’ancien, que ce soit du sharepoint vue de la technologie (passer de MF à Windows, VB à .net, etc.), mais ce projet ne se termine jamais. Ainsi, votre client finit par travailler avec 2 systèmes à la fois et ce système est appelé “inheritance”.

Si vous attendez assez longtemps, un troisième projet augmentera, ce qui amènera le client à travailler avec 3 systèmes à la fois, etc.

Mais pour répondre à votre question, je parierais 5 à 10 ans avant la refonte, et à moins que vos dates ne soient censées être longues dans l’avenir – pas besoin de s’inquiéter de la limitation du 2100.

IMHO cela se résume à l’artisanat: la fierté que nous prenons dans notre travail, le codage à un standard, nous n’aurions pas honte d’un autre vrai codeur à voir.

Dans le cas de dates comme celle-ci, vous avez déclaré que cela gracefully fails après 2100. Cela semble vous permettre de supprimer TODO sans mauvaise conscience, car vous avez intégré une réponse qui permettra de diagnostiquer facilement la cause de l’échec. et fixé dans la circonstance (cependant probable ou improbable) qu’une défaillance se produit.

Il existe des exemples de code fonctionnant sur des machines plus anciennes datant de 40 ou 50 ans.

(Bits intéressants dans ce sujet: http://developers.slashdot.org/developers/08/05/11/1759213.shtml ).

Vous devez vous interroger sur la nature du problème que vous résolvez, mais en général, même les «solutions rapides» seront disponibles pendant des années, de sorte que vous pourriez raisonnablement penser à une décennie ou plus de code destiné à une durée de vie décente. .

Les autres points à prendre en compte sont:

1) Quelle est la “vie active” de l’application – c’est là qu’elle va être utilisée et traitée.

2) Quelle est la “durée de vie inactive” de l’application – c’est-à-dire qu’elle ne sera pas utilisée au jour le jour mais pourrait être utilisée pour récupérer et visualiser les anciens enregistrements. Par exemple, le droit de la vérification au Royaume-Uni signifie que les enregistrements doivent être disponibles pendant 7 ans, ce qui représente un risque de 7 ans à compter de la dernière utilisation du système.

3) Quelle est la gamme de données futures à gérer? Par exemple, dites que vous prenez les dates d’expiration des cartes de crédit – vous pouvez avoir une carte qui n’expire pas avant dix ans. Pouvez-vous gérer cette date?

Les réponses à ces questions vous amèneront généralement à supposer que vous ne devez jamais écrire sciemment un code comportant des contraintes de date autres que celles du système d’exploitation ou du langage utilisé.

La question n’est pas “combien de temps dure le code?” mais plutôt “Combien de temps les choses dans mon code affecteront-elles une application?”

Même si votre code est remplacé, il est possible qu’il soit remplacé par du code qui fait exactement la même chose. Dans une certaine mesure, c’est la cause directe du problème de l’an 2000. Plus précisément , c’est la cause directe du problème de Y2038 .

Gardez également à l’esprit ce que vous entendez par dernier.

Par exemple, l’exploitation UNIX d’origine a été développée il y a 30 ans. Mais pendant ces 30 années, le produit a évolué avec le temps.

Cependant, cela ne me surprendrait pas si un peu de code original existe encore.

Alors pensez-y 2 façons … 1) avez-vous déjà antisipidé le code touché à l’avenir, 2) le produit / code évoluera si vous avez le soutien et l’implication.

Mon magasin actuel possède une base de code importante qui exécute des applications financières avec des règles métier complexes. Certaines de ces règles sont codées dans des procédures stockées, certaines dans des déclencheurs et d’autres dans le code d’application 3gl et 4gl. Il y a du code courant de la fin des années 90, et rien de tout cela dans vos langages “traditionnels” tels que COBOL ou FORTRAN. Comme on peut l’imaginer, c’est un tas de code spaghetti fumant, dont la plupart ont été créés avant que le TDD ne signifie quelque chose, donc les gens sont réticents à toucher n’importe quoi.

J’ai eu l’occasion de m’engager plus de dix ans plus tard dans le contrat pour consulter le code de portage sur une nouvelle plate-forme (OS / 2 n’est pas très populaire de nos jours!). En cas de doute, supposez que votre code vivra plus longtemps que vous ne le feriez. À tout le moins, documentez le diable à partir de limitations comme celle-ci; réparez-les à moins que cela ne demande beaucoup plus de travail que de les documenter.

En 1995, j’ai commencé à travailler sur un nouvel emploi, sur une base de code de 8 ans. Donc, la date d’entrée en vigueur était 1987 ou à peu près.

Le code est probablement encore en service . C’est ce que ? 23 années.
Il y a eu quelques mouvements de l’entreprise, mais ils ont probablement conservé le logiciel (parce que ça fonctionne). S’il est toujours en service, il sera encore en service dans une dizaine d’années.

Ce n’est pas surprenant, en particulier le code de haute technologie, en C (surtout)

En 1999, j’ai commencé un nouveau travail, le code avait des antécédents depuis 1984. La nouvelle version que j’ai conçue dans les années 2000 est toujours en service, avec des éléments de conception comme les fichiers de données précédents (et ainsi de suite). serait un programme de développement sur 26 ans.

Le problème de l’année 2086 commence donc à se dessiner un peu à mesure que les 32 bits signés time_t se terminent.

Rappelez-vous que l’un des principaux avantages de la programmation moderne est la réutilisation.

Cela signifie que le code que vous écrivez à l’origine pour résoudre un problème peut être réorienté et utilisé dans un scénario complètement différent des années plus tard (peut-être même à votre insu, par un coéquipier).

En guise de remarque: l’un des principaux avantages des tests unitaires automatisés est le test de code dont vous ne vous souvenez même pas qu’il existe dans un système! 🙂

Tant que les gens peuvent continuer à facturer leur soutien aux personnes prêtes à payer.

3-5 ans max. Après cela, vous êtes passé à un autre travail et avez laissé votre code de merde derrière.