Techniques et astuces de programmation pour débutants et "confirmés", Partagez ici vos techniques et astuces pour mieux programmer

[macuserfr]

Zut alors! Le niveau baisse... Vite les gars, proposez un bonne astuce pour qu'on finisse épinglés!

[bad_duck]

Ouep le rechercher / remplacer est plus que risqué si il change plus de chose que tes variables ou tes fonctions (dommages collatéraux), c'est pourquoi certains IDE changent automatiquement les références à une variables / fonctions quand tu en change le nom (de mémoire netbeans le fait).

Sinon le sujet du topic est assez vague et dépend principalement du langage qu'on utilise.

[macuserfr]

On est beaucoup parti sur le C, mais je pensai un peu à m'abstraire au langage. Pour être un bon programmeur il faut de la logique, de la rigueur. Avoir une capacité de schématiser, de concevoir sans même avoir pondu une ligne de code. c'est plutôt des trucs et astuces là dessus que je pensais, avec surtout un retour d'expérience de ceux qui "ont de la bouteille" (dans le bon sens du terme) pour dire "ça ça marche, ça c'est de la c** vous pouvez oublier".

Après, pourquoi pas quelques astuces sur des langages aussi. Mais le but ce n'est pas de faire une n-ème "guerre de langages", il y a déjà beaucoup de topics là dessus.

Donc on pourrait recentrer le débat sur comment coder plus vite, plus efficacement, plus proprement.

[greg57]

Ben dans ce cas c'est plus du codage c'est de l'algorithmique non ?

[macuserfr]

Oui, une grande partie d'algo, mais pas seulement, tout ce qui fait partie d'un projet de programmation en dehors du code bête et méchant, cela peut aussi être l'organisation du travail, bien définir le cahier de charges avant de commencer le projet, ...

[bad_duck]

http://fr.wikipedia.org/wiki/Méthode_agile
http://fr.wikipedia.org/wiki/Patron_de_conception

[noop]

Voici un exemple de bout de code qui écroule toutes les perfs dans un programme. Pourtant ca part d'une bonne intention

Code

void maMethodeDeTrace(String message, int niveauDeTrace) {
       if (niveauDeTrace < niveauDeTraceGlobal) {
            logger.trace(message);
       }
}

Voici le code Appelant:

Code

maMethodDeTrace(monObject.toString(), 2);

Le problème est le suivant: avant de faire l'appel à la méthode maMethodeDeTrace, le langage va évaluer le premier parametre. Si le niveau de trace est insuffisant rien ne sera tracé, mais on aura perdu du temps a transformer un object en chaine de caractère. Si cet appel se répète trop souvent, le programme va ramer un max.

[Jaypee]

Dans ce cas, il faut une API du style boolean isNiveauDeTraceSuffisant(int niveauSouhaite);

Les Loggers ont des primitives Logger.isDebugEnabled() dans ce même but.

A propos des remplacements multiples, c'est une illustration du proverbe que je cite souvent :
Un programmeur est un paresseux qui travaille beaucoup.

Par paresse, il va se donner la peine de trouver l'expression régulière qui va magiquement remplacer son motif dans toutes les configurations les plus tordues. Ce proverbe n' est pratique que si on se demande "Mais que ferait un bon programmeur dans cette situation ?" Il va étudier et retenir tous les trucs tordus, qui parfois vont lui faire gagner 10% du temps. C'est pour cela qu'il apprend toutes les commandes de <choississez l' éditeur que vous détestez le plus>

Au passage, des trucs d'édition...
Qui connaît la commande "deep" dans vi ?
de : delete to the end
e : go to the end
p : paste colle à droite du curseur
Elle permute deux mots.
et xp ? "xp" fait la même chose pour 2 caractères
x : delete du caractere sous le curseur, qui se trouve maintenant sur le caractère suivant
p : paste colle à droite du curseur

Et puisqu'on est sur le sujet des recherches, la commande vi pour remplacer tous les x par y, partout dans la ligne
:g/x/s//y/g

