Passaggio a MQL5 Algo Forge (parte 1): Creazione del repository principale

Contenuto

• Introduzione
• Strumenti Attualmente Disponibili
• Avvio della Transizione
• Strumento di Gestione del Repository
• Creazione del Repository Principale (Main)
• Clonazione del Repository
• Configurazione dei File Ignorati
• Modifiche Commit
• Creazione di un Ramo dell’Archivio (Branch)
• Preparazione alla Creazione di Rami del Progetto
• Conclusioni

Introduzione

Quando si lavora ad un progetto di medie o grandi dimensioni, sorge inevitabilmente la necessità di tenere traccia delle modifiche apportate al codice, di raggrupparle per significato e di poter tornare alle versioni precedenti. In genere, questo viene gestito da sistemi di controllo della versione come Git o Subversion (SVN).

La maggior parte degli ambienti di sviluppo fornisce strumenti integrati per lavorare con i repository di qualche sistema di controllo della versione. MetaEditor non fa eccezione - supporta il proprio repository MQL Storage basato su SVN. Come afferma la documentazione:

MQL5 Storage è un repository online personale per i codici sorgente MQL4/MQL5. È integrato in MetaEditor: puoi salvare e ricevere dati dallo storage direttamente nell'editor.

Lo storage presenta il sistema di controllo della versione. Ciò significa che puoi sempre sapere quando e come sono stati modificati i file, nonché annullare le modifiche e tornare alla versione precedente.

Con MQL5 Storage, i tuoi codici sorgente rimangono sempre al sicuro. I dati sono memorizzati su un server protetto e tu sei l'unico ad averne accesso. Se il tuo disco rigido non funziona, tutti i codici salvati in precedenza possono essere facilmente ripristinati.

Lo storage consente di condividere e sincronizzare facilmente i template e i profili dei grafici, le impostazioni dei parametri per il test dei programmi MQL5 e le impostazioni degli strumenti di trading tra le diverse piattaforme.

MQL5 Storage consente lo sviluppo remoto di applicazioni MQL5 in team utilizzando i progetti condivisi.

Tuttavia, il sistema di controllo delle versioni Git è diventato molto più popolare - e a ragione, secondo noi. Forse per questo motivo, a metà del 2024, MetaQuotes ha rivelato i suoi piani per adottare Git come sistema integrato di controllo delle versioni in MetaEditor, insieme al lancio di MQL5 Algo Forge, un'alternativa interna a GitHub.

Al momento della stesura di questo articolo, il nuovo repository è già disponibile per l'uso, ma l'integrazione con MetaEditor non è ancora stata completata. Pertanto, mentre MetaEditor rimane l'ambiente di sviluppo principale, gli sviluppatori sono ancora limitati a MQL Storage basato su SVN.

Nel nostro lavoro su vari progetti, abbiamo utilizzato attivamente il sistema di controllo delle versioni esistente. Tuttavia, durante la stesura della serie di articoli "Developing a Multi-Currency Expert Advisor", la mancanza di supporto per lo sviluppo parallelo del codice in rami e la loro successiva fusione è diventata particolarmente evidente. Mentre SVN stesso supporta la ramificazione, MetaEditor non fornisce un'interfaccia per questo. È possibile utilizzare client SVN esterni, ma ciò richiederebbe una ristrutturazione del flusso di lavoro già noto.

Per questo motivo, l'annuncio di MQL5 Algo Forge è stato accolto con entusiasmo. Speravamo che MetaEditor supportasse finalmente la ramificazione. Ma sette mesi dopo, quelle aspettative rimangono incompiute. Pertanto, cerchiamo di capire come migliorare il processo di sviluppo con gli strumenti attualmente disponibili.

Per una migliore comprensione, è necessaria almeno una conoscenza di base dei sistemi di controllo delle versioni. Se necessario, si consiglia di consultare il materiale sul sito web di MQL5 o altrove, come ad esempio Getting started with Git.

Strumenti Attualmente Disponibili

Subito dopo la pubblicazione da parte di MetaQuotes della notizia del lancio di MQL5 Algo Forge, è stato creato un repository denominato mql5, che conteneva tutti i file del nostro attuale MQL Storage. Tuttavia, sono stati aggiunti tutti in un unico commit sotto l'utente super.admin, il che significa che non è stata preservata la cronologia dei commit. Questo era previsto. La migrazione dello storico completo tra diversi sistemi di controllo delle versioni è quasi impossibile.

