Programmatore Migliore (Parte 06): 9 abitudini che portano a una codifica efficace

Introduzione

Prima di iniziare a programmare, ci sono alcune abitudini che dobbiamo aggiungere alla nostra programmazione che possono aiutarci a rimanere concentrati per tutto il tempo di programmazione. La maggior parte delle volte potremmo trovarci a programmare ma non renderci conto che non siamo efficaci a causa di vari motivi, come mancanza di concentrazione, mancanza di un piano o scarso piano di esecuzione.

Contenuti:

• Pianifica il tuo progetto prima della codifica
• Crea una raccolta di frammenti di codice
• Sviluppa una routine
• Pianifica i lavori intensi
• Crea piccole funzioni con un unico scopo e testale
• Aggiungi commenti al tuo io futuro
• Sviluppa abitudini di battitura tattili
• Utilizza i migliori strumenti
• Fai il controllo della versione

Disclaimer:

Tutti i frammenti di codice e gli esempi di codifica utilizzati in questo articolo sono destinati esclusivamente a scopi didattici. Alcuni di loro non sono stati accuratamente testati/oggetto di debug. Servono solo per chiarire il mio punto di vista. Se decidi di utilizzare uno qualsiasi dei codici, lo utilizzerai a tuo rischio.

01: Pianifica il tuo progetto prima della codifica

Se chiedi a 100 programmatori se pianificano i loro sistemi prima di iniziare a programmare, meno di dieci ti diranno che pianificano il loro lavoro prima di iniziare a scrivere codice sulla tastiera.

Questo è il problema principale che dobbiamo affrontare se vogliamo codificare in modo efficace.

Riesci a salire su un autobus senza avere la minima idea di dove stai andando? Assolutamente no.

Prima di iniziare a digitare il codice sulla tastiera, annota il tipo di programma di cui hai bisogno, gli strumenti, le librerie che potresti voler utilizzare al suo interno, ecc.

Ci sono delle cose chiamate specifiche di lavoro su Freelance, che sono esattamente la stessa cosa di un piano di lavoro che ogni sviluppatore deve avere prima di iniziare a programmare qualsiasi cosa.

Puoi utilizzare programmi gratuiti come Microsoft Word o WPS office per pianificare i tuoi lavori se non hai una penna, un taccuino o un pezzo di carta. Puoi disegnare diagrammi e illustrazioni per descrivere tutto ciò di cui hai bisogno.

Sono pienamente d'accordo con Charles Kettering quando ha affermato che "Un problema ben definito è risolto a metà".

Ad esempio, voglio solo creare un Simple Grid Expert Advisor con sistemi di gestione del denaro Labouchere al suo interno.

Ecco il semplice piano di lavoro.

Nota: Tutti i valori iniziali seguenti possono essere ottimizzati/sono le variabili di input

Valori iniziali: Lotsize = 0,01; xgrid = 100; LotIncrement = 0,01;

La mia strategia	Formula del lottaggio per tipo di posizione	Condizioni della griglia (Strategia ma in modo più chiaro)	Gestione del denaro	Librerie
Condizione 01: Quando non c'è posizione aperta Aprire sia la posizione di acquisto che quella di vendita (posizione singola per ogni tipo)	X = Lotsize + (LotIncrement * Numero Di Posizioni Per Tipo Di Posizione)  Esempio: BuyLotsize = 0.01 + ( 0.01 * Numero Di Posizioni Buy);	La condizione di acquisto si verifica quando il numero di posizioni di acquisto è 0 (zero) o quando esiste già una o più posizioni di acquisto e il prezzo di offerta è inferiore al prezzo di apertura dell'ultima posizione di acquisto meno xgrid</s1 > punti	StopLoss = 0 (di default)	Libreria di classi di posizioni standard Libreria di classi di informazioni sui simboli standard Libreria di classi di operazioni standardy
Condizione 02 (Condizione di vendita): se il prezzo di mercato sale di xgrid Punti dalla precedente posizione di vendita, aprire una posizione di vendita con Lotsize uguale alla precedente posizione di vendita < /s2>Lotsize Plus LotIncrement valore.		La condizione di vendita si verifica quando il numero di posizioni di vendita è 0 (zero) o quando esiste già una o più posizioni di vendita e il prezzo Ask è superiore al Prezzo di apertura dell'ultima posizione/i di vendita più </s1 >xgrid punti	TakeProfit = 100 (di default)
Condizione 03 (Condizione di acquisto): se il prezzo di mercato scende di xgrid punti dalla precedente posizione di acquisto, apri una posizione di acquisto con Lotsize uguale alla precedente Lotsize più il valore LotIncrement .

