VB.NET : code "propre" et code "propre et optimal"

Bonjour à tous,

Je viens de passer une semaine compliquée et passionnante à lire « Coder Proprement » de Robert C. Martin :D

J'ai publié mon post ici car les questions que je pose ensuite concernent VB.NET et je n'ai pas voulu déterrer le topic https://www.developpez.net/forums/d7...bert-c-martin/

La version française est épuisée, mais j’ai pu trouver la version PDF grâce à ce forum. Dès les premières pages il m’a semblé indispensable de l’imprimer pour continuer la lecture sur papier et ainsi pouvoir écrire des annotations, surligner des passages, ect…

J’ai vraiment appris la programmation en école d’ingénieur généraliste, de 1998 à 2003. Ce livre a confirmé le fait que ma formation initiale est à la fois datée et incomplète :aie: Ce livre m’a permis d’avoir un bon aperçu de tout ce qui a évolué depuis. L’auteur a eu la riche idée d’inclure pas mal de liens wikipédia et autres. En fait lors de chaque chapitre j’ai pu basculer sur le net pour trouver plus d’infos et quelques exemples sur les notions développées dans le livre. On en apprend tous les jours c'est une bonne chose :D

Il y a juste une chose qui m'a semblé surprenante : le livre n’évoque pas une fois la règle « ne jamais stocker deux fois la même information ». Il parle beaucoup de la redondance du code, mais jamais explicitement de la redondance des données :? , alors que c’est pour moi une source de problèmes importante... Plusieurs des logiciels que j'ai développé avait pour source de bugs une donnée devenue redondante suite à des évolutions.

J’ai développé quelques projets de taille relativement importante et... il y a du boulot pour que mon code devienne propre :mouarf: :aie:

Mon projet le plus ancien, fait sous VB5, qui a été commencé à 1997 et que je maintiens toujours (une nouvelle version est en préparation), peut profiter de certaines règles mais VB5 est trop ancien :aie: pour pas mal de choses comme le polymorphisme.

J’ai un autre projet, pas très gros, qui tourne avec VB.NET, dans lequel je pourrais appliquer la plupart des règles du livre. Cela me fera un bon exercice.

Mais je me demande en pratique quels outils utiliser avec VB.NET pour les choses suivantes :
- Comment suivre les évolutions du code (journalisation) pour éviter de le faire avec les commentaires ?
- Comment ne pas être limité dans l’usage du polymorphisme avec Option Strict ?
- Comment mettre en œuvre les tests unitaires ?
- Comment mette en œuvre la programmation orienté Aspect ?
- Comment organiser mes classes et modules en groupes, car « Coder proprement » implique d’avoir de nombreuses petites classes et petits modules ?

Ces questions ne sont que des questions pratiques et je ne pense pas que je resterais bloqué. (Sauf si certaines fonctionnalités ne sont pas possibles avec les versions Express ou Community de VB.NET, m’obligeant à passer à la version pro).

Quel est votre avis sur la question ?

Avez-vous déjà mis en pratique les principes de « Coder Proprement » avec VB.NET ?

Par contre, et c’est là que le bât blesse, j’ai un autre gros projet sous VB.NET où je ne vois pas du tout comment rendre le code propre, pour des raisons conceptuelles… Ce projet est un logiciel type « CAO/FAO » avec de nombreuses étapes de calculs pour arriver des données de départ au résultat final. Ces calculs sont très lourds et sujets à l’instabilité numérique.

J’ai dû optimiser les différentes étapes de mon programme de façon poussée car sinon le logiciel serait très lent :
- Optimisation des algorithmes
- Pré-calculs
- Pré-selection des données (comme le « clipping » en 3D)
- Optimisation de l’implantation (code « in-line »)

Le problème est qu’une bonne partie des règles d’optimisation que j’ai utilisée sont en contradiction avec les règles de « Coder Proprement »

« Coder Proprement » impose de subdiviser le code dans de multiples classes et fonctions :
- Faire des fonctions et des classes courtes
- Faire des fonctions qui font « une chose »
- Respecter le SRP
- Séparer commandes et demandes
- Faire des fonctions et des classes qui correspondent à un niveau d’abstraction
- Avoir recours au polymorphisme plutôt qu’utiliser des switchs
- Multiplier les fonctions plutôt que d’avoir des arguments sélecteurs
- Avoir recours à la programmation orientée aspect pour les fonctionnalités transversales
- Envelopper les appels aux API externes

Or pour optimiser un code une des règles est d’avoir, pour chaque procédure de calcul longue, un code « inline ». Plus spécifiquement, dans les fonctions critiques il faut compter les « cycles d'horloge » et chaque appel de fonction, chaque appel de propriété, chaque liaison tardive, chaque conversion de donnée est le genre de truc à éliminer sans scrupule.

Concrètement dans mon programme j’ai du « casser » la structure de données pour regrouper chaque gros calcul dans une seule procédure.
Plus sournoisement, pour éviter de calculer « deux fois », il m'a fallu regrouper des tâches ; par exemple si un test implique de faire un certain nombre de calculs, puis que l'étape suivante effectue ces mêmes calculs, pour ne pas gaspiller de temps CPU j'inclus le test dans l'étape suivante comme cela les résultats des calculs nécessaires aux tests sont réutilisés au lieu d'êtres refaits.

« Coder Proprement » ne parle pas du tout de l’optimisation.

Tout le monde dit qu’il « ne faut optimiser qu’à la fin » mais mon programme comporte plusieurs étapes avec chacune des calculs lourds. Avant de passer à l’étape suivante, j’ai d’abord du optimiser l’étape précédente, sinon les tests auraient pris des heures…

Impossible de faire et de conserver une version « normale » et une version « optimisée », où la version « optimisée » serait faite simplement à partir de la version « normale et propre », car dans mon application l’optimisation est cruciale et complexe. Ce n’est pas une petite optim pour gagner 30% de vitesse ; entre la version « naïve » de mon code de calcul et la version « optimisée de tous les points de vue » il y a un facteur 10 à 100 !

Bref, comment faire pour avoir du code « propre ET optimal » ?
Je sais que ce sera du propre « dégradé », ou « à l’ancienne » mais on doit pouvoir définir des règles.

J’avais déjà commencé à :
- mettre en place un nommage précis et organisé
- tenir un dossier d’analyse précis
- créer pas mal de jeux de tests représentant tous les cas particuliers imaginables
ainsi même si j’ai de grosses classes et des fonctions longues cette doc me permet d’avoir un code qui ne soit pas un foutoir incompréhensible mais j’aurais aimé aller plus loin.

« Coder Proprement » part de la méthode des 5S qui est universelle, mais ensuite se base sur des techniques de programmation très précises à utiliser de façon stricte (polymorphisme, structures de données, programmation orienté objet, programmation orienté aspect). Or je pense qu’il est possible de s’organiser même si l’on ne peut utiliser certaines techniques. Par exemple avec les vieux langages comme VB5, de bons programmeurs pouvaient certainement respecter une organisation sérieuse et avoir un « code propre ».

Que me conseillez-vous ?

A bientôt