Programmatore Migliore (Parte 04): Come diventare uno sviluppatore più veloce

Introduczione

Uno sviluppo più rapido è il sogno di ogni programmatore. Nessuno vuole sviluppare un programma o un pezzo di codice per tutta la settimana o passare interminabili ore, se non giorni, a cercare di capire le cose quando si rimane bloccati nel processo di codifica.

Ogni programmatore vuole essere più veloce

• Probabilmente hai guardato il video di codifica MQL5 su YouTube ed è stato difficile da seguire perché sei troppo lento per stare al passo con la velocità dell'istruttore e desideri raggiungere quel livello da solo.
• Forse hai visto alcuni sviluppatori con una magnifica velocità di codifica sulla tastiera, in grado di scrivere un algoritmo complesso in pochi minuti che potrebbero richiedere ore se non giorni per programmare.
• O forse vorresti essere in grado di programmare in modo più rapido ed efficace, in modo da poter fornire lavori più velocemente su Freelance ed essere un passo avanti rispetto alla concorrenza.
• O forse vorresti impressionare il tuo coniuge/partner con le tue abilità da superuomo sulla tastiera programmando, con meno o nessun bug, algoritmi complessi in un breve lasso di tempo.
  
• A volte potresti voler essere in grado di fornire aggiornamenti rapidi per i prodotti del Market e correggere bug ed errori che i tuoi clienti ti hanno inviato in spam o nella posta in arrivo dei messaggi MQL5.

Presta attenzione e porta la penna e il taccuino vicino a te perché sto per elargire perle di conoscenza su come aumentare la velocità di codifica, producendo un lavoro di alta qualità per te e il tuo cliente.

Non hai bisogno di niente del generei per raggiungere la tua massima velocità di codifica potenziale

• Ampia esperienza di codifica
• La migliore tastiera meccanica
• Per essere bravo a digitare sulla tastiera muscle memory
• Molti gigabyte di RAM, molti core, una potente GPU sul tuo personal computer(PC)

Sviluppatore più veloce vs Codificatore più veloce

Prima di iniziare, penso sia meglio spiegare la differenza tra uno Sviluppatore e un Codificatore.

Sviluppatore

Codificatore

Gli sviluppatori sono scrittori di codice più esperti. Sono responsabili di praticamente tutto nel progetto, come: Design, pianificazione del lavoro, codifica e tutto ciò che riguarda il progetto.

Chiunque sia in grado di scrivere del codice viene spesso definito un codificatore dalle persone al di fuori del settore tecnologico. Ma, di solito, i codificatori sono considerati il livello meno addestrato o esperto dei programmatori (sviluppatori). Questi individui non hanno le stesse conoscenze algoritmiche di un programmatore o sviluppatore, poiché spesso sono principianti nel campo, esperti in un solo linguaggio di programmazione. Ai codificatori viene solitamente affidato il compito di scrivere pezzi di codice che possono essere facilmente delegati dagli sviluppatori. Da codificatore non è necessario sapere tutto all'interno del progetto. Ad esempio, un cliente del servizio freelance potrebbe voler aggiungere una funzione Trailing Stop all'interno del suo EA. Un codificatore può facilmente andare a codificarlo, chiamarlo all'interno della funzione Ontick quindi testarlo una o due volte su MetaTrader 5 per assicurarsi che funzioni. Se lo fa lo rispedisce al cliente<br3 />

In questo articolo, discuteremo del termine più ampio di sviluppatore — di come puoi diventare più veloce nello sviluppo dei tuoi sistemi. Studieremo tutto tra design, etica del lavoro, strumenti da utilizzare, codifica, debugging, ecc. 

COME DIVENTARE PIÙ VELOCE COME SVILUPPATORE

01: Evita bug e una cattiva architettura

Gli sviluppatori pensano di trascorrere molto tempo a scrivere codice, ma in realtà trascorriamo la maggior parte del nostro tempo a leggere codice, eseguire il debug e capire cosa fare.

Potrebbero essere necessarie tre ore per eseguire il debug di un pezzo di codice che hai codificato per 30 minuti, quindi più bug hai più tempo ci vorrà per completare la codifica del tuo progetto. Ora sai che i bug rallentano il nostro processo di sviluppo. Quindi, la cosa migliore da fare per noi è evitarli il prima possibile.