In seguito, alcuni elementi dell'interfaccia di MetaEditor hanno iniziato a mostrare il nome del nuovo repository. Ad esempio, il titolo della finestra di dialogo della cronologia delle versioni è stato modificato in "MQL5 Algo Forge":

Tuttavia, l'essenza non è cambiata: tutte le modifiche vanno ancora in MQL Storage, non in Algo Forge. Pertanto, i file copiati su Algo Forge sette mesi fa non sono stati più aggiornati.

Ciò che è cambiato, tuttavia, è che ora possiamo lavorare con più repository. In precedenza, esisteva un solo repository. Abbiamo dovuto creare progetti diversi in cartelle separate all'interno della cartella dei dati MQL5, che era sempre la radice del repository. Ciò significa che quando si crea una nuova istanza del terminale per un nuovo progetto e si attiva lo storage, si scaricano tutti i progetti dallo storage, anche quelli non correlati. Man mano che il loro numero aumentava, questo diventava scomodo.

La semplice eliminazione dei progetti irrilevanti dalla cartella dei dati non era un'opzione, poiché ogni commit avrebbe richiesto l'esclusione manuale degli elementi eliminati dall’invio allo storage.

Con un repository Git adeguato, ora abbiamo diverse opzioni per strutturare l'archiviazione e gestire diversi progetti:

• Ogni progetto esiste in un proprio repository.
• Ogni progetto esiste in un ramo separato di un singolo repository.
• Un modello ibrido: alcuni progetti si trovano in repository separati, mentre altri coesistono come rami all'interno di un repository.

Ogni approccio ha pro e contro. Ad esempio, se più progetti condividono la stessa libreria, è scomodo tenere la libreria in un repository separato. È meglio invece mantenerlo in un ramo dedicato, unendo le modifiche nei rami del progetto secondo le necessità. D'altra parte, per i progetti autonomi, è preferibile un repository separato, per evitare di memorizzare codice non correlato da altri progetti.

Avvio della Transizione

Quando si apportano modifiche, è saggio preservare ciò che già esiste. Usare il repository mql5 creato automaticamente potrebbe non essere l'idea migliore, dato che MetaQuotes potrebbe eseguire azioni aggiuntive sotto super.admin. Pertanto, prima di tutto, creeremo un nuovo repository per memorizzare tutti i nostri progetti attuali. A tal fine, adotteremo il modello di archiviazione di progetti diversi in rami diversi. Per implementare questa separazione, definiamo le seguenti convenzioni:

• Il ramo principale rimarrà vuoto o conterrà solo un insieme minimo di codice comune utilizzato da tutti i progetti.
• Un ramo di archivio separato conserverà tutto il codice disponibile al momento della migrazione. Da qui possiamo copiare il codice nei singoli rami del progetto.
• Altri rami saranno legati a singoli progetti e saranno denominati di conseguenza.
• Un progetto può avere più rami attivi, a seconda della strategia di ramificazione scelta (per esempio, l'approccio descritto in ”A Successful Git Branching Model").

Supponiamo di avere una cartella MetaTrader5 con un terminale installato e un MQL Storage collegato. In altre parole, la cartella dati MetaTrader5/MQL5 del terminale contiene, insieme ai file standard, il codice dei nostri progetti.

Creare una nuova cartella denominata MetaTrader5.forge e copiarvi due file eseguibili:

Avviare il terminale MetaTrader da questa cartella in modalità portatile. Sul nostro sistema, si è avviato in questa modalità dopo un doppio clic. Altrimenti, potrebbe essere necessario specificare esplicitamente la chiave /portable quando si esegue dalla riga di comando o creare un collegamento, aggiungendo questa chiave al comando di avvio dell'applicazione. Non è necessario aprire un conto demo di trading o accedere a MQL5.community in questa fase.

Nella nuova cartella viene creata una struttura di cartelle iniziale, compresa una cartella di dati MQL5 vuota. Non contiene ancora i nostri file.

Avviare MetaEditor dal terminale premendo F4.

Se si fa clic con il tasto destro del mouse sul nome di una cartella, il menu contestuale offre l'opzione di attivare lo storage MQL5 Algo Forge (anche se, in realtà, questo attiverà lo storage MQL). Non attivatelo ancora, perché intendiamo migrare al nuovo tipo di repository.

Chiudete quindi MetaTrader e MetaEditor, poiché per un po' non ne avremo bisogno e dovremo eseguire alcune azioni direttamente nella cartella del terminale.

Strumento di Gestione del Repository

Il passo successivo è la scelta di uno strumento per lavorare con il futuro repository. In seguito, questo ruolo potrebbe essere assunto da MetaEditor stesso, ma per ora dobbiamo usare qualcos'altro. È possibile utilizzare qualsiasi strumento per lavorare con un repository Git, ad esempio Visual Studio Code (VSCode) in combinazione con Git. La versione Windows di Git può essere scaricata da gitforwindows.org.

Quindi, installate Git e VSCode (o assicuratevi che siano già installati). In VSCode, installare l'estensione MQL Tools per lavorare con i file MQL5:

Dopo aver installato l'estensione, specificare il percorso dell'eseguibile MetaEditor nel parametro 'Metaeditor5 Dir' delle impostazioni. Poiché non è necessario lavorare con i file sorgente MQL5 situati al di fuori della cartella di lavoro di un'istanza del terminale, è possibile seguire la raccomandazione e fornire il percorso relativo alla cartella attualmente aperta in VSCode:

Più in basso nelle impostazioni dell'estensione, consigliamo vivamente di abilitare l'opzione "Portable MT5".

Per l'evidenziazione della sintassi, è necessario installare l'estensione C/C++ per Visual Studio Code.

Purtroppo, sebbene MQL5 sia molto simile a C++, include alcuni costrutti linguistici che non sono utilizzati in C++ standard. Di conseguenza, l'estensione può occasionalmente visualizzare errori di sintassi che sono irrilevanti nel contesto di MQL5.

Ora, aprite la cartella dati MetaTrader5.forge/MQL5 in VSCode:

Provate ad aprire un qualsiasi file di Expert Advisor:

L'evidenziazione della sintassi funziona correttamente e nell'angolo in alto a destra della finestra dell'editor sono ora visualizzati ulteriori pulsanti per la verifica della sintassi MQL5 e la compilazione tramite MetaEditor. Tuttavia, tutte le direttive #include generano messaggi di errore. Questo accade perché MQL5 non è C++ e la posizione dei file di inclusione della libreria standard è diversa. Per risolvere il problema, seguite la soluzione suggerita: nelle impostazioni dell'estensione C/C++ per VSCode, aggiungete il percorso MetaTrader5.forge/MQL5/Include.

Una volta fatto questo, i messaggi di errore scompaiono e l'Expert Advisor viene compilato con successo:

A questo punto, accantoniamo temporaneamente VSCode, perché ora entra in scena l'attore principale: MQL5 Algo Forge.

Creazione del Repository Principale (Main)

Andate su https://forge.mql5.io/ e registrate un nuovo account o accedete utilizzando le vostre credenziali MQL5.community:

Dal menu in alto a destra, selezionare "Nuovo repository".

Scegliere un nome per il repository (ad esempio, mql5-main). Quando si clona il repository localmente, è possibile specificare qualsiasi nome per la cartella principale (root), quindi il nome del repository stesso non è fondamentale. Durante l'inizializzazione, aggiungere entrambi i file .gitignore e README.md.

Il repository è stato creato. Il primo commit viene eseguito automaticamente:

Per i passi successivi, copiare l'URL del repository. Nel nostro caso, è: https://forge.mql5.io/antekov/mql5-main.git. Ora possiamo tornare dal browser a VSCode, MetaEditor e il terminale MetaTrader 5.

Clonazione del Repository

Per clonare il repository localmente, abbiamo bisogno di una cartella MQL5 vuota nella directory del terminale. Attualmente è già pieno di file, quindi dobbiamo procedere come segue:

• Chiudere VSCode, MetaEditor e MetaTrader 5.
• Rinominare la cartella MQL5 esistente (ad esempio, in MQL6).

Ora non c'è nessuna cartella MQL5 nella directory MetaTrader5.forge:

Aprire questa cartella in VSCode e lanciare il terminale VSCode premendo [Ctrl + `].

Copiare l' URL del repository ed eseguire il comando di clonazione, specificando il nome della cartella principale del repository locale dopo l'URL (deve corrispondere a MQL5):

git clone https://forge.mql5.io/antekov/mql5-main.git MQL5

Se il repository è privato e questa è la prima volta che lo si clona, verrà richiesto di inserire le proprie credenziali. Di conseguenza, nella directory del terminale apparirà una nuova sottocartella MQL5, contenente .gitignore e README.md.

Ora spostate tutti i file e le cartelle da MetaTrader5.forge/MQL6 in MetaTrader5.forge/MQL5, quindi eliminate la vecchia cartella MetaTrader5.forge/MQL6.

Aprite la cartella MetaTrader5.forge/MQL5 in VSCode. Nel pannello di sinistra del Controllo Sorgente, vedrete che la cartella del repository ha un gran numero di nuovi file (nel nostro caso, 581):

Tuttavia, la maggior parte di questi file non dovrebbe trovarsi nel nostro repository, poiché appartengono all'installazione standard di MetaTrader 5. Nelle nuove versioni, il contenuto e la struttura di queste librerie standard e dei progetti di esempio possono cambiare. Non è possibile modificarli senza rischiare conflitti durante l’aggiornamento successivo del terminale MetaTrader o quando si passa a una nuova cartella di lavoro. Pertanto, non c'è motivo di includerli nel nostro repository.

Configurazione dei File Ignorati

È proprio qui che il file .gitignore diventa utile. Qui si possono specificare quali file e directory, Git deve ignorare. In questo modo, invece di centinaia di modifiche irrilevanti, vedremo solo le modifiche ai nostri file. Poiché non abbiamo ancora aggiunto alcun file personalizzato al repository, tutti i file attualmente elencati devono essere ignorati.

Quindi, aprite .gitignore e sostituite il suo contenuto predefinito con qualcosa di simile:

# ---> MQL5
# VSCode Preferences
.vscode/*

# Executables
*.ex5

# MQL5 Standard Files
/Experts/Advisors/
/Experts/Examples/
/Experts/Free Robots/
/Experts/Market/
/Files/
/Images/
/Include/Arrays/
/Include/Canvas/
/Include/ChartObjects/
/Include/Charts/
/Include/Controls/
/Include/Expert/
/Include/Files/
/Include/Generic/
/Include/Graphics/
/Include/Indicators/
/Include/Math/
/Include/OpenCL/
/Include/Strings/
/Include/Tools/
/Include/Trade/
/Include/WinAPI/
/Include/MovingAverages.mqh
/Include/Object.mqh
/Include/StdLibErr.mqh
/Include/VirtualKeys.mqh
/Indicators/Examples/
/Indicators/Free Indicators/
/Libraries/
/Logs/
/Profiles/
/Scripts/Examples/
/Scripts/UnitTests/
/Services/
/Shared Projects/
/experts.dat
/mql5.*

In questo modo si indica al sistema di controllo della versione di escludere i file di impostazione di VSCode, i file compilati di Expert Advisor e indicatori (il repository di solito contiene solo il codice sorgente) e i file standard di MetaTrader 5 che si trovano nelle cartelle elencate. Verrà tracciato solo il vostro codice sorgente.

Modifiche Commit

Dopo aver salvato .gitignore, VSCode mostra solo un singolo file modificato: il .gitignore stesso. Tutti gli altri file nella cartella MQL5, che ora è la cartella radice del nostro repository mql5-main, anche se fisicamente presenti, sono ora ignorati:

Eseguire un commit nel repository locale aggiungendo un messaggio come: "Aggiungi i file standard a .gitignore" e fare clic su "Commit".

A questo punto, la modifica esiste solo nel repository locale. Per inviarlo al repository remoto, eseguire il comando "Push". Questo può essere fatto in diversi modi, ad esempio facendo clic su "Sync Changes" in VSCode, selezionando "Push" dal menu di overflow (...) accanto a CHANGES, oppure eseguendo manualmente il comando 'git push'.

Tuttavia, prima di inviare l'ultimo commit, controllare la cronologia dei commit nel GRAPH. Si dovrebbero vedere due commit: "Commit iniziale" e "Aggiungi i file standard a .gitignore". Il nome del ramo è indicato in colore sulla destra, accanto ai commit. Il primo commit è etichettato come origin/main e il secondo solo main. In realtà si tratta dello stesso ramo main. Qui, origin è un alias del repository remoto, quindi il prefisso origin/ significa che questo commit è l'ultimo nel ramo main del repository. Il secondo commit appare senza questo prefisso, quindi esiste ed è l'ultimo solo nel repository locale.

Premere "Sincronizza modifiche":

Le modifiche sono state inviate con successo al repository remoto e l'etichetta viola "origin" è stata spostata sul secondo commit. È possibile confermarlo visualizzando il repository nell'interfaccia web:

A questo punto, abbiamo preparato un repository quasi vuoto per il nostro lavoro. L'unico ramo chiamato main contiene due file che abbiamo aggiunto. Qualsiasi altro file presente nella cartella dei dati di questa istanza del terminale viene ignorato dal sistema di controllo della versione.

Creazione di un Ramo dell’Archivio (Branch)

Come accennato in precedenza, il primo passo consiste nel collocare tutti i file esistenti in un ramo, in modo che rientrino nel controllo di versione e possano essere inviati al repository remoto. In questo modo è possibile recuperarli in seguito su qualsiasi altro computer, se necessario.

Come qualsiasi altra operazione nel sistema di controllo della versione, i rami possono essere creati in modi diversi. Da VSCode, aprire il menu del repository (...). Quindi selezionare "Checkout to...".

Quindi, nell'elenco delle azioni, selezionare "Create new branch...".

Nell'interfaccia web, dal repository remoto andare alla scheda branches e fare clic sul pulsante di creazione di un nuovo ramo (evidenziato con un rettangolo verde in basso):

C'è una differenza tra questi due metodi. Il primo crea un nuovo ramo sul computer locale e, finché non si inviano le modifiche, il repository remoto non sa nulla di questo ramo. Il secondo metodo crea un nuovo ramo nel repository remoto, quindi il repository locale non sa dell'esistenza di questo ramo finché non si recuperano le modifiche con il comando pull. In ogni caso, è sufficiente sincronizzarsi eseguendo i comandi pull o push).

Il terzo modo è quello di utilizzare la riga di comando. Per creare un nuovo ramo chiamato "archive" nel repository locale, si può eseguire, ad esempio, il seguente comando dalla cartella del repository:

git checkout -b archive

Se si esegue questa operazione nel terminale integrato VSCode, si vedrà quanto segue:

Questo terminale informa che il repository è stato spostato in un ramo "archive" appena creato. Nell'elenco dei commit, il nome del ramo main è cambiato in archive. Il changelog chiederà di inviare un nuovo ramo nel repository remoto. Tuttavia, prima aggiungeremo i nostri file a questo ramo.

Avevamo una cartella iniziale con il terminale MetaTrader, che conteneva la cartella MQL5 con tutti i nostri file. Il repository è stato creato all'interno di un'altra cartella del terminale. A questo punto, copiare tutti i file dalla vecchia cartella originale di MetaTrader5/MQL5 alla cartella del nuovo repository:

Il sistema di controllo della versione rileva immediatamente i nuovi file nella cartella del repository e alcune azioni diventano disponibili. È necessario aggiungere tutti i nuovi file all'indice (per consentire il controllo della versione). Questo può essere fatto sia attraverso l'interfaccia VSCode selezionando "+" (Stage All Changes) nell'intestazione dell'elenco delle modifiche, sia eseguendo il comando

git add .

Ora ogni file nell'elenco delle modifiche è etichettato con A, che significa che è stato indicizzato, invece che con U. Quindi, eseguire il commit e il push delle modifiche al repository remoto:

Come si può vedere, l'ultimo commit nel ramo main è ora il secondo commit, mentre il terzo commit è stato fatto nel ramo archive. Verifichiamo che il nuovo ramo sia stato inviato al repository remoto:

L'ultimo commit è visibile nel repository remoto e appartiene al nuovo ramo archive. Fare clic su di esso per vedere le modifiche specifiche, incluse in questo commit.

A questo punto, tutti i file sono stati aggiunti con successo al ramo dell'archivio. Ora, ritorniamo al ramo main del nostro repository locale.

Preparazione alla Creazione di Rami del Progetto

Per passare al ramo main (principale), eseguire il seguente comando nella console

git checkout main

Il repository locale dovrebbe tornare allo stato in cui si trovava prima di copiare tutti i file. Tuttavia, ispezionando il contenuto della cartella MQL5 dopo il passaggio, si può notare che molte delle nostre cartelle Expert Advisor sono rimaste.

Queste cartelle contengono ancora file .ex5 compilati. Questo accade perché, avendoli esclusi dal controllo di versione, Git non rimuove questi file quando si passa dal ramo dell’archivio a quello main. Dalla cartella sono stati rimossi solo i file sorgenti che sono stati organizzati e impegnati nel repository.

Questo non è molto comodo, quindi è necessario rimuovere i file compilati e le directory vuote che rimangono dopo la loro cancellazione. Fare questa operazione manualmente sarebbe dispendioso in termini di tempo, soprattutto perché potrebbe essere necessario ripeterla in futuro. Pertanto, è più pratico scrivere un semplice script per gestire questo compito automaticamente.

Durante lo sviluppo dello script, è emerso chiaramente che la sola eliminazione dei file non è sufficiente a ripristinare lo stato originale della cartella principale dopo il passaggio da un ramo all'altro. È inoltre necessario rimuovere le directory che sono diventate vuote dopo l'eliminazione dei file .ex5. Alcune cartelle possono essere intenzionalmente vuote e non devono essere rimosse. Questi verranno aggiunti ad un elenco di esclusione. Questo elenco includerà tutte le cartelle precedentemente elencate in .gitignore e la cartella .git contenente i metadati del controllo di versione. 

Ecco un esempio di script di questo tipo:

import os


def delete_ex5_files_and_empty_dirs(path, excluded=['.git', '.vscode']):
    # Exceptions
    excluded = {os.path.join(path, dir) for dir in excluded}

    # Check all folders and files in the directory tree
    for root, dirs, files in os.walk(path, topdown=False):
        is_excluded = False
        for ex in excluded:
            if root.startswith(ex):
                is_excluded = True
                break
        if is_excluded:
            continue

        # Delete all files with extension .ex5
        for file in files:
            if file.endswith('.ex5'):
                file_path = os.path.join(root, file)
                os.remove(file_path)
                print(f'File removed: {file_path}')

        # Delete all folders that have become empty after deleting files
        for dir in dirs:
            dir_path = os.path.join(root, dir)

            # IF the directory is empty after deleting files
            if dir_path not in excluded and not os.listdir(dir_path):
                try:
                    os.rmdir(dir_path)
                    print(f'Empty folder removed: {dir_path}')
                except OSError:
                    pass  # If error occurred, ignore


excluded = [
    '.git',
    '.vscode',
    'Experts\\Advisors',
    'Experts\\Examples',
    'Experts\\Free Robots',
    'Experts\\Market'
    'Files',
    'Images',
    'Include\\Arrays',
    'Include\\Canvas',
    'Include\\ChartObjects',
    'Include\\Charts',
    'Include\\Controls',
    'Include\\Expert',
    'Include\\Files',
    'Include\\Generic',
    'Include\\Graphics',
    'Include\\Indicators',
    'Include\\Math',
    'Include\\OpenCL',
    'Include\\Strings',
    'Include\\Tools',
    'Include\\Trade',
    'Include\\WinAPI',
    'Indicators\\Examples',
    'Indicators\\Free Indicators',
    'Libraries',
    'Logs',
    'Presets',
    'Profiles',
    'Scripts\\Examples',
    'Scripts\\UnitTests',
    'Services',
    'Shared Projects',
]

if __name__ == '__main__':
    current_dir = os.getcwd()  # Current working directory
    delete_ex5_files_and_empty_dirs(current_dir, excluded)

Salvare questo script come clean.py nella root del repository e aggiungerlo al controllo di versione nel ramo principale. D'ora in poi, dopo il passaggio dall'archivio al main, è sufficiente eseguire questo script per ripulire automaticamente i file compilati e le cartelle vuote.

Conclusioni

Concludiamo qui i nostri primi esperimenti con il nuovo sistema di repository. Tutti i nostri file sono stati trasferiti con successo. Abbiamo gettato le basi per la creazione di nuovi rami di progetto per nuovi progetti. Poiché il codice è conservato in modo sicuro nel ramo di archivio, possiamo migrare gradualmente i progetti in rami separati, a seconda delle necessità.

Un prossimo passo interessante sarà quello di provare a creare un repository pubblico per il codice sorgente della nostra serie di articoli "Sviluppare un Expert Advisor multivaluta". Non è ancora chiaro come strutturare il codice tra le diverse parti della serie, ma lo affronteremo nel prossimo futuro.

Grazie per l'attenzione! A presto!

Contenuti dell'archivio

#	Nome	Versione	Descrizione
	MQL5		Cartella principale del repository (Cartella dei Dati del Terminale)
1	.gitignore	1.00	File che elenca le cartelle e i file che devono essere ignorati dal sistema di controllo della versione Git
2	clean.py	1.00	Script per eliminare i file compilati e le directory vuote quando si passa al ramo main del repository