Nos petits trucs utiles de développeurs

[ddrmax]

Même si je viens du monde de builder, j'ai quelques éléments qui peuvent servir:
Cela concerne plus une chose en rapport avec les premiers posts du topic (assez ancien) mais don je n'ai vu aucune information a proprement parlé dessus.
Cela utilise une astuce de CGI pour c++ builder et quelque petites autres astuces:

• Création d'une classe Logger
• Dedans, je crée un constructeur avec Owner et deux booléens
• Ce constructeur va créer un affichage console (astuce de CGI) et un fichier texte (basé sur fstream), avec un nom basé comme ceci APPLICATION_NAME_OWNERNAME_YYYY_MM_DD_hh_mm.log
• les boolens indique si je crée ce fichier et si je crée mon affichage console
• Cette classe recevra deux fonctions:
• OtuputDebugString(String) qui va simplement ajouter la string que je veux et celui-ci ajoute automatiquement l'heure en face
• OutputException (Exception) qui va automatiquement ajouter une trame avec l'heure,le type d'exception,la valeur de l'exception, la valeur de GetlastError et sa définition
  
  Je place ces fonctions dans aux endroits qui posent problème
  

Depuis j'ai commencer a l'étoffer et desormais ça me sors automatiquement dans mon log :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
 
**************************************************************
*                   Project System LogFile                   *
*                   Project 1.38.02 Series                   *
*                   Related Build: Release                   *
**************************************************************
 
**************************************************************
*                 Windows System Information                 *
**************************************************************
Computer Name: XXXXXXX-DEV
Windows Version: Windows XP
Windows Build: 2600
Service Pack: Service Pack 3
Physical Memory: 2046 Mo
User Name: YYYYYYY
Admin Rights: User is in the Admin Group
 
**************************************************************
*                 Project System Information                 *
**************************************************************
Project Release: 12w49b
Related Build: December 2012
Release Date: Week 2 (Week 49 of the Year)
Project Core Type: Hybrid
Project Core Version: Revision 45.12.38b
 
**************************************************************
*                       Project Plugins                      *
**************************************************************
xxxxxxxxxxxxxxxx Revision 21
xxxxxxxxxxxxxxxx Revision 37
xxxxxxxxxxxxxxxx Revision 4
xxxxxxxxxxxxxxxx Revision 2
xxxxxxxxxxxxxxxx Revision 0
xxxxxxxxxxxxxxxx Revision 38 snapshot21
xxxxxxxxxxxxxxxx Revision 254
xxxxxxxxxxxxxxxx Revision 4881
xxxxxxxxxxxxxxxx Revision 2
xxxxxxxxxxxxxxxx Revision 1
 
**************************************************************
*                Project: Journal de débogage                *
**************************************************************
Debug loging file generated on08/11/2012 10:01:38
Verbose Mode is set on 1 of 3 (Standard Logging)
 
08/12/2012 : Initialisation SQL ...
08/12/2012 : Chargement des configurations ...
08/12/2012 : Chargement de la base de données ...
08/12/2012 : Chargement de la carte MapPoint ...
08/12/2012 : Initialisation de xxxxxxxxxxxxxxxx ...
08/12/2012 : Initialisation du module de reconaissance xxxxxxxxxxxxxxxx ...
08/12/2012 : Initialisation du module xxxxxxxxxxxxxxxx ...
08/11/2012 : Initialisation du module xxxxxxxxxxxxxxxx ...
08/12/2012 : Initialisation du module xxxxxxxxxxxxxxxx ...
08/11/2012 : Initialisation des modules xxxxxxxxxxxxxxxx ...
08/12/2012 : Chargement terminé
**************************************************************
*                         END OF FILE                        *
**************************************************************

et l'affichage console est coloré suivant le niveau de verbosité et de l'impact du message (coleurs claires et froides pour la verbosité et couleurs chaudes pour les warnings et les erreurs)
normalement tout ceci peut être porté sur delphi

[Thehacker]

Un showLog depuis un outil SVN (tortoiseSVN par exemple) suffit pour voir les différences relatives à une modif commitée (à condition qu'il s'agisse de commit groupé et non pas de commit fichier par fichier)

[Andnotor]

Envoyé par Kymic

ce message c'est trouvé en news

Est-ce que quelqu'un pourrait me donner le lien de cette news SVP ?

[ddrmax]

Envoyé par Andnotor