Cattiva Architettura + Bug = parla della fine del mondo (sto scherzando)

Avere bug nel tuo progetto è negativo, ma non riuscire a eseguirne il debug o individuarli facilmente solo a causa di una cattiva architettura è ancora peggio. Basta guardare questo pezzo di codice preso da un EA che mi è stato dato da qualcuno per correggere i bug.

ouble NPB=ND(m_account.Balance()*PortionPC,2);
if(CbT==0||PortChange<0||(PortChange>0&&NPB>PortionBalance))PortionBalance=NPB;
if(Pb+Ph<0)DrawDownPC=-(Pb+Ph)/PortionBalance;
if(!FirstRun&&DrawDownPC>=MaxDDPercent/100)
{       ET(A,displayColorLoss,"Equity Stop Loss Reached");
        if(PlaySounds)PlaySound(AlertSound);
        return(0);
}
if(-(Pb+Ph)>MaxDD)MaxDD=-(Pb+Ph);
MaxDDPer=MathMax(MaxDDPer,DrawDownPC*100);
if(SaveStats)Stats(false,TimeCurrent()<NextStats,PortionBalance,Pb+Ph);

//+-----------------------------------------------------------------+
//|                                                                 |
//+-----------------------------------------------------------------+
double StepAB=InitialAB*(1+StopTradePercent),StepSTB=m_accout.Balance()*(1-StopTradePercent), NextISTB=StepAB*(1-StopTradePercent);
if(StepSTB>NextISTB){   InitialAB=StepAB;
        StopTradeBalance=StepSTB;       }
        
double InitPortion=StopTradeBalance*PortionPC;
if(PortionBalance<InitPortion)
{       if(CbT==0)
 {      AllowTrading=false;
        if(PlaySounds)PlaySound(AlertSound);
        Print("Portion Balance dropped below stop trade percent");
        MessageBox("Reset EA, account balance dropped below stop trade percent on "+Symbol()+Period()," Warning",48);
        return(0); }
        else if(!ShutDown&&!RecoupClosedLoss)
        {       ShutDown=true; if(PlaySounds)PlaySound(AlertSound);
                Print("Portion Balance dropped below stop trade percent");
                return(0);              }
}

Guarda quanto è pessima l'architettura. Non c'è da stupirsi che ci siano bug nel codice. Come puoi vedere, il codice è difficile da capire facilmente a prima vista, anche se sei quello che ha scritto il codice in primo luogo.

Sarai così sfortunato (proprio come me), se qualcuno ti assume come freelance per correggere i bug, vedrai più di 10000 righe di codice tutte come il codice sopra (sono passate più di 3 settimane ora e non ho ancora finito).

Il mio punto qui è come segue. Sii sempre coerente con i tuoi schemi di codifica, con il modo in cui denomini le funzioni, crei variabili e così via, scegli quella con cui ti senti a tuo agio e assicurati che siano facili da usare per te e per tutti gli altri.

02: : Impara a eseguire il debug velocemente

Abbiamo visto nel primo punto che i bug ci rallentano e si nutrono del nostro tempo. Il debug è un argomento lungo da trattare in questo articolo. Consiglio a tutti di leggere l'articolo Debug dei programmi MQL5 per saperne di più sul debug.

Per essere veloci, dobbiamo imparare a eseguire il debug molto rapidamente, ecco alcuni dei suggerimenti rapidi.

01: Usa il MetaEditor CodeStyler .

È come fare dei piccoli passi verso il debug, questo straordinario strumento non può eseguire il debug da solo ma può aiutare a modificare l'aspetto del nostro codice e renderlo chiaro e facile da leggere.

02: Stampa e Commenta more.

Per scoprire cosa non funziona, dobbiamo stampare e commentare più codice in aree sospette.

Trova sempre i bug in aree in cui non possono essere trovati.

03: Non cercare di cambiare nulla prima di aver capito chiaramente come funziona.

Sono sicuro che a volte ti sia successo, dopo aver eliminato un pezzo di codice in modo da poter far funzionare il tuo sistema, di renderti conto che il codice eliminato non aveva nulla a che fare con i bug del tuo sistema, e di dover codificare di nuovo, senza alcuna garanzia di non esporre il tuo sistema ad altri bug lungo il processo. 

