Code de vérification future

Là où je travaille, les développeurs me disent toujours "j'ai ajouté ceci au cas où ce serait pour l'avenir" ou "je pense que c'est une bonne idée de le faire car ils le voudront probablement un jour". Je trouve ça génial qu'ils soient proactifs en essayant d'anticiper les changements futurs, mais je ne peux m'empêcher de penser que c'est inutile et risque d'écrire du code qui pourrait ne jamais être nécessaire et qui serait donc improductif (je pense aussi que certains développeurs veulent juste essayer quelque chose nouveau pour le plaisir). Les arguments en faveur de la vérification future sont-ils invalides si vous écrivez simplement un code organisé correct et propre?

Tout d’abord, il y a des choses qui nécessitent des éclaircissements:

• La vérification future n’ajoute rien .
• La future vérification consiste à s'assurer que vous pouvez facilement ajouter du code / des fonctionnalités sans casser les fonctionnalités existantes.

Cela signifie qu'écrire du code "à l'épreuve du temps", c'est s'assurer que le code est écrit de manière couplée, suffisamment abstraite, mais aussi du code qui ne masque pas complètement les niveaux d'abstraction. Il y a donc toujours moyen de passer aux niveaux d'abstraction inférieurs. si nécessaire.

Écrire du code à l'épreuve du temps est un art en soi et est étroitement associé aux pratiques SOLID en matière de gestion des versions de composants, de séparation des problèmes, de superposition et d'abstraction des fonctionnalités. La vérification future n’a rien à voir avec l’ajout de fonctionnalités à l’avance, mais bien avec la possibilité de pouvoir ajouter des fonctionnalités à l’avenir sans rupture , grâce à la bonne conception du code / des bibliothèques existants.

Mon 2c

N'écrivez pas de code qui ne sera pas utilisé pendant longtemps. Ce sera inutile, car il est fort probable qu'il ne répondra pas aux besoins de cette époque (que vous ne savez pas encore, par définition).

Rendez le code robuste face aux problèmes inattendus permettant une récupération en douceur ou une défaillance rapide, mais n'écrivez pas de code pour de futures utilisations.

Un bon moyen de s’assurer de cela consiste à utiliser une conception et un développement pilotés par des tests. Les cas de test sont dérivés de la spécification et des cas d'utilisation. Tout le code doit réussir un test. Le code inutile ne doit pas être écrit. En procédant ainsi, il est simple de déterminer si cela est nécessaire ou non.

Il est important de réaliser que rendre le code évolutif et l'écrire au cas où il en aurait besoin à l'avenir sont deux choses très différentes. Le premier est crucial pour une bonne application, le moins important n’est généralement pas une bonne pratique de codage.

• Pour moi, mettre le code à l'épreuve pour l'avenir, c'est l'écrire de manière à pouvoir interagir avec les technologies en évolution. Cela implique la modularisation de votre code, afin que chaque partie de votre application puisse interagir indépendamment du langage et de la technologie de l'application dans son ensemble. Un bon exemple de ceci serait d'utiliser XML ou JSON pour transmettre des données entre différentes parties de l'application. Quelle que soit l'évolution de la technologie, il est très probable qu'il sera toujours capable de lire XML et JSON.

• Semblable à ce qui précède, exposer une partie de votre application via une API SOAP ou REST permet d'obtenir un résultat similaire. Quelles que soient les technologies, il ne sera pas nécessaire de réécrire chaque partie de l’application, car les nouvelles technologies pourront toujours communiquer avec les anciennes.

• En ce qui concerne l’ écriture de code au cas où cela serait nécessaire , j’estime que c’est très dangereux, car le code ne comportera probablement que peu ou pas d’essais.

Donc, bien sûr, assurez la pérennité du code (la NASA envoie toujours des vaisseaux spatiaux avec Fortran), mais n’écrivez pas de code «au cas où».

Pensez au nombre de fois que vous avez activé un morceau de code dans un environnement de production en pensant: "Dieu merci, j’ai écrit cela il ya 2 ans!".

Le code doit être modifiable / extensible facilement. N'ajoutez pas de code qui n'est pas immédiatement nécessaire, car cela confère un très faux sentiment de sécurité et gaspille les ressources de développement et de test dans un monde où les exigences changent.

Beaucoup d'autres réponses traitent de problèmes de conception plus vastes ou sont plutôt abstraites. Si vous envisagez l'avenir, vous pouvez définir des techniques claires pour aider à protéger le code à l' avenir .

Pensez principalement qu'à l'avenir quelqu'un essaiera d'ajouter une fonctionnalité au code ou tentera de le réutiliser ailleurs. Ils peuvent également essayer de corriger une fonctionnalité dans le code. Bien sûr, un bon code propre est un point de départ requis, mais certaines techniques spécifiques peuvent également être appliquées.