Solo dal semplice piano di lavoro, puoi vedere che è molto più facile eseguire il lavoro piuttosto che iniziare a programmare con la vaga idea di capire le cose lungo il percorso. Un piano migliore può aiutarti a identificare le aree che devi imparare o ricordare a te stesso nel caso sembri averle dimenticate.

Prima di iniziare a programmare assicurati di avere un piano ben spiegato per il tuo lavoro. Più chiaro è, meglio è

02: Crea una raccolta di frammenti di codice

Se scopri che stai definendo funzioni o classi più volte in più programmi, come Expert Advisor, indicatori o script, probabilmente avrai bisogno di una loro raccolta in modo da poterle riutilizzare più volte senza definirle più e più volte. Si può diventare in grado di farlo in modo più efficace attraverso la programmazione orientata agli oggetti (OOP).

Dall'esempio del piano di lavoro, abbiamo visto che dobbiamo creare due funzioni nel nostro EA. 

1. Una funzione per contare le posizioni per tipo
2. Una funzione per fornire il prezzo d'apertura dell'ultima posizione per tipo di posizione

Queste funzioni sono necessarie in quasi tutti i grid EA, quindi possiamo creare un file Include(.mqh) chiamato gridmodule e archiviare queste due funzioni in modo da poterle includere nel nostro file principale .mq5 .

Dentro il 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;
 }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+

Ci sono molti vantaggi che otterrai in questo modo, poiché si semplifica il debug del tuo codice: il debug deve essere eseguito in un unico posto e ti dà meno codice con cui lavorare sul tuo file .mq5< principale /b0>.

03: Sviluppa una routine

Le routine possono essere ottime per entrare nel giusto schema mentale di codifica che può essere ottimo per migliorare la tua produttività in generale. È anche il modo migliore per aiutarti a rimanere impegnato e diventare un programmatore coerente giorno per giorno.

Ad esempio, puoi avere una routine che prevede di programmare ogni giorno dalle 08:00 alle 11:00.

Quando segui la stessa routine, dopo diverse settimane o mesi noterai che la tua mente si eccita all'idea di iniziare a programmare ogni volta che ti metti al tuo PC durante quelle ore.

Crea una tabella di marcia che funzioni meglio per te.

04: Pianifica i lavori intensi

Ai giorni nostri, è molto facile essere distratti da molte cose. È difficile concentrarsi al giorno d'oggi, specialmente quando le cose si fanno difficili durante la programmazione. Nota che sono solo pochi istanti/ore del giorno in cui siamo iper-concentrati nella misura in cui diventiamo creativi.

Spesso la nostra mente ha bisogno di lavorare molto tempo senza distrazioni per arrivare a quel livello. Per essere in grado di raggiungere quello stato, dobbiamo programmare per giorni, svariate ore, senza interruzioni.

È attraverso lunghe ore di lavoro intenso che possiamo fare la maggior parte del duro lavoro che potremmo aver affrontato mentre lavoravamo sulle nostre normali routine. Consiglio a tutti i programmatori di pianificare determinati giorni in cui si lavorerà sodo e senza distrazioni.

05: Crea piccole funzioni con un unico scopo e testale

Evita di avere troppe operazioni all'interno di una funzione. Prendi in considerazione la creazione di un'altra funzione ogni volta che ti rendi conto che devi programmare per un'operazione importante.

Avere troppi loop nella funzione Ontick (o in qualsiasi altra funzione maggiore o minore) ti danneggerà in men che non si dica. È come tirare fuori lo spillo di una bomba a mano che tieni in tasca.

Forzare semplici algoritmi a diventare complessi costringendo tutta la logica a comparire in un unico posto è uno dei modi migliori per creare bug che ti costeranno denaro e la risorsa più preziosa della tua vita, il Tempo..

Credo che la programmazione debba essere divertente per la maggior parte del tempo, in modo che possiamo essere in grado di farlo in modo coerente. Non c'è divertimento negli algoritmi contorti, non importa quanto esperto e intelligente sia qualcuno che sta leggendo il codice. Assicurati che ogni funzione esegua un'operazione e che per di più abbia un nome facile da leggere e che faccia capire di cosa tratta la funzione.</s2 >

Dai un'occhiata alla funzione CountPositions con un argomento per il tipo di posizione dell'esempio precedente:

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;
 }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+

Solo guardando il nome della funzione, tutti possono dire che la funzione riguarda il conteggio delle posizioni in base al loro tipo, ed è quello che è stato fatto all'interno della funzione, niente di più niente di meno.

06: Aggiungi commenti al tuo io futuro