Prima di eliminare qualcosa, leggi sulla documentazione se si tratta di una funzione incorporata o di un metodo. Se non sei sicuro, chiedi informazioni sul forum. Personalmente, quando non sono sicuro della cosa giusta da fare, copierei tutto il codice in un file di testo in modo da poter essere flessibile e poter cambiare codice e testare nuove cose. Tornerei al codice principale solo dopo aver scoperto qual era l'errore.

03: Le Librerie vengono create per usi specifici

Quando si lavora con una libreria è essenziale utilizzare le classi fornite per lo scopo previsto. Cercare di forzare le cose perché siamo troppo pigri per implementare qualcosa di pulito è una via sicura per il disastro.

Se stai utilizzando la Libreria standard, è buona norma creare un'istanza e fare riferimento ai membri della libreria in modo chiaro, facile, coerente e probabilmente il modo consigliato dagli sviluppatori di librerie professionisti.

Ad esempio, invece di fare riferimento alla libreria Classi di trade in modi pigri e con nomi poco chiari che non sono nemmeno coerenti proprio come questo,

#include <Trade\AccountInfo.mqh> //Class for working with trade account properties
#include <Trade\SymbolInfo.mqh>  //Class for working with trade instrument properties
#include <Trade\OrderInfo.mqh>   //Class for working with pending order properties
#include <Trade\OrderHistoryInfo.mqh>  //Class for working with history order properties
#include <Trade\PositionInfo.mqh>   //Class for working with open position properties
#include <Trade\DealInfo.mqh>       //Class for working with history deal properties
#include <Trade\Trade.mqh>          //Class for trade operations execution
#include <Trade\TerminalInfo.mqh>   //Class for getting the properties of the terminal environment
//--- 
CAccountInfo       ac;
CSymbolInfo        symb;
COrderInfo         orders;
CHistoryOrderInfo  hist_orders;
CPositionInfo      pos;
CDealInfo          _clos;
CTrade             my_trade;
CTerminalInfo      info;

chiama tutte le biblioteche in modo coerente e di facile comprensione. Il modo migliore per farlo è fare riferimento a Classe formato membro di riferimento m_*** -sta per membri di un certa classe

proprio così,

#include <Trade\AccountInfo.mqh> //Class for working with trade account properties
#include <Trade\SymbolInfo.mqh>  //Class for working with trade instrument properties
#include <Trade\OrderInfo.mqh>   //Class for working with pending order properties
#include <Trade\OrderHistoryInfo.mqh>  //Class for working with history order properties
#include <Trade\PositionInfo.mqh>   //Class for working with open position properties
#include <Trade\DealInfo.mqh>       //Class for working with history deal properties
#include <Trade\Trade.mqh>          //Class for trade operations execution
#include <Trade\TerminalInfo.mqh>   //Class for getting the properties of the terminal environment
//--- 
CAccountInfo       m_account;  //members of account info
CSymbolInfo        m_symbol;   //members of symbolInfo
COrderInfo         m_order;    //mambers of OrderInfo
CHistoryOrderInfo  m_orderhistory; //members of Orderhistory info
CPositionInfo      m_position; //members of position info
CDealInfo          m_deal;     //members of deal info
CTrade             m_trade;    //members of trade info
CTerminalInfo      m_terminal; //members of terminal info

Inoltre, non dimenticare di inserire i commenti alla fine del riferimento della libreria in modo da ricordarti di cosa tratta la prossima volta che proverai ad accedervi durante la codifica. 

Inoltre, per accelerare la nostra capacità di codificare, dovremmo preferire l'utilizzo di librerie standard già pronte per gestire i nostri compiti piuttosto che provare a implementare tutto da zero. Queste librerie sono state create da programmatori professionisti per rendere il nostro codice MQL5 ASCIUTTO (non ripeterti) e per velocizzare il processo di sviluppo. Incoraggio tutti a usarli, per non parlare di altre buone librerie disponibili sul codebase e alcune sul Market. 

Chi pensi che codifichi più velocemente tra questi due;

Tutto da Scratch Coder (probabilmente un novellino)

Libreria standard di utente Codificatore

