Better Programmer (Part 06) : 9 habitudes qui mènent à un codage efficace

Introduction

Avant de commencer à coder, il y a certaines habitudes que nous devons ajouter à notre codage qui peuvent nous aider à rester concentrés tout le temps de codage. La plupart du temps, nous pouvons nous retrouver à coder sans réaliser que nous ne sommes pas efficaces pour diverses raisons, telles que le manque de concentration, l'absence de plan ou un mauvais plan d'exécution.

Contenu :

• Planifier votre projet avant de coder
• Créer une collection de snippets de code
• Ayez une routine
• Planifier des travaux en profondeur
• Créez de petites fonctions à usage unique et testez-les
• Ajoutez des commentaires à votre futur moi
• Habitude de frappe tactile
• Utiliser les meilleurs outils
• Utiliser le contrôle de version

Avertissement :

Tous les fragments de code et exemples de codage utilisés dans cet article sont uniquement destinés à des fins éducatives. Certains d'entre eux n'ont pas été soigneusement testés/débogués. Ils sont juste utilisés pour clarifier mon propos. Si vous décidez d'utiliser l'un des codes, vous l'utiliserez à vos risques et périls.

01 : Planifier votre projet avant de coder

Si vous demandez à 100 programmeurs s'ils planifient leurs systèmes avant de commencer à coder, moins de dix vous diront qu'ils planifient leur travail avant de commencer à écrire du code sur le clavier.

C'est le problème majeur que nous devons résoudre si nous voulons coder efficacement.

Pouvez-vous sauter dans un train sans savoir où vous allez ? Absolument pas.

Avant de commencer à taper du code sur le clavier, notez le type de programme dont vous avez besoin, les outils, les bibliothèques que vous voudrez peut-être utiliser à l'intérieur, etc.

Il existe quelque chose appelé spécifications de travail sur Freelance, qui est exactement la même chose qu'un plan de travail que chaque développeur doit avoir avant de commencer à coder quoi que ce soit.

Vous pouvez utiliser des programmes gratuits tels que Microsoft Word ou WPS office pour planifier vos travaux si vous n'avez pas de stylo et de cahier ou de feuille de papier. Vous pouvez dessiner des diagrammes et des illustrations pour décrire tout ce dont vous avez besoin.

Je suis tout à fait d'accord avec Charles Kettering lorsqu'il dit que "Un problème bien posé est à moitié résolu".

Par exemple, je veux juste créer un Expert Advisor Simple Grid avec un système de gestion de l'argent Labouchere.

Voici le plan de travail simple.

Remarque : Toutes les valeurs initiales ci-dessous peuvent être optimisées/sont les variables d'entrée

Valeurs initiales : Lotsize = 0,01 ; xgrid = 100 ; LotIncrement = 0,01 ;