La semplice abitudine di aggiungere commenti al codice può essere vista come un modo prematuro di codificare. Ma può essere un punto di svolta per coloro che sanno come usarlo in modo efficace.

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 maggior parte delle variabili, delle funzioni e dei frammenti di codice che scrivi ora saranno dimenticati nel giro di alcune settimane o addirittura giorni. Senza commenti significativi, non avrai familiarità con il codice che hai scritto in precedenza (pensa a quanto è stupido!!).

L'aggiunta di commenti su MQL5 consentirà all'IDE MetaEditor di aiutarti a ricordare più facilmente ogni volta che lo desideri.

Perché rendere più difficile per MetaEditor aiutarti? Questo non ha senso per me.

Tieni presente che non sei solo in questa carriera, quindi vuoi sempre avere il codice che può essere facilmente passato e utilizzato da altri sviluppatori sulla base di codice o qualcosa del genere e l'unico modo per farlo è avere < i0>codice di facile lettura e comprensione reso possibile dai commenti.

07: Sviluppa abitudini di battitura tattili

Non dimentichiamo che per programmare in modo efficace bisogna diventare bravi scrittori sulla tastiera. Ogni programmatore deve sforzarsi di sviluppare e migliorare le proprie capacità di digitazione sulla tastiera. Il modo migliore per diventare bravo a digitare il codice è sviluppare un'abitudine di digitazione tattile: l'abitudine di battere le lettere corrette sulla tastiera senza effettivamente guardare la tastiera.

La maggior parte delle volte tendiamo a programmare guardando la tastiera e lo schermo contemporaneamente senza renderci conto che è una forma di digitazione inesperta.

Devi interrompere l'abitudine di digitazione hunt-and-peck e allenarti a digitare senza guardare la tastiera (guardando solo lo schermo). Questo è possibile attraverso la digitazione della memoria muscolare.

È un po' difficile sviluppare questa abitudine, ma una volta sviluppata la digitazione diventa una pratica automatizzata.

Sono stato in grado di sviluppare questa abitudine dopo diverse settimane di pratica su un sito gratuito chiamato keybr.com, che è il miglior sito che consiglio a tutti coloro che vogliono sviluppare questa abitudine.

08: Utilizza i migliori strumenti 

Gli strumenti possono essere una parte importante per migliorare la tua produttività complessiva come programmatore e non posso sottolinearlo abbastanza. Hai bisogno di strumenti migliori se non dei migliori in assoluto (sia hardware che software).

Assicurati sempre di utilizzare le migliori librerie (consiglio le librerie standard MQL5). Devi anche avere le migliori fonti di informazioni quando sei bloccato e quando hai bisogno di imparare e provare cose nuove (leggi questo articolo per maggiori dettagli) e per di più è necessario un PC ben funzionante e una buona connessione a Internet.

09: Esegui il controllo della versione

Ti è mai capitato mentre stavi codificando un programma, quindi dopo aver apportato diverse modifiche, di renderti conto per qualche motivo di voler tornare al codice che hai scritto in precedenza?

È sempre una buona abitudine avere il controllo della versione del tuo codice in modo da poter tenere traccia dei tuoi progressi e poter tornare alle versioni precedenti del codice ogni volta che vuoi.

Conosco due modi per farlo. Il primo utilizza Git e il secondo modo è un processo manuale che prevede la copia e incolla dei metodi di memorizzazione del codice attraverso un file di testo.

Usare Git

Questo è un modo non rapido che posso insegnarti in pochi minuti se non hai familiarità con Git e Github, ti consiglio di leggere la documentazione di Git.

Attraverso un file di testo

Crea una cartella per il tuo progetto, aggiungi tutti i file necessari necessari a quel progetto. Quindi apri quella cartella in Esplora file per visualizzare cosa c'è (vedi l'immagine qui sotto dal mio esempio precedente).

Dopo aver apportato una modifica importante al tuo like .mq5, aggiungendo una nuova funzione, devi creare un file di testo con un nome che specifichi la versione del codice e cosa è stato aggiunto. Guarda l'immagine

Puoi aprire un file di testo insieme al file .mq5 o .mqh principale e salvarli entrambi con un clic CTRL+F7 in Windows, che compilerà tutti i file aperti sul tuo editor. Dopo una compilazione riuscita, puoi ignorare tutti gli errori provenienti da quel file di testo e chiuderlo.

Conclusione

Questo è tutto per questo articolo. Spero che tu abbia guadagnato qualcosa di positivo per fare un ulteriore passo avanti per diventare un programmatore migliore. Se hai delle perle di saggezza che qui mancano, condividile con me e altri programmatori nella sezione di discussione qui sotto. Di seguito in allegato tutto il codice utilizzato in questo articolo.

Grazie per aver letto.