Le premier g est pour indiquer toutes les lignes, le dernier pour "partout dans la ligne", si on l' oublie, seul le premier remplacement est fait dans la ligne.

Le s c'est pour substituer

C'est la version simplifiée de remplacer tout les x par des y, partout dans les lignes où se trouve z
:g/z/s/x/y/g
La forme compliquée de la première serait : sur toute lignes où il y a x, remplacer x par y. Du fait que le motif de recherche des lignes est aussi le motif à remplacer, on peut l'omettre après le s.

J'ai appris tout ça par paresse...

J-P

Ce message a été modifié par Jaypee - 28 Jul 2009, 20:11.

[macuserfr]

J'arrive pas à m'y faire avec les éditeurs en ligne de commande. Certes, je reconnais qu'un pico ou autre pour remplacer une virgule dans un script qui est en root ça va plus vite que de prendre le script, ouvrir dans l'interface graphique en non-root (oui, d'accord, t'as des astuces pour le faire en root) puis sauvegarder en non-root et recopier en root à son endroit d'origine. Vous me suivez encore?

Pour mes petits développements je passe par Smultron que je trouve simple et efficace. J'ai vu TextMate dans une video de présentation de Python, qui a l'air bien aussi. Pourquoi ne pas les utiliser sur des stations graphiques? D'accord qu'en ssh ou sur un serveur ou t'as qu'une CLI ça se corse, mais bon, ma station de développement de base c'est un Mac.

Sinon, là il va falloir que je debug du php, donc à ce que j'ai compris, pas trop le choix, le mieux c'est d'installer l'usine à gaz qu'est eclipse PDT.

[bad_duck]

J'arrive pas à m'y faire avec les éditeurs en ligne de commande. Certes, je reconnais qu'un pico ou autre pour remplacer une virgule dans un script qui est en root ça va plus vite que de prendre le script, ouvrir dans l'interface graphique en non-root (oui, d'accord, t'as des astuces pour le faire en root) puis sauvegarder en non-root et recopier en root à son endroit d'origine. Vous me suivez encore?

Pour mes petits développements je passe par Smultron que je trouve simple et efficace. J'ai vu TextMate dans une video de présentation de Python, qui a l'air bien aussi. Pourquoi ne pas les utiliser sur des stations graphiques? D'accord qu'en ssh ou sur un serveur ou t'as qu'une CLI ça se corse, mais bon, ma station de développement de base c'est un Mac.

Sinon, là il va falloir que je debug du php, donc à ce que j'ai compris, pas trop le choix, le mieux c'est d'installer l'usine à gaz qu'est eclipse PDT.