Ma stratégie	Formule de Lotsize par Type de Position	Conditions de grille (Stratégie mais de manière plus claire)	Gestions Financières	Bibliothèques
Condition 01 : Lorsqu'il n'y a pas de position ouverte Ouvrir les positions d'achat et de vente (une seule position pour chaque type)	X = Lotsize + (LotIncrement * Nombre de Positions par Type de Position)  Exemple : BuyLotsize = 0,01 + ( 0,01 * Nombre de positions d'achat) ;	La condition d'achat se produit lorsque le nombre de positions d'achat est de 0 (zéro) ou lorsqu'il existe déjà une ou plusieurs positions d'achat et que le prix de l'offre est inférieur au prix d'ouverture de la dernière position d'achat moins xgrid points	StopLoss = 0 (par défaut)	Bibliothèque Standard de Classes de Positions Bibliothèque Standard de Classes d'Information des Symboles Bibliothèque Standard de Classes des Trades
Condition 02 (condition de vente) : si le prix du marché augmente de xgrid points par rapport à la position de vente précédente, ouvrez une position de vente avec une taille de lot égale à la position de vente précédente Lotsize Plus valeur de LotIncrement.		La condition de vente se produit lorsque le nombre de positions de vente est de 0 (zéro) ou lorsqu'il existe déjà une ou plusieurs positions de vente et que le prix de vente est supérieur à la dernière position de vente Prix d'ouverture plus xgrid points	TakeProfit = 100 (par défaut)
Condition 03 (condition d'achat) : si le prix du marché baisse de xgrid points par rapport à la position d'achat précédente, ouvrez une position d'achat avec Lotsize égal à la valeur Lotsize plus LotIncrement précédente.

Rien qu'à partir du plan de travail simple, vous pouvez voir qu'il est beaucoup plus facile d'exécuter le travail plutôt que de commencer à coder avec le vague état d'esprit de comprendre les choses en cours de route. Une meilleure planification peut vous aider à identifier les domaines que vous devez apprendre ou à vous rappeler au cas où vous sembleriez les avoir oubliés.

Avant de commencer à coder, assurez-vous d'avoir un plan bien expliqué pour votre travail. Plus c'est clair mieux c'est

02 : Créer une collection de snippets de code

Si vous constatez que vous définissez plusieurs fois des fonctions ou des classes dans plusieurs programmes, tels que des Expert Advisors, des indicateurs ou des scripts, vous avez probablement besoin d'une collection d'entre eux afin de pouvoir les réutiliser plusieurs fois sans les définir encore et encore. . Pour pouvoir le faire le plus efficacement possible, utilisez la programmation orientée objet (POO).

Dans l'exemple du plan de travail, nous avons vu que nous devons créer deux fonctions dans notre EA. 

1. Une fonction pour compter les positions par leur type
2. Une fonction pour fournir le prix d'ouverture de la dernière position par type de position

Ces fonctions sont nécessaires dans presque tous les EA de grille afin que nous puissions créer un fichier Include (.mqh) appelé gridmodule et y stocker ces deux fonctions que nous pouvons inclure dans notre fichier .mq5 principal.

Dans gridmodule.mqh

//+------------------------------------------------------------------+
//|                                                  gridmodule.mqh |
//|                                     Copyright 2021, Omega Joctan |
//|                        https://www.mql5.com/en/users/omegajoctan |
//+------------------------------------------------------------------+
#property copyright "Copyright 2021, Omega Joctan"
#property link      "https://www.mql5.com/en/users/omegajoctan"
//+------------------------------------------------------------------+
//| Libraries                                                        |
//+------------------------------------------------------------------+ 
#include <Trade\PositionInfo.mqh>
#include <Trade\SymbolInfo.mqh>

CSymbolInfo   m_symbol;
CPositionInfo m_position;
//+------------------------------------------------------------------+
//| DLL imports                                                      |
//+------------------------------------------------------------------+
class CGrid
  {
   protected:
     int                   MagicNumber;
  
   public:
                           CGrid(void);
                          ~CGrid(void);
      void                 InitializeModule(int magic) { MagicNumber = magic; }
      double               LastPositionOpenPrice(ENUM_POSITION_TYPE type);
      int                  CountPositions(ENUM_POSITION_TYPE type);
   
  };
//+------------------------------------------------------------------+
//|               Constructor                                        |
//+------------------------------------------------------------------+
CGrid::CGrid(void)
 {
 
 }
//+------------------------------------------------------------------+
//|                Destructor                                        |
//+------------------------------------------------------------------+
CGrid :: ~CGrid(void)
 {
 
 }
//+------------------------------------------------------------------+
//|           Last Position Open Price By Position Type              |
//+------------------------------------------------------------------+
double CGrid::LastPositionOpenPrice(ENUM_POSITION_TYPE type)
 {
  double LastPrice = -1;
  ulong  LastTime = 0; 
   for (int i=PositionsTotal()-1; i>=0; i--)
     if (m_position.SelectByIndex(i))
       if (m_position.Magic() == MagicNumber && m_position.Symbol()==Symbol() && m_position.PositionType()==type)
          {
             ulong positionTime = m_position.TimeMsc();
             if ( positionTime > LastTime ) //FInd the latest position
               {
                  LastPrice = m_position.PriceOpen();
                  LastTime = m_position.TimeMsc();
               }
          }
       return LastPrice;
 }
//+------------------------------------------------------------------+
//|                Count Positions By Type                           |
//+------------------------------------------------------------------+
int CGrid::CountPositions(ENUM_POSITION_TYPE type)
 {
   int counter = 0; //variable to store our positions number
   for (int i=PositionsTotal()-1; i>=0; i--)
     if (m_position.SelectByIndex(i)) // Select position by its index
        if (m_position.Magic() == MagicNumber && m_position.Symbol() == Symbol() && m_position.PositionType() == type)
          {
            counter++; 
          }
      return counter;
 }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+

Vous obtiendrez de nombreux avantages en procédant ainsi, car cela facilite le débogage de votre code : le débogage doit être effectué à un seul endroit et cela vous permet d'avoir moins de code dans votre fichier .mq5 principal. fichier.

03 : Ayez une routine

Les routines peuvent être excellentes pour mettre votre esprit dans le bon état d'esprit de codage, ce qui peut être excellent pour améliorer votre productivité en général. C'est également le meilleur moyen de vous aider à rester engagé et à devenir un programmeur régulier au quotidien.

Par exemple, vous pouvez avoir une routine pour coder tous les jours de 08h00 à 11h00.

Lorsque vous vous en tenez à la même routine, après plusieurs semaines ou mois, vous remarquerez que votre esprit s'excite à commencer à coder chaque fois que vous montez sur votre PC pendant ces heures.

Créez un emploi du temps qui vous convient le mieux.

04 : Programmer des travaux en profondeur

De nos jours, il est si facile de se laisser distraire par beaucoup de choses. Il est difficile de se concentrer de nos jours, surtout lorsque les choses deviennent difficiles lors du codage. Notez que ce n'est que pendant quelques instants/heures de la journée que nous sommes hyper-concentrés dans la mesure où nous devenons créatifs.

Souvent, notre esprit a besoin de beaucoup de temps pour travailler sans distractions pour atteindre ce niveau. Pour pouvoir arriver à cet état, nous devons planifier des jours de longues heures de codage non-stop.

C'est grâce à de longues heures de travail en profondeur que nous pouvons faire la majorité du travail auquel nous aurions été confrontés en travaillant sur nos routines régulières. Je recommande à chaque codeur de planifier certains jours où vous travaillerez dur et sans distractions.

05 : Créez des fonctions à usage unique et testez-les

Evitez d'avoir trop d'opérations dans une seule fonction. Envisagez de créer une autre fonction chaque fois que vous réalisez que vous devez coder une nouvelle opération.

Avoir trop de boucles dans la fonction Ontick (ou dans toute autre fonction majeure ou mineure) vous nuira en un rien de temps. C'est comme retirer la goupille d'une grenade à main que vous gardez dans vos poches.

Forcer des algorithmes simples à devenir complexes en forçant toute la logique à apparaître au même endroit est l'un des meilleurs moyens de créer des bugs qui vous coûteront de l'argent et la ressource la plus précieuse de votre vie, le temps.

Je pense que le codage doit être amusant la plupart du temps, afin que nous puissions le faire de manière cohérente. Il n'y a pas de plaisir dans les algorithmes alambiqués, peu importe l'expérience et l'intelligence de quelqu'un qui lit le code. Assurez-vous que chaque fonction effectue une opération et, qu'en plus, elle ait un nom facile à lire et permettant de comprendre en quoi elle consiste .

Examinez la fonction CountPositions avec un argument pour le type de position de l'exemple précédent :

int CGrid::CountPositions(ENUM_POSITION_TYPE type)
 {
   int counter = 0; //variable to store our positions number
   for (int i=PositionsTotal()-1; i>=0; i--)
     if (m_position.SelectByIndex(i)) // Select position by its index
        if (m_position.Magic() == MagicNumber && m_position.Symbol() == Symbol() && m_position.PositionType() == type)
          {
            counter++; 
          }
      return counter;
 }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+

Rien qu'en regardant le nom de la fonction, tout le monde peut dire que la fonction consiste à compter les positions par leur type, et c'est ce qui a été fait à l'intérieur de la fonction, rien de plus rien de moins.

06 : Ajoutez des commentaires pour votre futur moi

La simple habitude d'ajouter des commentaires à votre code peut être considérée comme une façon prématurée de coder. Mais cela peut changer la donne pour ceux qui savent l'utiliser efficacement.

input    group        "Money management"
input    double       InitialLots = 0.01; //Initial position volume
input    int          EquityUse = 50;  // Percentage of equity to be used in all trading operations
input    group        "Average True Range";
input    int          AtrBarSignal = 1; //Atr value will be calculation taken from this candle

La plupart des variables, fonctions et extraits de code que vous écrivez maintenant seront oubliés par vous dans plusieurs semaines, voire plusieurs jours. Sans commentaires significatifs, vous ne serez pas familier avec le code que vous avez écrit plus tôt (pensez à quel point c'est stupide !!).

L'ajout de commentaires dans MQL5 permettra à l'IDE MetaEditor de vous aider à vous en souvenir plus facilement chaque fois que vous voudrez l'utiliser.

Pourquoi compliquer la tâche de MetaEditor qui peut vous aider ? Cela n'a aucun sens pour moi.

Gardez à l'esprit que vous n'êtes pas seul dans cette carrière, donc vous voulez toujours avoir le code qui peut être facilement transmis et utilisé par d'autres développeurs sur la base de code ou ailleurs, et la seule façon de le faire est d'avoir du code facile à lire et à comprendre, rendu possible par les commentaires.

07 : Habitude de saisie tactile

N'oublions pas que pour coder efficacement, nous devons devenir de bons écrivains au clavier. Chaque codeur doit s'efforcer de développer et d'améliorer ses capacités de frappe au clavier. La meilleure façon pour vous de devenir bon en dactylographie est de développer une habitude de frappe tactile : une habitude de taper les lettres correctes sur le clavier sans vraiment regarder le clavier.

La plupart du temps, nous avons tendance à coder tout en regardant le clavier et l'écran en même temps sans nous rendre compte qu'il s'agit d'une forme de frappe inexperte.

Vous devez rompre avec l'habitude de taper chasse et picorer et vous entraîner à taper en ne regardant pas le clavier (en regardant uniquement l'écran). Ceci est possible grâce au typage de la mémoire musculaire.

Il est un peu plus difficile de développer cette habitude, mais une fois que vous l'avez développée, la dactylographie devient une pratique automatisée.

J'ai pu développer cette habitude après plusieurs semaines de pratique sur un site gratuit appelé keybr.com, qui est le meilleur site que je recommande à tous ceux qui souhaitent développer cette habitude.

08 : Utilisez les meilleurs outils 

Les outils peuvent être un élément important pour améliorer votre productivité globale en tant que programmeur et je ne saurais trop insister là-dessus pour dire que vous avez besoin de meilleurs outils, sinon des meilleurs (à la fois matériels et logiciels).

Assurez-vous toujours que vous utilisez les meilleures bibliothèques (je recommande les bibliothèques standard MQL5), vous devez également disposer des meilleures sources d'informations lorsque vous êtes bloqué et lorsque vous avez besoin d'apprendre et d'essayer de nouvelles choses (lisez cet article pour plus de détails) et en plus de tout cela, vous avez besoin d'un PC performant et d'une bonne connexion Internet.

09 : Utiliser le contrôle de version

Cela vous est-il déjà arrivé, alors que vous codiez un programme, puis après avoir fait plusieurs changements, pour une raison quelconque, de vous rendre compte que vous voulez revenir au code que vous aviez écrit plus tôt ?

C'est toujours une bonne habitude d'avoir un contrôle de version pour votre code afin que vous puissiez suivre votre progression et pouvoir revenir aux versions précédentes du code quand vous le souhaitez.

Je connais deux façons de procéder. La première utilise Git et la seconde est un processus manuel qui consiste à copier et coller du code dans un fichier texte.

Utiliser Git

C'est une solution rapide que je peux vous apprendre en quelques minutes si vous n'êtes pas familier avec Git et Github, je vous recommande de lire la documentation Git.

Via un fichier texte

Créez un dossier pour votre projet, ajoutez tous les fichiers nécessaires à ce projet. Ouvrez ensuite ce dossier dans votre explorateur de fichiers pour voir ce qu'il y a dans le dossier (voir l'image ci-dessous de mon exemple précédent).

Après avoir apporté une modification majeure à votre fichier .mq5 comme l'ajout d'une nouvelle fonction, vous devez créer un fichier texte avec un nom spécifiant la version du code et ce qui a été ajouté. Voir l'image

Vous pouvez ouvrir un fichier texte à côté du fichier principal .mq5 ou .mqh et les enregistrer tous les deux en un seul clic CTRL+F7 dans Windows, ce qui compilera tous les fichiers ouverts sur votre éditeur. Après une compilation réussie, vous pouvez ignorer toutes les erreurs provenant de ce fichier texte et le fermer.

Conclusion

Voilà pour cet article. J'espère que vous avez appris quelque chose de positif pour vous faire avancer d'un pas pour devenir un meilleur programmeur. S'il vous manque des informations, partagez-les avec moi et d'autres programmeurs dans la section de discussion ci-dessous. Tous les codes utilisés dans cet article sont joints ci-dessous.

Merci pour la lecture, meilleures salutations.