double SymbolAsk(string symbol) {         if (symbol == "") symbol = Symbol();         return SymbolInfoDouble(symbol, SYMBOL_ASK); } double SymbolBid(string symbol) {         if (symbol == "") symbol = Symbol();         return SymbolInfoDouble(symbol, SYMBOL_BID); } int SymbolDigits(string symbol) {         if (symbol == "") symbol = Symbol();         return (int)SymbolInfoInteger(symbol, SYMBOL_DIGITS); } double SymbolLotSize(string symbol) {         if (symbol == "") symbol = Symbol();         return SymbolInfoDouble(symbol, SYMBOL_TRADE_CONTRACT_SIZE); } double SymbolLotStep(string symbol) {         if (symbol == "") symbol = Symbol();         return SymbolInfoDouble(symbol, SYMBOL_VOLUME_STEP); } double SymbolMaxLot(string symbol) {         if (symbol == "") symbol = Symbol();         return SymbolInfoDouble(symbol, SYMBOL_VOLUME_MAX); } double SymbolMinLot(string symbol) {         if (symbol == "") symbol = Symbol();         return SymbolInfoDouble(symbol, SYMBOL_VOLUME_MIN); }

#include <Trade\SymbolInfo.mqh> CSymbolInfo   m_symbol; input string Input_symbol = "EURUSD"; //+------------------------------------------------------------------+ //| Expert initialization function                                   | //+------------------------------------------------------------------+ int OnInit()   { //---      string symbol = Input_symbol=="" ? Symbol() : Input_symbol;       m_symbol.Name(symbol); //Sets symbol name for our CSymbolInfo class object //---    return(INIT_SUCCEEDED);   } //+------------------------------------------------------------------+ //| Expert tick function                                             | //+------------------------------------------------------------------+ void OnTick()   { //---       m_symbol.RefreshRates(); //Refresh to Get the Last quote       double    SymbolAsk = m_symbol.Ask();       double    SymbolBid = m_symbol.Bid();       double    SymbolDigits = m_symbol.Digits();       double    SymbolLotSize = m_symbol.ContractSize();       double    SymbolLotStep = m_symbol.LotsStep();       double    SymbolMaxLot = m_symbol.LotsMax();       double    SymbolMinLot = m_symbol.LotsMin();   }

Gli utenti della libreria standard sono 3 volte più produttivi rispetto ai non utenti e per non parlare del fatto che hanno meno codice nei loro programmi, il che significa meno bug.<

04: Evita codice contorto

Spero che nella tua carriera di programmatore tu abbia visto qualcosa di simile al codice qui sotto nell'EA di qualcuno

        if(LbT>0)
        {       BEb=ND(BEb/LbT,Digits());
                if(BCa<0)BEb-=ND(BCa/PipVal2/(LbB-LbS),Digits());
                if(Pb>PbMax||PbMax==0)PbMax=Pb;
                if(Pb<PbMin||PbMin==0)PbMin=Pb;
                if(!TradesOpen)
                {       FileHandle=FileOpen(FileName,FILE_BIN|FILE_WRITE);
                        if(FileHandle>-1)
                        {       FileWriteInteger(FileHandle,TbF);
                                FileClose(FileHandle);
                                TradesOpen=true;
                                if(Debug)Print(FileName+" File Written: "+TbF);
                        }
                }
        }

Potrebbe essere facile nel momento in cui scrivi questo blocco di codice ma non sarà facile leggerlo nel momento in cui vuoi eseguirne il debug, è probabile che dimenticherai alcune delle variabili se non tutte, quindi dovrai ricominciare a farvi riferimento. Pensa a quanto tempo fa perdere quell'attività!

Scrivere algoritmi complessi ti farà odiare dalle persone e ti confonderai.

Forzare tutta la logica ad apparire in un posto è disgustoso, voler avere troppe operazioni in una singola funzione rallenterà il nostro processo di sviluppo poiché dobbiamo organizzare con cura il nostro codice e assicurarci che tutto funzioni beneForzare tutta la logica ad apparire in un posto è disgustoso, voler avere troppe operazioni in una singola funzione rallenterà il nostro processo di sviluppo poiché dobbiamo organizzare con cura il nostro codice e assicurarci che tutto funzioni bene.

Se hai bisogno di determinati tipi di operazioni, considera la creazione di funzioni indipendenti che possono esegurle, in modo che sia facile per te finire una cosa e passare all'altra.

05: Evita distrazioni.