Est-ce que quelqu'un pourrait me donner le lien de cette news SVP ?

ici
http://www.developpez.com/actu/50202...programmation/

[Conaclos]

Pour facilement lire le flux d'instruction j'évite de le "briser", de mettre des "point de saut".
Dans une fonction je fait en sorte d'avoir un seul 'return'.
J'évite au maximum les 'break' ou 'continue' dans les boucles.
J'évite les Exceptions, je préfère responsabiliser le client.

Pour lire plus facilement un algorithme, je déclare toutes les variables au début.

Pour le versionnage je préfère itérer un numéro de révision dans l'entête du fichier.

[l.zehnder]

Pour ce type de trace sous delphi je prefere l'outils CodeSite.
Il suffit d'ajouter l'unit : CodeSiteLogging

et dans le code d'ajouter :
CodeSite.Send('MonTexte')

J'entoure le tous avec des ifdef DEBUG
On peut faire des imbrication de message, changer l'icone du message etc.

[ddrmax]

Envoyé par l.zehnder

Pour ce type de trace sous delphi je prefere l'outils CodeSite.
Il suffit d'ajouter l'unit : CodeSiteLogging

et dans le code d'ajouter :
CodeSite.Send('MonTexte')

J'entoure le tous avec des ifdef DEBUG
On peut faire des imbrication de message, changer l'icone du message etc.

tout le monde ne peut pas mettre 400$ dans leurs outils ou leurs outils ne sont pas compatibles avec se genre de solution (il est vrai que a partir de XE2 la version express est disponible)
beaucoup de personnes travaillent encore avec des version antérieures a rad studio 2007 et ou utilisent les version turbo ou personnelles de ces outils.

Ici, la solution est plus simple, il se peut que je reecrive le tout et que je le publie autant en .pas pour delphi que .h/.cpp pour C++ Builder.
Je peut voir aussi pour en faire une version compatible Visual C++ qui sait.
Le problème est que cette api contient du code propriétaire et que le support CPUID est encore bancal (Intel uniquement et pas le support total des fonctions)

[Nexavi]

Suite à la lecture de ce sujet, j'en ai une bien bonne, en alternative au "ShowMessage" qui fait débat dans les premiers posts. En effet, dans certains cas, l'unité dialogs n'a pas et ne doit pas être ajoutée, parceque "Dialogs" génère du code d'initialisation et augmente la taille de l'exe/de la dll (à éviter par example pour une dll qui va strictement faire du calcul).

Sans ajouter de code d'exception:

Code :

Assert(MaCondition = MonAutreCondition, 'MonMessageQuandCestpasVrai')

Sinon et c'est là que celà peut (et devrait faire rire), si vous avez la flegme d'ajouter Dialogs à vos uses alors pour remplacer le showmessage du débutant, faites:

Code :

Assert(0=1,'ca va se déclencher et en plus vous pouvez inspécter les variables')

Celà évite par example de devoir taper des choses lourdingues comme:

Code :

1
2
3
4
Interface
uses...{$IFDEF DEBUG}Dialogs{$ENDIF}...;
// et à chaque fois dans l'implémentation...
{$IFDEF DEBUG}ShowMessage('MonControleDeDebug'){$ENDIF}

Sachant que dans les configs "Release" vous aurrez plutôt tendance à désactiver les assertions. Dailleurs, de manière général, je suis surpris à quel point les delphiistes n'utilisent pas les assertions...J'ai participé à plusieurs programmes de béta testing où les logiciels étaient littéralement "bourrés" d'assertions...

Passons à autre chose: un mini-bread-crumb manager:

Définissez une classe de base, persistente et qui va prendre en main automatiquement les objets non-aliénés à cette classe (mais qui devraient l'être) lors de la destruction d'une classe descendante:

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
TAutoDestroyCrumbs = Class(TComponent)
Private 
  FOrphans: TObjectList; // FOrphans peut être Protected à la limite...
Public
  Constructor Create(AOwner: TComponent); Override;
  Destructor Destroy; Override;
End;
 
TDemoClass = Class(TAutoDestroyCrumbs)
Private
  FList1,FList2: TList;
Public
  Constructor Create(AOwner: TComponent); Override; 
End;
 
 
Constructor TAutoDestroyCrumbs.Create(AOwner: TComponent);
Begin
  Inherited;
  FOrphans := TObjectList.Create;
End;
 
Destructor TAutoDestroyCrumbs.Destroy;
Begin
  FOrphans.Free; // appellera free sur chaque objet ajouté dans les descendants de TAutoDestroyCrumbs;)
  Inherited;
End;
 
// par example dans la Démo on se contente de...
 
Constructor TDemoClass.Create(AOwner: TComponent)
Begin
  Inherited;
  FList1 := TList.Create;
  FList2 := TList.Create;
  FOrphans.Add(FList1);
  FOrphans.Add(FList2);
End;
// ..et pas besoin de destructeur...

En définissant un "Orphan manager" ( "un preneur en main des objets orphelins" ), on peut se permettre d'omettre la destruction des orphelins...car TObjectList gère par défaut la destruction des objets qui lui sont ajoutés...Donc ca ne leak pas...et ca évite d'écrire un destructeur...ca peut servir.

[Golgotha]

L'astuce qui me viens spontanément et que j'utilise pour 90% des mes problèmes, la dichotomie.

Exemple, j'ai une requête qui ne marche pas avec 10 lignes :

0 -------------------------------------------------------------
1 -------------------------------------------------------------
2 -------------------------------------------------------------
3 -------------------------------------------------------------
4 -------------------------------------------------------------
5 -------------------------------------------------------------
6 ---------------------x erreur x-----------------------------
7 -------------------------------------------------------------
8 -------------------------------------------------------------
9 -------------------------------------------------------------

La méthode la plus efficace pour trouver l'erreur n'est pas de la chercher directement, mais de faire un découpage et de la localiser.

Ainsi, je fait le test suivant :

j'enlève la moitié de la requête.

0 -------------------------------------------------------------
1 -------------------------------------------------------------
2 -------------------------------------------------------------
3 -------------------------------------------------------------
4 -------------------------------------------------------------

La requête fonctionne. Je sais que l'erreur se trouve dans la deuxième moitié, je fait donc de même avec l'autre moitié :

5 -------------------------------------------------------------
6 ---------------------x erreur x-----------------------------
7 -------------------------------------------------------------

de même avec le reste... Je finirais par tomber sur l'erreur, grosse comme le nez au milieux de la figure !

6 ---------------------x erreur x-----------------------------

C'est une technique qui marche avec tout et n'importe quoi, surtout quand on cherche une aiguille dans une meule de foins.

[Andnotor]

Envoyé par Nexavi

Sinon et c'est là que celà peut (et devrait faire rire), si vous avez la flegme d'ajouter Dialogs à vos uses alors pour remplacer le showmessage du débutant, faites:

Code :

Assert(0=1,'ca va se déclencher et en plus vous pouvez inspécter les variables')

Assert(FALSE, ...) serait plus esthétique, mais utiliser les assertions à la place d'un ShowMessage... fallait oser
Si tu ne veux pas de Dialogs, ben fais appel à Windows.MessageBox !

Envoyé par Nexavi

Passons à autre chose: un mini-bread-crumb manager

Grosse construction pour juste le cas où FList1.Free aurait été omis...

[tourlourou]

Grosse construction pour juste le cas où FList1.Free aurait été omis...

Mais utiliser un TObjectList comme GarbageCollector peut être pratique.

[TCHdvlp]

Bonjour à tous !

Personnellement, lorsque je rajoute du code, que ce soit pour une évolution ou une correction, je rajoute ceci dans mon code


[code existant]
//----------------- <mon nom> <numero de ticket> <description rapide> -----------

[mon code]

//--------------------------------------------------------------------------------
[reste du code]

Ca permet de retrouver facilement le code en question, et je sais si c'est moi ou un collègue qui a fait la modif.

De plus, avec certains outils, le numéro de ticket peut être récupéré depuis l'outil de gestion des bugs.

[Kaamo]

Envoyé par TCHdvlp

Bonjour à tous !

Personnellement, lorsque je rajoute du code, que ce soit pour une évolution ou une correction, je rajoute ceci dans mon code


[code existant]
//----------------- <mon nom> <numero de ticket> <description rapide> -----------

[mon code]

//--------------------------------------------------------------------------------
[reste du code]

Ca permet de retrouver facilement le code en question, et je sais si c'est moi ou un collègue qui a fait la modif.

De plus, avec certains outils, le numéro de ticket peut être récupéré depuis l'outil de gestion des bugs.

sinon il y a des gestionnaires de conf qui permettent de faire ça non ? en commentaire quand tu commit les modifications ?

[chris188]

Bonsoir,

même dans la structure des commentaires il y a moyen d'optimiser :

' UNE RUBRIQUE EN MAJUSCULE (Calculer)
for cpt=1 to X
'afaire controler Y
A=Fct(X)+cpt ' accumuler une donnée
Next

un espace = c'est fait
sans espace = à faire
en majuscule = recherche facile avec ctrl F

je pense revenir expliquer d'autres trucs
A+

[Danfas2]

pour eviter les catastrophe

J'ai toujours eu un soucis avec les sauvegardes... j'avançais, j'avançais et paf... la dernière sauvegarde remontait à trop loin... aujourd'hui je fais des sauvegarde incrémentales automatiques en arrière plan toutes les 10 minutes vers deux destinations différentes... DIR10 une sur un disque externe et l'autre sur le même disque.. c'est rapide et transparent. Je ne m en rend même pas compte et Je peux revenir en arrière de 10 minutes.

Toutes les heures deux répertoires différents DIR60 reçoivent les fichiers modifiés et Je peux revenir en arrière de 60 minutes.

Toutes les 3 heures 2 répertoires (DIR180) différents reçoivent mes fichiers modifiés.

en fin de journée je fais mon ménage, et je procède aux sauvegardes vers d'autres supports... projet 0 ,1 , 2 etc....

je me souviens plus de la fois ou j'ai perdu quelque chose.... Ca peut paraître excessif mais je ne m en rend pas compte et c est imparable.

[popo]

Suite à la lecture de ce sujet, j'en ai une bien bonne, en alternative au "ShowMessage" qui fait débat dans les premiers posts. En effet, dans certains cas, l'unité dialogs n'a pas et ne doit pas être ajoutée, parceque "Dialogs" génère du code d'initialisation et augmente la taille de l'exe/de la dll (à éviter par example pour une dll qui va strictement faire du calcul).

Sans ajouter de code d'exception:

Code :

Assert(MaCondition = MonAutreCondition, 'MonMessageQuandCestpasVrai')

Sinon et c'est là que celà peut (et devrait faire rire), si vous avez la flegme d'ajouter Dialogs à vos uses alors pour remplacer le showmessage du débutant, faites:

Code :

Assert(0=1,'ca va se déclencher et en plus vous pouvez inspécter les variables')

Celà évite par example de devoir taper des choses lourdingues comme:

Code :

Sachant que dans les configs "Release" vous aurrez plutôt tendance à désactiver les assertions. Dailleurs, de manière général, je suis surpris à quel point les delphiistes n'utilisent pas les assertions...J'ai participé à plusieurs programmes de béta testing où les logiciels étaient littéralement "bourrés" d'assertions...

Personnellement, je trouve cette pratique plutôt barbare. Surtout dans le cas où justement dans la config release, les assertion ne sont pas désactivées par défaut.
En plus si c'est pour une dll destinée à faire uniquement des calculs, je préfère largement faire des tests unitaires.

Bonjour à tous !

Personnellement, lorsque je rajoute du code, que ce soit pour une évolution ou une correction, je rajoute ceci dans mon code


[code existant]
//----------------- <mon nom> <numero de ticket> <description rapide> -----------

[mon code]

//--------------------------------------------------------------------------------
[reste du code]

Ca permet de retrouver facilement le code en question, et je sais si c'est moi ou un collègue qui a fait la modif.

De plus, avec certains outils, le numéro de ticket peut être récupéré depuis l'outil de gestion des bugs.

Comme tu le dis si bien, il existe des tonnes d'outils. Pour te simplifier encore plus la vie et éviter l'immondisme d'avoir des commentaires qui ne servent à rien à part à savoir qui à fait une correction, il existe des outils tels que SVN pour n'en citer qu'un et qui fera certainement ton bonheur

[El0ka]

Bonjour, tous le monde !

Vous m'avez donnée envie de contribué aussi !
Pour ma part j'utilise une petite astuce que je vais vous donné :
tout d'abord je develloppe en WLanguage (Avec Windev, je debute ...)

Comment trouver retrouver facilement la cause d'une erreur ?
j'utilise des point de control placer dans le code source a divers endroit stratégique (selon la partie qui plante)

exemple :

//Control1
info("Control 1 : MaVariable="+MaVariable)

ou,

//Control2
info("Control 2 : Fichier.Donnée="+Fichier.Donnée)

Après, avoir placer mes points j'execute mon projet en mode test...

ducoup, des message s'affiche a l'ecran avec le contenu des differentes variable ou fichier de donnée... ce qui permet de retrouver une variable qui ne recupère pas la bonne valeur (par exemple) ! et de connaitre la derniere valeur appeller avant plantage ou pour vérifier qu'un compteur de boucle s'incrémente bien, ce qui peut etre la cause d'une boucle sans fin et ainsi de suite ...

bref, ce procédé m'a deja depané pas mal de situation dans lesquel je ramais !!! ^^

Lorsque je n'est plus besoin de ces points, je ne les supprime pas au cas ou !! j'ajoute simplement deux slash "/" pour qu'il soit concidéré comme des commentaire :

il me suffi alors avec la fonction Rechercher/Remplacer de Windev, de Remplacer tous les "info("Control" Par "//info("Control"

[Rayek]

Merci pour la participation de certain mais je rappel qui nous somme ici dans la section pour DELPHI
Il serait bein de ne mettre que des astuces pour cet IDE

Envoyé par El0ka

Bonjour, tous le monde !

Vous m'avez donnée envie de contribué aussi !
Pour ma part j'utilise une petite astuce que je vais vous donné :
tout d'abord je develloppe en WLanguage (Avec Windev, je debute ...)

Comment trouver retrouver facilement la cause d'une erreur ?
j'utilise des point de control placer dans le code source a divers endroit stratégique (selon la partie qui plante)

exemple :

//Control1
info("Control 1 : MaVariable="+MaVariable)

ou,

//Control2
info("Control 2 : Fichier.Donnée="+Fichier.Donnée)

Après, avoir placer mes points j'execute mon projet en mode test...

ducoup, des message s'affiche a l'ecran avec le contenu des differentes variable ou fichier de donnée... ce qui permet de retrouver une variable qui ne recupère pas la bonne valeur (par exemple) ! et de connaitre la derniere valeur appeller avant plantage ou pour vérifier qu'un compteur de boucle s'incrémente bien, ce qui peut etre la cause d'une boucle sans fin et ainsi de suite ...

bref, ce procédé m'a deja depané pas mal de situation dans lesquel je ramais !!! ^^

Lorsque je n'est plus besoin de ces points, je ne les supprime pas au cas ou !! j'ajoute simplement deux slash "/" pour qu'il soit concidéré comme des commentaire :

il me suffi alors avec la fonction Rechercher/Remplacer de Windev, de Remplacer tous les "info("Control" Par "//info("Control"

En général dans les langages évolués il y a un système de point d'arrêt qui permet de stopper le programme à des endroits que l'on a décidé et de voir l'état des variables en passant le curseur au dessus

[Fandyz]

Pour rapidement gérer l'aspect présentation (l'aspect graphique) d'un contrôle créé dynamiquement, je procède ainsi :