Apprendre à utiliser un éditeur en cli (vim, nano ou autre) est assez pratique pour les machines qui n'ont pas d'interface graphique (les serveurs MacBidouille par ex), surtout quand tu as juste des petites modifications à faire (décommenter une ligne, changer un p'tit param etc..).

Textmate est un super éditeur de texte, je m'en sers pour faire du xhtml/php/css etc.. et pour le debug php je vois pas trop l'intérêt d'éclipse : t'as simplement besoin d'un serveur web qui supporte php : si ya pas de warning ou de notice : c'est bon ; si la page te sort un gros warning tu regarde la ligne et tu vas débugger avec ton éditeur de texte

[macuserfr]

Pour les éditeurs texte, on est d'accord

Pour le debug de PHP, oui, tu peux faire comme cela, voire même mettre des echo/var_dump dans ton code (ce que je fais actuellement). Mais il y a des fois ou ce serait pratique d'avoir un vrai debugger à la gdb, pouvoir passer toutes les variables en revue. Quand tu comprends le bug, c'est simple, comme tu dis tu va à la ligne où il faut et tu changes l'instruction qu'il faut.

Mais quand t'as des trucs tordus, t'es bien content de pouvoir exécuter ton code pas à pas et voir le changement d'état des variables jusqu'à capter où est le problème. C'est là que les outils de débogage d'eclipse entrent en jeu.

Je suis d'accord pour dire que si tu codes proprement et avec de l'expérience, t'es pas censé avoir des comportements tordus en test. Mais en phase d'apprentissage et prise en main des outils cela me semble inévitable. Le php est loin d'avoir toutes les "bizarreries" du C, il a aussi quelques particularités auxquelles il vaut mieux faire attention.

[Hellstorm]

Personellement pour coder du C/C++ je me sers de xcode, après pour le reste je rejoins macuserfr sur smultron qui est léger et simple d'usage, TextMate est payant si je ne m'abuse..
Sinon en CLI, je trouve nano très simple pour des petites éditions rapides, je n'ai personellement pas accroché VIM.

[macuserfr]

Pareil, pour mes gros projets en C pendant les études je suis passé par XCode que j'ai maitrisé assez rapidement pour debugger avec un GUI sur gdb, c'était le bonheur. J'ai des copains qui se cassaient les dents avec gdb (qui fait théoriquement la même chose, mais qui est plus austère à maîtriser) ou avec KDevelop qui à l'époque n'était pas aussi simple que XCode. Eclipse en était à ses débuts, surtout focalisé sur Java.

Il y en a plus d'un qui a bavé sur mon iBook et ce que je pouvait faire (simplement) avec pour debugger.

[Jaypee]

J'avais signalé un problème de Smultron que je trouve important : De tous les éditeurs courants, c'est le seul qui ne signale pas qu'un document ouvert a été modifié et donc le seul à ne pas proposer de le recharger. C'est un risque important de réimporter des bugs déjà fixés.

A mon avis, c'est rédhibitoire pour un usage "pro", mais il reste très bien pour des utilisations occasionnelles.

TextMate a un tel impact qu'il existe une personnalisation d'Eclipse qui reprend son thème de couleurs, et de même pour jEdit.

Etant sur du Java principalement, je travaille avec Eclipse qui est vraiment très, très puissant :
- Propose les noms de méthodes après le point (à la Intellisense)
- Import automatique des bibliothèques
- Nettoyage des imports non utilisés
- Formattage automatique (des accolades...) selon les règles fixées
- Géneration des commentaires Javadoc.
- Generation des getters/setters des propriétés.
- Refactoring
- ...

J-P

Ce message a été modifié par Jaypee - 29 Jul 2009, 11:43.

[Hellstorm]

Je ne suis pas sur, mais il me semble que dans les options avancés de smultron il y a une option pour vérifier si un document ouvert à été modifié (je ne peux vérifier en ce moment étant windows :<)

[macuserfr]

Oui, l'option existe sur la dernière version (3.5.1) mais décochée par default, je viens de la cocher
Ceci dit, je ne m'aventure pas à éditer mes codes avec 2 éditeurs en même temps. Même si c'est techniquement possible, c'est très casse-gueule comme méthode.

[Vin's]

Une petite bibliothèque qui facilite le déboguage des allocations mémoire en C : Electric-Fence.
Par exemple, si l'on a le code suivant :

Code

int* tab = malloc(10 * sizeof(int));
tab[10] = 42; /* ERREUR tab a 10 éléments, de 0 à 9 */

Généralement, un débordement de tableau comme celui-ci ne fera pas planter immédiatement le programme. Mais il pourra provoquer des plantages plus tard, à cause de la corruption mémoire engendrée...
Le but d'Electric-Fence est justement de faire planter le programme dès qu'il provoque un débordement de tableau.
Il fonctionne bien sous Mac OS X... Il suffit de lier le programme que l'on débogue à la libefence (et éventuellement mettre la variable d'environnement EF_PROTECT_BELOW à 1 si l'on veut que Electric-Fence surveille aussi les sous-débordements), et c'est bon

Attention, cet outil ne vérifie pas les allocations mémoire faites sur la pile (comme "int tab[10]"). Pour vérifier ça (ainsi que beaucoup d'autre choses...), il y a Valgrind (mais seulement sous Linux...)

Ce message a été modifié par Vin's - 30 Jul 2009, 08:59.

[noop]

Quand on fait du développement en C/C++ multi tache, débugger un programme qui crash est quelque fois impossible. En effet, si l'on pose un break point dans une thread, on change le comportement de l'ensemble du processus (si celui-ci a été mal architecturé par rapport aux mécanismes de rendez vous ou d'attente sur sémaphore). L'unique solution est quelque fois d'utiliser des debugger "post-mortem".

Le principe est simple, le programme est compilé avec un bout de code qui provoque un "dump" en cas de crash.

Le dump une fois récupéré peut être analysé avec le debugger. A charge du développeur de fouiller ses stack et la mémoire pour trouver ce qui cloche.

[macuserfr]

Un peu HS, mais à l'école d'ingé où j'ai été le Linux était configuré de base pour générer ces dump lors d'un crash. Or nous avions un quota très restrint (du genre 30Mo). Du coup on avait un config à mettre dans notre .profile pour éviter de créer ces dump et de bloquer notre session si on était un peu juste niveau quota.

[cbrandt]

En C/Objective-C je mets toujours cette petite macro pour faciliter le traitement des erreurs:

Code

#define Fail(erreur,label) {if(erreur) goto label;}

oui, je sais, les goto c'est crade, mais c'est pour la bonne cause
Ça permet de regrouper le code de gestion d'erreur en fin de fonction, et ça s'utilise comme ça:

Code

int err;
...
err = appel_de_fonction ();
Fail (err, stop);
...
return;
stop:
NSLog (@"erreur: %d", err);
...

[macuserfr]

Pourquoi faire du goto et des labels quand un

Code

if(!fonction())
{
    //traitement de l'erreur
}
//continuation du code

fait la même chose en plus propre (en supposant que la fonction retourne 0 si erreur)?

Si plusieurs morceaux ont besoin du même traitement d'erreur, dans la partie traitement d'erreur dans le if il suffit de faire un appel vers une fonction dédiée à la gestion d'erreur (c'est même recommandé). Cela revient au même effet que ta macro, mais en plus propre et lisible.

[cbrandt]

je m'explique

si on a juste un ou deux appel de fonctions, ton exemple est ok, c'est comme ça que je fais aussi.
mais si on a un enchaînement de plusieurs fonctions qui renvoient un code d'erreur, on aurait le cheminement normal encombré (visuellement) de traitement d'erreur:

Code

if(!fonction1())
{
    //traitement de l'erreur
}
if(!fonction2())
{
    //traitement de l'erreur
}
if(!fonction3())
{
    //traitement de l'erreur
}
//continuation du code

alors que comme ça c'est plus clair (à mon avis):

Code

err = fonction1 ();
Fail (err, stop);
err = fonction2 ();
Fail (err, stop);
err = fonction3 ();
Fail (err, stop);
//continuation du code
return;
stop:
// traitement erreur(s)

par ailleurs, si une fonction renvoyant une erreur implique que la fonction qu'on écrit doit finir en erreur aussi, ça permet de faire le ménage proprement et dans l'ordre:

Code

mafonction()
{
int err;
char *buffer;
FILE *file;

err = fonction1 ();
Fail (err, stop1);

buffer = malloc (xxx);

err = fonction2 ();
Fail (err, stop2);

fichier = fopen ("chemin", r);

err = fonction3 ();
Fail (err, stop3);

err = fonction4 ();
Fail (err, stop4);

fclose (fichier);
free (buffer);

// suite du traitement

return; // ok - avec éventuellement un code pour indiquer le succès

stop4:
stop3:
    fclose (fichier);
stop2:
    free (buffer);
stop1:
    // gestion erreur
    return; // avec éventuellement un code erreur
}

si l'appel à fonction2() échoue, on désalloue buffer mais on ne touche pas à fichier - et si ça échoue sur fonction3() ou fonction4(), on ferme fichier d'abord, puis on désalloue buffer…

mais bon, il y a toujours plusieurs façons de faire, et chacun préfère la sienne

Ce message a été modifié par cbrandt - 14 Aug 2009, 14:18.

[noop]

je m'explique
si l'appel à fonction2() échoue, on désalloue buffer mais on ne touche pas à fichier - et si ça échoue sur fonction3() ou fonction4(), on ferme fichier d'abord, puis on désalloue buffer…

mais bon, il y a toujours plusieurs façons de faire, et chacun préfère la sienne

Code

stop3:
    fclose (fichier);
stop2:
    free (buffer);

Mieux vaut ca:

Code

stop3:
     if (fichier != NULL) {
    fclose (fichier);
     }
stop2:
     if (buffer != NULL) {
    free (buffer);
     }

Ce message a été modifié par noop - 14 Aug 2009, 14:34.

[cbrandt]

Bien vu
j'aurais dû ajouter un appel à Fail() après malloc() et après fopen()...

Fail (buffer == nil, stopXXX)

et

Fail (file == nil, stopXXX)

[Jaypee]

Sur ce coup, j'suis sceptique. Si le langage offre un try/catch/finally c'est quand même plus propre.

Mais si effectivement ça manque, c'est une bonne béquille.

La leçon essentielle qu'il faut retenir de cet exemple est que le programmeur est souvent focalisé sur la gestion mémoire, allouer, rendre les blocs, mais oublie les autres ressources système qu'il utilise:
- Les fichiers ouverts
- Les connections ouvertes (Connection pools des serveurs bd)
Il faut aussi les restituer.
En fait, ici faudrait simuler en plus le bloc finally dans lequel on passe toujours, succès ou erreur. Et c'est là qu'il faut tester si File est null sinon le fermer etc...

C'est qui conduit à bloquer une machine et à devoir la redémarrer.

[macuserfr]

Oui, je suis sceptique aussi. En effet des try catch dans un langage qui le permet c'est prévu pour. Sinon tu peux toujours te débrouiller pour avoir des fonctions et un switch pour réaliser ces codes là au lieu de passer par des labels + goto + macro (cocktail explosif si utilisé sans parcimonie).

Code

int fonction() {
    ...
    if(!machin())
        gestionErreur(1, fichier, buffer);
    if(!machin2())
        gestionErreur(2, NULL, buffer);
    if(!machin3())
        gestionErreur(1, fichier, buffer);
    ...
}

int gestionErreur(int errno, void *fichier, void *buffer) {
    switch(errno) {
        case 0: ...
        case 1: fclose (fichier);
        case 2: free(buffer); break;
        default: ...
    }
}

Bon, d'accord, t'as des variables à passer en plus, mais c'est beaucoup plus portable pour réutiliser le code sur un langage qui n'ai pas de goto, de label ou de macro. Qu'en pensez-vous?

[hubeert]

coucou
personnellement et afin d'optimiser le code je suis pour l'utilisation du binaire autant que possible..
exemple un profil d'utilisateur défini par 32 paramètre qui sont sur on ou off. dans une base de donnée normale ou avec des variables nous avons besoin de 32 champs ou variables différentes. si nous avons 1 000 000 d'utilisateurs nous avons donc 1 million d'enregistrement pour 32 champ mais si on utilise la programmation binaire avec les opérateurs adéquat on peut stocker 32 paramètre dans un seul nombre..lorsque on veut transférer un profil on manipule un seul chiffre. dans un jeu de tetris par exemple pour savoir ou se trouve les éléments je n'ai a tester qu'une dizaine de chiffre.. dans un panneau lumineux régit par des diiodes mes lettres sont représentées par un carre de 30 diodes que j'allume ou jeteinds pour faire un A un I ou un Z chaque lettre est représentée par un nombre en binaire qui indique quelle diode est éclairée ou éteinte; avec 26 variable (26 nombres) par exemple j'ai mon alphabet..

[noop]

coucou
personnellement et afin d'optimiser le code je suis pour l'utilisation du binaire autant que possible..
exemple un profil d'utilisateur défini par 32 paramètre qui sont sur on ou off. dans une base de donnée normale ou avec des variables nous avons besoin de 32 champs ou variables différentes. si nous avons 1 000 000 d'utilisateurs nous avons donc 1 million d'enregistrement pour 32 champ mais si on utilise la programmation binaire avec les opérateurs adéquat on peut stocker 32 paramètre dans un seul nombre..lorsque on veut transférer un profil on manipule un seul chiffre. dans un jeu de tetris par exemple pour savoir ou se trouve les éléments je n'ai a tester qu'une dizaine de chiffre.. dans un panneau lumineux régit par des diiodes mes lettres sont représentées par un carre de 30 diodes que j'allume ou jeteinds pour faire un A un I ou un Z chaque lettre est représentée par un nombre en binaire qui indique quelle diode est éclairée ou éteinte; avec 26 variable (26 nombres) par exemple j'ai mon alphabet..

Méfie toi, le binaire n'est pas la donnée la plus optimisée pour les bases de données. J'ai eu récemment a envisager cette solution dans le cadre d'une application qui avait une désynchronisation de base de données entre deux logiciels. Bref, afin de marquer les champs mis à jour j'avais envisager une utilisation de flags avec du binaire. renseignement pris, un admin Oracle m'a déconseiller fortemment cette astuce. J'ai suivi à la lettre ce conseil.

Etant donné la puissance des processeurs et les capacités de stockage, les économies de bout de chandelle peuvent être catastrophiques.

[hubeert]

coucou;
je n'ai pas parlé "vraiment" de base de données mais de variables constituées d'un seul nombre et pouvant contenir 32 indications on ou off..
ceci dit l'optimisation relève souvent de toute petites économies
et je suis totalement contre l'idée que puisque les processeur sont performants et puisque on a de la place on peut coder comme un cochon (je sais que ce n'est pas ça que tu as voulu dire ) et ne pas rechercher une manière plus optimisée.. mais je pense aussi que les codeurs professionnels n'ont pas toujours le temps au vu du cahier des charges.

Ce message a été modifié par hubeert - 17 Aug 2009, 09:04.

[noop]

coucou;
je n'ai pas parlé "vraiment" de base de données mais de variables constituées d'un seul nombre et pouvant contenir 32 indications on ou off..
ceci dit l'optimisation relève souvent de toute petites économies
et je suis totalement contre l'idée que puisque les processeur sont performants et puisque on a de la place on peut coder comme un cochon (je sais que ce n'est pas ça que tu as voulu dire ) et ne pas rechercher une manière plus optimisée.. mais je pense aussi que les codeurs professionnels n'ont pas toujours le temps au vu du cahier des charges.

1) concernant les 32 indications ON/OFF. Certes autant pour moi concernant les bases de données. Mais l'utilisation du binaire limite beaucoup les évolutions du code. Comment fais tu pour traiter la 33 ème ? . Bon je pinaille..... mais quelque fois en cours d'évolution d'un projet, le domaine de valeurs d'un indicateur peut quelque fois passé du ON/OFF a ON/OFF/INDETERMINE....là je ne sais pas comment tu fais evoluer ton traitement sauf a faire une belle verrue

2) l'optimisation coûte souvent très cher et doit rester dans un ratio qui ne grève pas les coûts de maintenance ( la maintenance = 70% de la charge d'un soft). Et avant d'en arriver au binaire, les gains de performances peuvent être trouvés sur des motif de programmation simples: examen des boucles internes, recherche dans les chaines de caractères, utilisation de pattern plutot que de boucle laborieuses.

3) le travail de cochon.....ca c'est dans l'air du temps et c'est une tendance qui va devenir la règle (si ce n'est pas déjà fait).