Bessere Programmierer (Teil 06): 9 Gewohnheiten, die zu effektiver Codierung führen
480
0
Einführung
Bevor wir mit dem Programmieren beginnen, müssen wir uns bestimmte Gewohnheiten aneignen, die uns dabei helfen, während der gesamten Programmierzeit konzentriert zu bleiben. Meistens ertappen wir uns dabei, dass wir programmieren, aber nicht merken, dass wir aus verschiedenen Gründen nicht effektiv sind, z. B. weil wir uns nicht konzentrieren, keinen Plan haben oder die Ausführung schlecht planen.
Inhalt:
- Planen Sie Ihr Projekt vor der Codierung
- Eine Sammlung von Codeschnipseln erstellen
- Über eine Routine verfügen
- Planen Sie tiefgreifende Arbeiten
- Erstellen Sie kleine Funktionen für einzelne Zwecke und testen Sie sie
- Fügen Sie Kommentare für Ihr zukünftiges Ich hinzu
- Tippgewohnheit
- Verwenden Sie die besten Hilfsmittel
- Verwenden Sie Versionskontrollen
Haftungsausschluss:
Alle in diesem Artikel verwendeten Codefragmente und Programmierbeispiele sind nur für Lehrzwecke gedacht. Einige von ihnen wurden nicht sorgfältig getestet/debuggt. Sie werden nur verwendet, um meinen Standpunkt zu verdeutlichen. Wenn Sie sich entscheiden, den Code zu verwenden, tun Sie dies auf eigene Gefahr.
01: Planen Sie Ihr Projekt vor dem Programmieren
Wenn Sie 100 Programmierer fragen, ob sie ihre Systeme planen, bevor sie mit dem Programmieren beginnen, werden Ihnen weniger als zehn sagen, dass sie ihre Arbeit planen, bevor sie anfangen, Code auf der Tastatur zu schreiben.
Dies ist das Hauptproblem, das wir angehen müssen, wenn wir effektiv programmieren wollen.
Können Sie in einen öffentlichen Bus einsteigen, ohne zu wissen, wohin Sie wollen? Auf keinen Fall.
Bevor Sie anfangen, Code in die Tastatur zu tippen, schreiben Sie sich auf, welche Art von Programm Sie brauchen, welche Werkzeuge, welche Bibliotheken Sie darin verwenden wollen, usw.
Im Bereich Freelance gibt es etwas, das Arbeitsspezifikationen genannt wird, was genau dasselbe ist wie ein Arbeitsplan, den jeder Entwickler haben muss, bevor er anfängt, etwas zu programmieren.
Sie können kostenlose Programme wie Microsoft Word oder WPS-Office verwenden, um Ihre Arbeiten zu planen, wenn Sie keinen Stift und kein Notizbuch oder ein Stück Papier haben. Sie können Diagramme und Illustrationen zeichnen, um alles zu beschreiben, was Sie brauchen.
Ich stimme Charles Kettering voll und ganz zu, als er sagte, dass "Ein gut formuliertes Problem ist halb gelöst"
Ich möchte zum Beispiel einen Simple Grid Expert Advisor mit Labouchere Geldmanagementsystemen darin erstellen.
Hier ist der einfache Arbeitsplan.
Hinweis: Alle folgenden Ausgangswerte können optimiert werden bzw. sind die Eingabevariablen.
Anfangswerte: Lotsize = 0,01; xgrid = 100; LotIncrement = 0,01;
| Meine Strategie | Formel für die Lotsize nach Positionstyp | Grid-Bedingungen (Strategie, aber in einer klareren Weise) | Geld-Managements | Bibliotheken |
|---|---|---|---|---|
| Bedingung 01: Wenn es keine offene Position gibt Öffne sowohl Kauf- als auch Verkaufspositionen (eine Position für jeden Typ) | X = Lotsize + (LotIncrement * Anzahl der Positionen nach Positionstyp) Beispiel: BuyLotsize = 0,01 + ( 0,01 * Anzahl der Kaufpositionen); | Die Kaufbedingung tritt ein, wenn die Anzahl der Kaufpositionen 0 (Null) ist oder wenn es bereits eine Kaufposition(en) gibt und der Geldkurs unter dem Eröffnungskurs der letzten Kaufposition minus xgrid Punkte liegt. | StopLoss = 0 (standardmäßig) | Klassenbibliothek für Standardpositionen |
| Bedingung 02 (Verkaufsbedingung): Wenn der Marktpreis um xgrid Punkte gegenüber der vorherigen Verkaufsposition gestiegen ist, eröffne eine Verkaufsposition mit Lotsize gleich der vorherigen Verkaufsposition Lotsize plus LotIncrement Wert. | Die Verkaufsbedingung tritt ein, wenn die Anzahl der Verkaufspositionen 0 (Null) ist oder wenn es bereits eine Verkaufsposition(en) gibt und der Briefkurs (Ask) über dem Eröffnungskurs der letzten Verkaufsposition plus xgrid Punkte liegt. | TakeProfit = 100 (standardmäßig) | ||
| Bedingung 03 (Kaufbedingung): Wenn der Marktpreis um xgrid Punkte von der vorherigen Kaufposition fällt, eröffne eine Kaufposition mit Lotsize gleich dem vorherigen Lotsize plus LotIncrement Wert. |
Anhand dieses einfachen Arbeitsplans können Sie sehen, dass es viel einfacher ist, die Arbeit auszuführen, als mit der vagen Vorstellung zu beginnen, die Dinge unterwegs herauszufinden. Ein besserer Plan kann Ihnen helfen, Bereiche zu identifizieren, die Sie lernen müssen, oder sich selbst daran zu erinnern, falls Sie sie vergessen haben sollten.
Bevor Sie mit dem Programmieren beginnen, sollten Sie einen gut erklärten Plan für Ihre Arbeit haben. Je klarer, desto besser
02: Eine Sammlung von Codeschnipseln erstellen
Wenn Sie feststellen, dass Sie Funktionen oder Klassen mehrmals in mehreren Programmen definieren, wie z.B. Expert Advisors, Indikatoren oder Skripte, brauchen Sie wahrscheinlich eine Sammlung von ihnen, damit Sie sie mehrmals wiederverwenden können, ohne sie immer wieder zu definieren. Am effektivsten lässt sich dies mit objektorientierter Programmierung (OOP) erreichen.
Anhand des Arbeitsplan-Beispiels haben wir gesehen, dass wir zwei Funktionen in unserem EA erstellen müssen.
- Eine Funktion zum Zählen der Positionen nach ihrem Typ
- Eine Funktion, die den Eröffnungspreis der letzten Position nach Positionstyp liefert.
Diese Funktionen werden in fast jedem Grid-EA benötigt, also können wir eine Include(.mqh)-Datei mit dem Namen gridmodule erstellen und diese beiden Funktionen darin speichern, damit wir sie in unsere Hauptdatei .mq5 aufnehmen können.
gridmodule.mqh von innen
//+------------------------------------------------------------------+ //| 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; } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+
Das hat viele Vorteile, denn es erleichtert das Debuggen des Codes: Das Debuggen muss nur an einer Stelle erfolgen und man muss weniger Code in der Hauptdatei .mq5 bearbeiten.
03: Haben Sie eine Routine
Routinen können sehr hilfreich sein, um sich auf die richtige Einstellung zum Programmieren einzustellen, was wiederum die Produktivität im Allgemeinen erhöht. Es ist auch der beste Weg, um sich zu engagieren und ein beständiger Programmierer zu werden, Tag für Tag.
Sie können zum Beispiel eine Routine haben, um jeden Tag von 08:00 bis 11:00 Uhr zu programmieren.
Wenn Sie sich an diese Routine halten, werden Sie nach einigen Wochen oder Monaten feststellen, dass Sie sich jedes Mal, wenn Sie sich zu dieser Zeit an den PC setzen, darauf freuen, mit dem Programmieren zu beginnen.
Erstellen Sie einen Zeitplan, der für Sie am besten funktioniert.
04: Planen Sie tiefgreifende Arbeiten
In der heutigen Zeit ist es so einfach, sich von vielen Dingen ablenken zu lassen. Es ist heutzutage schwer, sich zu konzentrieren, vor allem wenn es beim Programmieren schwierig wird. Beachten Sie, dass wir nur wenige Momente/Stunden am Tag so hyperfokussiert sind, dass wir kreativ werden.
Oft braucht unser Geist eine lange Zeit, in der er frei von Ablenkungen arbeiten kann, um dieses Niveau zu erreichen. Um diesen Zustand zu erreichen, müssen wir Tage mit vielen Stunden Non-Stop-Programmieren einplanen.
Durch lange Stunden intensiver Arbeit können wir den Großteil der harten Arbeit erledigen, mit der wir bei unserer normalen Arbeit konfrontiert waren. Ich empfehle jedem Programmierer, bestimmte Tage einzuplanen, an denen man hart und frei von Ablenkungen arbeiten kann.
05: Erstellen Sie Funktionen für einzelne Zwecke und testen Sie sie
Vermeiden Sie zu viele Operationen innerhalb einer Funktion. Denken Sie daran, jedes Mal eine neue Funktion zu erstellen, wenn Sie feststellen, dass Sie für eine wichtige Operation programmieren müssen.
Zu viele Schleifen in der Funktion OnTick (oder in jeder anderen Haupt- oder Nebenfunktion) werden Ihnen in kürzester Zeit schaden. Es ist, als würde man den Stift einer Handgranate herausziehen, die man in der Tasche hat.
Einfache Algorithmen zu zwingen, komplex zu werden, indem man die gesamte Logik an einer Stelle erscheinen lässt, ist eine der besten Möglichkeiten, Fehler zu erzeugen, die Sie Geld und die wertvollste Ressource in Ihrem Leben, Zeit, kosten werden.
Ich bin der Meinung, dass Programmieren die meiste Zeit Spaß machen muss, damit wir in der Lage sind, es konsequent zu tun. Verschlungene Algorithmen machen keinen Spaß, egal wie erfahren und clever derjenige ist, der den Code liest. Stellen Sie sicher, dass jede Funktion nur eine Operation ausführt, und darüber hinaus sollte sie einen einfach zu lesenden und zu verstehenden Funktionsnamen haben.
Schauen Sie sich die Funktion CountPositions mit einem Argument für den Positionstyp aus dem vorherigen Beispiel an:
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; } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+
Ein Blick auf den Funktionsnamen genügt, um zu erkennen, dass es bei dieser Funktion um das Zählen von Positionen nach ihrem Typ geht, und genau das wurde im Inneren der Funktion getan, nicht mehr und nicht weniger.
06: Fügen Sie Kommentare für Ihr zukünftiges Ich hinzu
Die einfache Angewohnheit, Kommentare zu Ihrem Code hinzuzufügen, kann als eine voreilige Art der Codierung angesehen werden. Aber für diejenigen, die wissen, wie man sie effektiv einsetzt, kann das ein entscheidender Vorteil sein.
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
Die meisten Variablen, Funktionen und Codeschnipsel, die Sie jetzt schreiben, werden Sie in einigen Wochen oder sogar Tagen wieder vergessen. Ohne sinnvolle Kommentare werden Sie mit dem Code, den Sie früher geschrieben haben, nicht mehr vertraut sein (wie dumm ist das denn !!).
Das Hinzufügen von Kommentaren in MQL5 ermöglicht es der IDE MetaEditor , Ihnen dabei zu helfen, sich jedes Mal leichter daran zu erinnern, wenn Sie sie benutzen wollen.
Warum sollte es MetaEditor schwerer fallen, Ihnen zu helfen? Das ergibt für mich keinen Sinn.
Denken Sie daran, dass Sie in dieser Karriere nicht allein sind, also wollen Sie immer einen Code haben, der leicht weitergegeben und von anderen Entwicklern in der Codebasis oder so verwendet werden kann, und der einzige Weg, dies zu erreichen, ist ein leicht zu lesender und verständlicher Code, der durch Kommentare ermöglicht wird.
07: Tippgewohnheit
Vergessen wir nicht, dass wir, um effektiv zu programmieren, gute Schreiber auf der Tastatur werden müssen. Jeder Programmierer muss sich bemühen, seine Fähigkeiten beim Tippen auf der Tastatur zu entwickeln und zu verbessern. Der beste Weg, um gut im Tippen von Code zu werden, ist die Entwicklung einer Tippgewohnheit: eine Gewohnheit, die richtigen Buchstaben auf der Tastatur zu treffen, ohne auf die Tastatur zu schauen.
Meistens neigen wir dazu, Codes zu schreiben, während wir gleichzeitig auf die Tastatur und den Bildschirm schauen, ohne uns bewusst zu sein, dass dies eine unsachgemäße Form des Tippens ist.
Sie müssen sich von der Schnellschreibgewohnheit verabschieden und sich antrainieren, zu tippen, ohne auf die Tastatur zu schauen (nur auf den Bildschirm). Dies ist durch das Tippen mit dem Muskelgedächtnis möglich.
Es ist etwas schwieriger, diese Gewohnheit zu entwickeln, aber wenn man sie einmal entwickelt hat, wird das Tippen zu einer automatischen Übung.
Ich konnte diese Gewohnheit nach mehreren Wochen Übung auf einer kostenlosen Website namens keybr.com entwickeln, die ich jedem empfehlen kann, der diese Gewohnheit entwickeln möchte.
08: Verwenden Sie die besten Hilfsmittel
Hilfsmittel können einen großen Beitrag zur Verbesserung Ihrer Gesamtproduktivität als Programmierer leisten, und ich kann nicht genug betonen, dass Sie bessere Hilfsmittel brauchen, wenn nicht sogar die besten (sowohl Hardware als auch Software).
Achten Sie immer darauf, dass Sie die besten Bibliotheken verwenden (ich empfehle die MQL5-Standardbibliotheken), Sie brauchen auch die besten Informationsquellen, wenn Sie nicht weiterkommen und wenn Sie neue Dinge lernen und ausprobieren müssen (lesen Sie diesen Artikel für weitere Details) und obendrein brauchen Sie einen leistungsfähigen PC und eine gute Internetverbindung.
09: Verwenden Sie Versionskontrollen
Es ist immer eine gute Angewohnheit, eine Versionskontrolle für Ihren Code einzurichten, so dass Sie Ihren Fortschritt verfolgen und jederzeit zu früheren Versionen des Codes zurückkehren können.
Ich kenne zwei Möglichkeiten, dies zu tun. Die erste ist die Verwendung von Git und die zweite ist ein manueller Prozess, der das Kopieren und Einfügen von Methoden zur Speicherung von Code in einer Textdatei beinhaltet.
Verwenden von Git
Dies ist ein Weg, den ich Ihnen in wenigen Minuten beibringen könnte, wenn Sie mit Git und Github nicht vertraut sind. Ich empfehle aber, die Git Dokumentation zu lesen.
Durch eine Textdatei
Legen Sie einen Ordner für Ihr Projekt an und fügen Sie alle benötigten Dateien in diesem Projekt hinzu. Öffnen Sie dann diesen Ordner in Ihrem Dateiexplorer, um zu sehen, was sich in dem Ordner befindet (siehe das Bild unten aus meinem vorherigen Beispiel).
Wenn Sie eine größere Änderung an Ihrer .mq5-Datei vorgenommen haben, z. B. durch das Hinzufügen einer neuen Funktion, müssen Sie eine Textdatei mit einem Namen erstellen, der die Version des Codes und den hinzugefügten Inhalt angibt. Wie im Bild
Sie können eine Textdatei neben der Hauptdatei .mq5 oder .mqh öffnen und beide mit einem Klick CTRL+F7 in Windows speichern, was alle geöffneten Dateien in Ihrem Editor kompiliert. Nach erfolgreicher Kompilierung können Sie alle Fehler ignorieren, die von dieser Textdatei stammen, und sie schließen.
Schlussfolgerung
Das war's für diesen Artikel. Ich hoffe, Sie haben etwas Positives gewonnen, das Sie einen Schritt weiterbringt, um ein besserer Programmierer zu werden. Wenn Sie irgendwelche Perlen der Weisheit haben, die Sie vermissen, teilen Sie sie mit mir und anderen Programmierern im untenstehenden Diskussionsbereich. Der gesamte in diesem Artikel verwendete Code ist unten angehängt.
Vielen Dank für die Lektüre und beste Grüße.
Übersetzt aus dem Englischen von MetaQuotes Ltd.
Originalartikel: https://www.mql5.com/en/articles/9923
Grafiken in der Bibliothek DoEasy (Teil 84): Abgeleitete Klassen des abstrakten grafischen Standardobjekts
Programmierung eines Tiefen Neuronalen Netzes von Grund auf mit der Sprache MQL
Grafiken in der Bibliothek DoEasy (Teil 85): Grafische Objektkollektion - Hinzufügen neu erstellter Objekte
Umgang mit Zeit (Teil 2): Die Funktionen
- Freie Handelsapplikationen
- Über 8.000 Signale zum Kopieren
- Wirtschaftsnachrichten für die Lage an den Finanzmärkte
Sie stimmen der Website-Richtlinie und den Nutzungsbedingungen zu.