Programmation défensive : vérifiez les entrées au-delà de ce dont votre application actuelle a réellement besoin. Chaque fois que vous appelez des API, assurez-vous que leur entrée correspond à ce que vous attendez. À l'avenir, les utilisateurs mélangeront ensemble de nouvelles versions de code, de sorte que l'étendue des erreurs et les retours d'API changeront par rapport à ce qu'ils sont maintenant.

Supprimer le comportement non défini : De nombreux codes ont un comportement qui évolue à partir de rien. Certaines combinaisons d’entrées conduisent à certaines sorties que personne ne voulait vraiment, mais c’est ce qui se passe. Maintenant, inévitablement, quelqu'un se basera sur ce comportement, mais personne ne le saura car ce n'est pas défini. Quiconque tente de changer le comportement à l'avenir cassera les choses par inadvertance. Utilisez les contrôles de sécurité maintenant et essayez de supprimer / bloquer toutes les utilisations non définies du code.

Suite de tests automatisés : Je suis sûr que vous pouvez trouver des volumes sur le besoin de tests unitaires. En ce qui concerne la vérification future, il est toutefois essentiel de permettre à quelqu'un de refactoriser le code. La refactorisation est essentielle au maintien de la pureté du code, mais si vous ne disposez pas d'une bonne suite de tests, vous ne pouvez pas la refactoriser en toute sécurité.

Isolement et séparation : L'encapsulation et une modularisation appropriée constituent un bon principe de conception, mais vous devez aller au-delà. Vous constaterez souvent que vous devez utiliser une bibliothèque, une API ou un produit, qui peut avoir un avenir incertain. Peut-être en raison de problèmes de qualité, de problèmes de licence ou du développement continu des auteurs. Dans ces cas, prenez plus de temps pour mettre une couche entre vous et ce code. Découpez l'API selon vos besoins afin que le couplage soit très faible pour permettre un remplacement plus facile à l'avenir.

Un code bon, propre et bien organisé est à l'épreuve du temps en ce sens qu'il facilite les modifications et les ajouts à mettre en œuvre correctement.

Le terme "preuve future" signifie au mieux une "conception à couplage lâche". 80% du temps, les gens veulent dire "flexible" quand ils disent "à l'épreuve du temps". Parfois, ils le disent pour essayer de paraître cool. Mais au moins, ils fournissent quelque chose qui fonctionne à l'heure.

La "preuve future" au pire n'a pas de sens. 20% du temps, c'est une excuse pour perdre du temps à rechercher des technologies alternatives au lieu de simplement fournir quelque chose. Ils ne livrent rien (ou ce qu'ils livrent est trop complexe pour le problème à résoudre.)

Il y a deux cas extrêmes.

1. Une prévoyance sans faille. On peut réellement prédire l'avenir avec précision. Dans ce cas, appliquez cette puissante prévoyance à la vérification future du code. Mieux, appliquez la prévoyance sans faille pour prévoir les tendances du marché, prenez votre retraite tôt et arrêtez de coder.

2. On est "conduire" l'avenir. C'est-à-dire qu'une nouvelle technologie prête à être déployée à l'avenir nécessitera une réécriture de la chose livrée maintenant. C'est bizarre qu'on ne déploie pas d'abord ce truc futur cool.

   Nous devons livrer le projet "A", sachant que le projet "B" entraînera une réécriture immédiate de "A". Dans ce cas seulement, nous pourrions être en mesure de prouver à l'avenir "A".

YAGNI = Vous n'en aurez pas besoin .

Vos instincts sont corrects: leur code est superflu, ajoute un fardeau de maintenance et de test, et fait perdre du temps à des tâches qui n’ont pas de valeur commerciale concrète.

Voir aussi: Gold Plating .

Ignorer le titre de la question et rester concentré sur le fait de "mettre des choses parce que quelqu'un pourrait en vouloir un jour" ...

La réponse est non. Jamais. N'écrivez pas un point de code dont vous n'avez pas besoin aujourd'hui. Voici pourquoi:

1. Le programme est maintenant plus compliqué que nécessaire.
2. Vous n’avez peut-être jamais besoin de cette fonctionnalité, vous avez donc perdu votre temps.
3. Vous ne savez pas quelles seront les exigences de la fonctionnalité si quelqu'un le demande à l'avenir. Vous devrez donc le comprendre et le modifier quand même.

Je pense que le premier point est le plus important. Si vous avez déjà travaillé avec un système bourré de code générique pour différents clients ou plein de fonctionnalités avec des éléments inutiles, vous savez combien de temps et d’efforts supplémentaires sont nécessaires pour maintenir ou étendre les fonctionnalités, grâce à: cette. Alors évitez à tout prix.