"Sii consapevole che quando le distrazioni ti si presentano, saprai che sono distrazioni quando smetti di fare quello che dovevi fare e ti ritrovi a riflettere su cose che non hanno valore."
— Beverly R. Imes

Tieni il telefono in modalità silenziosa (o spegnilo del tutto) e non tirarlo su per controllare i tuoi Mi piace e le condivisioni sulle tue foto sui social media. Sarai molto inefficace se lo farai. Se ti trovi in una casa rumorosa, trova un posto dove andare a sederti e finire il tuo progetto.

Se è abbastanza importante per te, eliminerai tutte le distrazioni: chiudi la porta, spegni il telefono, spegni i social media, Concentrati e porta a termine il lavoro.

Penso che questa sia la sfida più grande che dobbiamo superare come sviluppatori nel mondo moderno in cui sei a un clic di distanza da seducenti e bellissime modelle su Instagram e dai simpatici video di gatti su Snapchat.

È allettante quando le cose diventano difficili nel tuo progetto, quando non riesci a capire il codice giusto da implementare, fare una pausa e vedere cosa sta succedendo sui social media o semplicemente uscire e rilassarti.

Non è che io sia contrario alle pause e al relax con gli amici no, non fraintendermi, non codifico 24/7, anche se ho troppi progetti di sviluppo web e MQL5 che mi aspettano. Ma credo che tutti dovrebbero attenersi a un programma che funzioni per loro. Se non è il momento di controllare i social media, non farlo. Se è il tempo di codificare, attieniti a quello solo fino alla fine della sessione (non importa quanto le cose diventino confuse o difficili) Io preferirei estendere le sessioni di codifica, se dopo non avessi nulla di importante da fare.

I codificatori distratti possono lavorare per 5 ore o più a qualcosa che i programmatori concentrati possono codificare in 45 minuti

06: Lettura della documentazione e Apprendimento

Dopo aver trovato la soluzione al tuo problema sul forum, non copiarlo e incollarlo per poi scappar via, pensando che in questo modo finirai il tuo progetto più velocemente (ne ho parlato nel mio Primo Articolo< /i2>). Assicurati di aver compreso come codificare la soluzione da solo. È difficile lavorare con il codice copiato quando qualcosa va storto, specialmente quando contiene dei bug poiché non lo capisci personalmente.

Incoraggio ogni codificatore a leggere frequentemente la documentazione, specialmente su cose che non sappiamo già o con cui non siamo ancora a nostro agio.

In che modo questo aumenta la nostra velocità di sviluppo ?

Più conosci il linguaggio MQL5, più diventa comodo e facile, più veloce sarai, come programmatore. È sempre una lotta trovare il codice giusto per realizzare efficacemente la tua idea (Programma), è qui che viene sprecata la maggior parte del nostro tempo. Spero davvero che tu possa dire quanto sia difficile programmare anche cose semplici se non sei molto informato su una particolare attività come la codifica di indicatori, script, consulenti esperti, ecc. È qui che entra in gioco l'esperienza.

Quindi, come ottenere l'esperienza? La mia risposta è sempre semplice: impara e prova cose diverse

Coloro che sanno molto del linguaggio MQL5 hanno infinite opzioni su come trasformare la loro idea in codice efficace e significativo. Sanno dove usare diverse opzioni

• Matrici
• For loops / While 
• File da memorizzare/Leggere Dati
• Richiedi e leggi i dati da un server web
• e molte altre cose interessanti che non posso menzionare tutte in questo articolo

07: Ripetizione distanziata

"Gli esseri umani ricordano o imparano più facilmente le cose quando vengono studiate più volte in un lungo periodo di tempo (presentazione distanziata), di quando vengono studiate ripetutamente in un breve periodo di tempo."
— Hermann Ebbinghaus

È così che abbiamo imparato tutto ciò che sappiamo facendolo più e più volte lentamente fino a quando non è diventata una seconda natura. La nostra memoria nel nostro cervello è limitata e manterrà solo ciò che usiamo regolarmente, quindi se vogliamo conservare qualcosa nella nostra mente dovremmo farlo regolarmente. Dovremmo imparare a usare questo metodo a nostro vantaggio.

Come?

