Ah ! L’IUT ! Petit moment de nostalgie. Je me remémore mon arrivée dans ce que j’imaginais alors être un temple du savoir, un panthéon de la connaissance. Je me voyais déjà marchant en toge parmis les vénérables érudits qui, au prix d’une vie de labeur et d’intense réflexion, avaient amassé une telle compétence que le simple fait de leur baiser les pieds me remplirait d’honneur et de joie.
Enfin ! Enfin, terminées les pénibles heures, incomfortablement assis devant un cahier à étudier des matières inutiles et obsolètes. Enfin, j’allais pouvoir m’abreuver au calice de la culture informatique. J’allais boire jusqu’à la lie le doux hydromel de cette noble science.
Une larme me monte au yeux lorsqu’à ma mémoire remonte avec nostalgie le souvenir de mon second cours de programmation (le premier était une fabuleuse analogie entre la programmation et le tricot irlandais). Je revois encore l’honorable professeur, barbu et imposant comme il se doit, pénétrer d’un pas sûr et tranquille dans l’amphi bondé, et d’un seul regard, serein mais implacable, imposer le silence aux étudiants.
Après nous avoir considéré quelques secondes, l’éminent docteur, toujours sans dire un mot, se tourne vers l’immense tableau vert, saisi une craie, et commence à écrire. Dans la salle, pas un mot, pas un chuchotement. Nous sommes tous figés, écoutant religieusement les crissements de la craie, attendant ce qui va suivre. Notre curiosité, notre soif d’apprendre sont telles, que nous n’osons presque plus respirer.
Après deux interminables minutes, l’estimable savant pose sa craie, se frotte les mains en se tournant vers nous, nous considère d’un oeil malicieux, et nous lance, narquois : « Alors, quelque peut-il me dire ce que cela signifie ? »
void action(int* var1, int* var2) { *var1 = *var1 + *var2; *var2 = *var1 - *var2; *var1 = *var1 - *var2; } int main() { int var1 = 5; int var2 = 7; action(&var1, &var2); printf("%d %d\n", var1, var2); }
Après quelques dizaines de secondes à rester dubitatif, observant ces symboles cabalistiques les yeux plissés par l’effort de réflexion, nous dûmes bien avouer notre impuissance à leur attacher un sens.
Amusé, l’honoré pédagogue, celui qu’au fond de nous nous appellions déjà « maître », repris sa craie et compléta le blanc qu’il avait judicieusement laissé au tableau.
/* * Type : procédure * Paramètres : 2 entiers var1 et var2 * Résultat : Rien * Action : cette fonction échange les deux valeurs des variables passées en paramètres, * sans utiliser de variable intermédiaire */ void action(int* var1, int* var2) { *var1 = *var1 + *var2; *var2 = *var1 - *var2; *var1 = *var1 - *var2; } int main() { int var1 = 5; int var2 = 7; action(&var1, &var2); printf("%d %d\n", var1, var2); }
« Et maintenant, comprenez vous ? » Évidemment ! L’évidence nous avait sauté aux yeux. Tout était limpide comme de l’eau de source. Fallait-il que nous soyons sots et ignorants pour n’avoir pas compris plutôt ? Ce code échangeait tout simplement les valeurs des deux variables passées en paramètres, sans utiliser de fonction intermédiaire.
« Sans commentaires, un code est incompréhensible. Dorénavant, vous ajouterez un commentaire devant chaque fonction, pour indiquer son action, ses paramètres, et son retour. Si vous ne vous conformez pas à cette règle, inutile de vous présenter à l’examen ».
Une fois cette docte sentence prononcée, le vénérable enseignant tourna les talons, et sorti sous nos applausissements déchaînés. En fait, seuls ma pudeur naturelle et les traces de vieux chewing-gums écrasés par terre me retinrent de me jeter à ses pieds pour le supplier de me bénir.
Ça-y-était !!! Nous jouyions dans la cour des grands. Nous n’étions plus de pauvres demeurés, nous savions que chaque fonction doit être précédée d’un long commentaire ! Nous pûmes alors nous rendre sur les forums de développez.com, et étaler ouvertement notre science en méprisant les hérétiques qui ne commentaient même pas leurs fonctions (les fous) !!
Depuis, beaucoup d’eau a coulé sous les ponts
Depuis ce temps béni, quelques longues et pénibles années se sont écoulées. Alors que je commence à accumuler de l’expérience professionnelle (pas beaucoup, mais un peu quand même), ma naïve insouciance d’alors s’efface peu à peu, érodée par les nombreuses occasions que j’ai d’observer le code des autres d’un regard un peu critique.
Tel l’enfant qui découvre que son père n’est pas tout puissant, il me fallut beaucoup de courage pour affronter la détresse qui fut mienne lorsque je fit cette terrible découverte : mon adoré, mon honoré, mon vénérable et vénéré maître avait tort. Car je dus me rendre à l’évidence : les commentaires, c’est mieux quand y-en a pas !
La suite au prochain épisode…
16 Commentaires
Je crois que j’ai deviné la chute.
Mais en tout cas c’était intense, éprouvant, beau.
J’ai hâte de lire la suite de cette aventure « (ro)cobolesque »
K, on a dit que les commentaires c’est mieux quand il n’y en a pas…
Mince ! moi aussi j’en ai posté un :p
Oula ! Pas de confusion ! Je parle des commentaires dans le code, pas les commentaires des blogs.
Ici, les commentaires, c’est mieux quand y-en a
oui, j’avais bien compris ^^
*var2 = *var1 – *var2 ;
Je m’abstiendrais de commentaire sur ce diff…
Et sinon oui… tant que les noms de fonctions sont clairs et la structure limpide comme de l’eau de roche, les commentaires restent souvent inutiles, même si des fois on est bien content d’en trouver.
Oups le diff avait des caractères html, il est mal passé. Bon, on là refait. Il faut changer la ligne :
*var2 = *var1 + *var2 ;
…par :
*var2 = *var1 – *var2 ;
Le code marchera peut-être mieux ; et bizarrement c’est plus clair
De manière générale, s’il y a besoin de commenter, c’est que le code est pourri.
http://www.clifford.at/style.html
Deux notes sur l’exemple du prof :
* N’importe qui ayant codé plus d’un an devrait avoir reconnu la fonction au premier coup d’oeil. Si vous êtes payé pour coder et que vous n’avez pas reconnu ce que fait cette fonction « instictivement », par pitié, changez de métier.
* Cette fonction ne devrait jamais être utilisée dans la vraie vie. Mieux vaut utiliser une variable intermédiaire dans le code et laisser le compilateur optimiser tout seul. Premature optimization is the root of all evil, toussa.
Cette fonction a un problème plutôt gênant… Si tu lui donnes deux pointeurs identiques (quelle que soit la valeur pointée), l’échange ne devrait pas avoir d’effet, pourtant tu reçois deux beaux zéros…
c’est comme si après toutes ces années tu n’avais pas compris la substance du cours car tu en es resté à la surface à mon humble avis..
1) les commantaires dans ce style aident à comprendre rapidement le code et surtout à s’y repérer… en effet, quand tu dois déboguer un long source dont tu ne sais absolument rien, je ne pense pas que tu t’amuse à parcourir chaque fonction.. moi je repère plutôt la ligne « action » des cartouches devant la fonction (en repensant, je comprend mieux pourquoi les collègues n’arrivaient pas à me suivre)…
ici, je signale à Krunch que quand il prend le code du stagiaire qui dit que ça marche pas ; sans le commentaire, devinerait-il si un moins est replacé par un plus où y passerat-il du temps.. ? :-/
2) les commentaires aident à documenter le code ! en effet. le pédaguogue a montré un commentaire bien structuré dont il faut apprendre la syntaxe aussi.. et une autre grande règle voulant que l’on écrive la documentation au fur et à mesure (bah oui, ne pas remettre à demain), cette présentation peut permettre l’analyse automatique (parsing) pour générer la documentaion technique (cf Doxygen, perldoc, javadoc, etc.)
3) il ne s’agit pas de mettre des commontaires à tout va, genre :
*var1 = *var1 – *var2 ; // je retranche var2 de var1 et je stocke le résultat dans var1
(autant faire du cobol dans ce cas) ; mais de permettre la relecture rapide (je l’ai déjà dit) et facile du code (dans cet exemple, on sait quels arguments sont accepté et ce qui est retourné -idéalement, il faudrait dire à quoi ça correspond parce-que ces noms de variable ne sont pas franchement parlantes) ..même par quelqu’unqui ne parle pas C/C++
4) puique j’ai parlé de structure, les commentaires sont à mettre dans le même sac que l’indentation et la convention de nommage des variables et constantes. tout ce fratras est bien inutile aussi puisque tout codeur digne de ce nom sait lire et comprendre ceci :
int var1=5 ; int var2=7 ; action(&var1, &var2) ; printf( »%d %d\n », var1, var2) ;
alors, même quand les commentaires semblent inutiles, perso, je suis bien content de les trouver
@Sapporo : c’est pourquoi je suis d’accord avec Krunch qu’il faut toujours utiliser une variable intermédiaire… tu as du être victime d’un débordement de capacité (ici, on n’échange pas les variables, on fait deux calculs dont le résultat est la permutation..) couplé à l’effet pointeur (en opérant directement sur la mémoire, à toi de faire les vérifs nécessaires ; je ne crois pas qu’il y ait « cast » avant que les opérations soient effectuées)
Je crois que tu ne m’as pas compris. Si je fais :
int main(void)
{
int val =56 ;
action(&val, &val) ;
printf( »%d\n », val) ;
}
J’obtiendrai zéro alors que je veux 56… J’admets que c’est tiré par les cheveux mais le comportement de cette fonction me gêne quand même.
si si, cela me semble tout à fait normal (ici, on n’échange pas les variables, on fait deux calculs dont le résultat est la permutation..)
déroule l’algo dans l’idéal pour voir :
1ère op : var1 = var1 + var2 ; // var1 est alors à 56+56=112 et var2 à 56
2ème op : var2 = var1 – var2 ; // var1 est à 112 et var2 est à 112-56=56
3ème op : var1 = var1 – var2 ; // var1 est à 112-56=56 et var2 est à 56
maintenant, reprends le film dans ton cas particulier où var1=var2=var.. :
1ère op : var = var + var ; // var est alors à 56+56=112
2ème op : var = var – var ; // var est alors à 112-112=0
3ème op : var = var – var ; // var est alors à 0-0=0 c q f d
ce qui n’arrive pas avec une variable intermédiaire puisque tu ne fais que transvaser en utilisant une case vide (alors qu’ici tu fais des calculs qui modifient tes valeurs au fur et à mesure… )
pour la route : essaye d’échanger ainsi 1/3 et 2/3 (c’est un tout autre problème, mais c’est toujours à cause du calcul direct)
Alors c’est que tu m’avais bien compris
Ce qui me gêne c’est que effectuer un échange entre une même variable devrait théoriquement jamais donner 0. C’est pourtant ce à quoi on arrive avec cette implémentation de la fonction « échange ». Un personne qui voit la fonction « échange » ne peut pas deviner ce comportement (à moins de documenter ce comportement en particulier). C’est donc dangereux.
En résumé, je veux donc dire que ce comportement est contre-intuitif et donc dangereux (même si on peut l’expliquer dans la pratique).
j’utilise souvent cet exemple pour montrer d’une part l’utilité des variables intermédiares ( les bêtes des mathématiques ayant tendance à prendre trop facilement ce genre de raccourcis) et d’autre part pourquoi l’algorithmique est tout un boulot (au grand damn des codeurs qui ne veulent pas perdre de temps en analyse ou qui pensent qu’on trouve les failles en compilant et exécutant pour voir… (le pur et bon analyste peut prévoir ce problème et je l’ai pointé du doigt la première fois que j’ai vu cet algo -habitude aussi de dérouler mentalement)
ce genre de fonction en soi n’est pas dangereux quand on sait l’utiliser (utile par exemple quand on transpose du code en assembleur et qu’on n’a pas assez de registres ou de pile pour se permettre un intermédiaire… et dans un niveau plus haut comme celui-ci, la fonction ne devrait être déroulée que si on lui passe deux valeurs distinctes…)
enfin, pour en revenir à nos moutons, cela fait partir des effets de bords qu’il peut être bon de commenter pour quand on sera relu par un novice ou quelqu’un de trop pressé (ça fait pas toujours tilt dans l’urgence, même pour les meilleurs) =D
J’ajouterais que ce comportement devrait au moins être documenté correctement et ceci même si les programmeurs qui reliront le code sont des demi-dieux.
Si on ne le fait pas on les oblige à lire toutes les fonctions qu’ils utilisent pour vérifier leur comportement avant de commencer à coder. Ceci est trop couteux en temps même pour un professionnel (on ne va pas relire 4′000 lignes pour découvrir le comportement de chacune des fonctions utilisées).
je tenais à vousfaire un petit commentaire pour vous dird que votre blog est très symathique !
One Trackback
[...] ceux qui, parmis vous qui me lisez, ont déjà reçu durant leurs études un cours intégralement dédié à l’utilisation des commentaires ? Allons, levez la main ! Hum… Ça ne fait pas [...]