- je prend une fiche vide
- sur cette fiche, je dispose tous les composants dont j'ai besoin dans la disposition que je veux avoir à l'exécution
- j'affiche la fenêtre en mode texte ("clic droit sur la fiche > voir comme fiche" ou Alt + F12)
- je copie la déclaration qui m'intéresse (les déclarations des composants que je veux)
- dans la partie de mon code où je dois créer mes contrôles, je colle les déclarations que j'ai copiées
- il ne me reste plus qu'à modifier les déclarations pour qu'elles soient conformes au langage

Cette astuce me permet de rapidement retrouver toutes les modifications faites au niveau du l'inspecteur d'objet et me fait gagner du temps dans la constitution de mon rendu graphique.

[Paul TOTH]

Envoyé par Rayek

En général dans les langages évolués il y a un système de point d'arrêt qui permet de stopper le programme à des endroits que l'on a décidé et de voir l'état des variables en passant le curseur au dessus

c'est vrai, mais il est parfois plus simple de coder les conditions dans le code (et c'est souvent plus rapide à l'execution que le point d'arrêt conditionnel)

Code :

1
2
3
4
5
6
7
 
 {$IFDEF DEBUG}
  if (Index = 12) and ((PrixTotal > 5000) or (TVA < 19.6)) and FonctionChose() then
  begin
    ShowMessage('Conditions de bug réunies'); // placer un point d'arrêt ici !
  end;
 {$ENDIF}