Dal momento che uno dei motivi per cui siamo lenti è la nostra ignoranza su un particolare argomento, dovremmo sempre cercare le aree in cui dobbiamo migliorare (alcune di esse sono discusse in questo articolo). Una volta trovate quelle aree, dovremmo continuamente sforzarci di migliorare fino a diventare eccezionalmente bravi. Questo va bene quando si cerca di apprendere e padroneggiare una particolare abilità come >Machine Learning, Algoritmi autoadattativi</s4 >, ecc.

08: Tasti di scelta rapida e configurazione del MetaEditor

Tasti di scelta rapida

I tasti di scelta rapida sono divertenti e possono farti risparmiare molto tempo quando si tratta di scrivere codice sulla tastiera. Sono un professionista in questo e mi piace quando si tratta di insegnare ai programmatori le mie scorciatoie da tastiera produttive su MetaEditor.

Imparare le scorciatoie da tastiera cambia la vita quando si tratta di codificare e penso che l'uso della tastiera anziché del mouse dovrebbe essere adottato da ogni sviluppatore poiché trascorriamo la maggior parte del nostro tempo sulla tastiera, quindi dobbiamo essere bravi a farlo.

Ecco alcune delle mie scorciatoie preferite su un PC Windows (per Mac e Linux). Non ne sono così sicuro, ma gli utenti Mac possono sostituire CTRL con COMMAND;

SCORCIATOIA	USO
F4	Passa da MT5 a MetaEditor
F7	Compila Codice
CTRL+F7	Compila tutti i documenti aperti
CTRL+C	Copia il Codice Selzionato
CTRL+V	Incolla il Codice Selzionato
CTRL+X	Taglia il Codice Selzionato
CTRL+Z	Elimina le modifiche nel codice
CTRL+Y	Ripeti le modifiche nel codice
CTRL+A	Seleziona tutto il codice
CTRL+END	Sposta il cursore sull'ultima riga di codice nel documento
CTRL+HOME	Sposta il cursore sulla prima riga di codice nel documento
MAIUSC + Direzioni (SINISTRA, SU, DESTRA, GIÙ)	Seleziona il codice verso quella direzione
TAB	Aumenta il rientro del codice selezionato
MAIUSC+TAB	Diminuisci Rientra il codice selezionato
CTRL+ Backspace	Elimina l'intera parola in una riga
HOME	Sposta il cursore all'inizio di una riga
END	Sposta il cursore alla fine di una riga
CTRL+ ?	//--- Metti un separatore di codice nella riga successiva
CTRL+>	//+------------------------------------------------------------------+ //|           Add this to the current line and the next two          | //+------------------------------------------------------------------+
CTRL+"	// aggiunge due barre all'inizio di una riga
CTRL+,	Applica styler al documento corrente
CTRL+F4	Chiudi il documento Corrente
CRL +F5	Avvia/Riprendi il debug sui dati della cronologia
CTRL+T	Apri / Nascondi strumenti
CTRL+D	Apri / Nascondi Navigatore
ALT+G	Vai a Variabile/Dichiarazione di funzione
WINDOWS+T	Per navigare tra le app sulla barra delle applicazioni nel caso in cui volessi aprire browser Internet (CHROME) e cercare un problema
CTRL+F	Apri la casella di ricerca Trova
CTRL+S	Salva il documento corrente
CTRL + Directions	Salta negli spazi del codice (da parola a parola) in quella direzionen
CTR + +	Naviga in avanti
CTRL+ -	Naviga indietro
CTRL+SHIFT+U	Crea un codice selezionato (una parola) Maiuscolo
CTRL+U	Crea un codice selezionato (una parola) Minuscolo

Configurazione del Metaeditor

È anche importante avere la migliore configurazione di MetaEditor che favorisca la scrittura del codice più velocemente. Diamo un'occhiata ad alcune delle impostazioni che consiglio a tutti di provare.

Questi box dovrebbero essere spuntati

• Inserisci () e chiudi }]' — questo aiuterà a evitare quegli errori (fine programma imprevisto, parentesi sbilanciate) che potrebbero essere difficili e a catturare troppe righe di codice.
• Evidenzia le parentesi corrispondenti: questo ti ricorderà in quale funzione o in quale blocco ti trovi.
• Evidenzia la riga corrente: potrebbe essere fonte di confusione arrivare al punto in cui stavi codificando l'ultima volta, l'impostazione di questa opzione ti aiuterà a arrivarci rapidamente. Devi solo scorrere il codice e la linea corrente sarà evidenziata.
  
• Cronologia degli appunti: per vedere la cronologia di copia e incolla, potrai copiare diverse righe di codice e accedervi facilmente.
  

Altre impostazioni sono la scelta della giusta dimensione del carattere per la capacità dei tuoi occhi e la distanza tra gli occhi e il PC, non è necessario impostare una dimensione del carattere piccola che difficilmente puoi vedere.

Puoi giocare con le impostazioni per trovare altre impostazioni per renderti più veloce, vai su Strumenti>Opzioni.

09: Impara a cercare su Google

Imparare a fare la corretta ricerca su Google è un'attività che fa risparmiare tempo e può accelerare la velocità di codifica. È molto probabile che ti imbatti in molti problemi durante la codifica e che avresti bisogno di una soluzione immediata, ma sapere dove trovare le soluzioni non è sufficiente, devi anche sapere come cercare efficacemente la soluzione.

Fare una ricerca su Google è sufficiente per ottenere risposte rapide e corrette alle tue domande, giusto? SBAGLIATO

Vediamo un esempio di come il codificatore utente medio di Google che è rimasto bloccato nella lettura di un array da un file binario utilizza Google per cercare la soluzione.

La prima cosa che la maggior parte delle persone fa è andare su Google e cercare qualcosa come come leggere un array in un file binario ecco cosa ottengono

Nota: Il totale dei risultati supera i 98 milioni. 

Vedi il web è pieno di spazzatura e siti che fanno perdere tempo che se non stai attento finirai per perdere tempo e i tuoi dati privati verranno rubati dagli hacker. Il termine di ricerca è troppo vago per ottenere il risultato immediato specifico di cui abbiamo bisogno. Per ottenere i risultati che vogliamo, dobbiamo essere molto chiari e specifici.

Ci sono troppi suggerimenti per la ricerca per coloro che desiderano approfondire l'argomento. Consiglio di guardare questo breve video. Parlerò solo di due suggerimenti. 

01: Sito specifico da cercare

Non c'è posto migliore per ottenere le soluzioni relative a MQL5 di MQL5.com. Ogni volta che esegui una ricerca su Google considera MQL5.com come il sito in cui desideri che Google cerchi le tue risposte.

Aggiungi sito:MQL5.com alla fine del termine di ricerca e questo è risultato della ricerca

Questa volta vengono restituiti solo 568 risultati, tutti provenienti da MQL5.com (Il sito: URL) Comanda a Google di cercare solo nel sito specificato.

02: Più specifico

MQL5.com è ancora un sito vago in cui cercare se hai ben chiaro quello che vuoi, dato che è un sito di grandi dimensioni, c'è un modo che uso sempre, che non è consigliato da google, ma che funziona molto bene. La chiave qui è che devi sapere su quale parte di MQL5 vuoi che i tuoi risultati abbiano la priorità, ad esempio Articoli, Forum, Codebase, ecc. Potresti preferire i risultati di:

•  Sezione Articoli se vuoi approfondire un argomento.
•  Forum se vuoi una soluzione rapida 
•  Codebase se vuoi vedere cosa altri hanno codificato prima.

Cerca in questo formato MQl5 + seguito da sezione + quindi un termine di ricerca, esempio in questo caso 

Forum MQL5 come leggere un array in un file binario ecco il risultato

Questo metodo è specifico ma ancora, non abbiamo comandato a Google un sito specifico (solo il sito Web in cui ti trovi attualmente), la cosa migliore sarebbe aggiungere site:MQL5.com il termine di ricerca finale è ora forum come leggere un array in un file binario sito:MQL5.com Questa volta Google restituirà 399 risultati.

Conclusione

Questo è abbastanza per questo articolo, sto ancora lavorando su altri suggerimenti per aumentare la nostra velocità di programmazione e aumentare la nostra produttività. Ci sono altri suggerimenti che arriveranno con i prossimi articoli poiché ce ne sono molti. Raccomando a tutti i programmatori di praticare queste abitudini e modalità ogni giorno

Grazie per la lettura, mi piacerebbe sentire alcuni dei tuoi suggerimenti nella sezione di discussione di questo articolo.

Un caro saluto.