Yeni Başlayanlar İçin Hızlı Başlangıç veya Kısa Kılavuz

Giriş

Merhaba sevgili okuyucu! Bu yazıda, Uzman Danışmanlar (EA) oluşturma, göstergelerle çalışma vb. ilkeleri nasıl kolay ve hızlı bir şekilde kavrayabileceğinizi açıklamaya ve göstermeye çalışacağım. Bu, yeni başlayanlara yöneliktir ve zor veya anlaşılmaz örnekler içermeyecektir. Bu nedenle makale, Uzman Danışmanları (EA) nasıl programlayacağını zaten bilenleriniz için muhtemelen çok ilham verici ve bilgilendirici olmayabilir.

Uzman Danışman (EA) ve Yapısı

Uzman Danışman (EA), MQL dilinde yazılmış, alım satım yapmak veya bir kenarda tutmak için şartları belirten bir programdır.

Temel olarak, bir EA'nın yapısı çok sayıda bloktan oluşabilir, ancak daha kolay anlaşılması için MetaEditor'da varsayılan olarak oluşturulan çok basit bir örnek vereceğim.

Tüm EA görsel olarak her biri yapılacak işin belirli bir bölümünden sorumlu olan 4 bölüme ayrılabilir.

 
Şekil 1. Ana EA blokları

1. Parametre Bloğu terminalin EA'yı uygun bir şekilde işlemesine izin veren bilgileri içerir. En yaygın parametreler EA versiyonu, üretim şirketinin adı ve kısa bir açıklamadır.
   
   
2. OnInit() Bloğu EA terminale yüklendikten sonra kontrolü kazanır. EA'nın başlatılması, değişkenleri ve dizileri bildirme, gösterge tanıtıcılarını alma vb. ile ilgili çeşitli veriler içerebilir. Yani, bu blok, doğrudan alım satımla ilişkilendirilecek herhangi bir fonksiyona sahip değildir.
   
   
3. OnDeinit() Bloğu, OnInit() Bloğunun tersi şekilde hareket eder. Bu, EA çalışmasını tamamladığında çağrılır (EA/Terminal kapatma veya bir EA'nın başlatılamaması). Bu bloğun ana fonksiyonlarından biri, artık ihtiyaç duyulmadığında EA tarafından kullanılan bellek alanının serbest bırakılmasıdır. Başka bir deyişle, değişkenleri, dizileri ve gösterge tanıtıcılarını vb. silme işlemlerini açıklar.
   
   
4. OnTick() Bloğu, sunucudan sembol (para birimi çifti) üzerinde her yeni bilgi alındığında çağrılır. Alım satımı yapmak için koşulları ve alım satımın fonksiyonlarını belirtir.

   Şekil 2. MetaEditor'da varsayılan olarak oluşturulan yeni bir belge örneği

Yukarıdaki örnekle açıklayayım. Daha sonra doldurulması gereken bir tür Uzman Danışman (EA) şablonu olan "boş" Uzman Danışman (EA) koduna sahibiz.
Burada görebildiğimiz şudur:

• ilk beş satır (1'den 5'e kadar olan satırlar) EA'nın adını (dosya adı), üretim şirketinin adını ve web sitesini içeren yorumları temsil eder. Buraya hoşunuza giden her şeyi yazabilirsiniz. Bu metin hiçbir yerde görülmez ve hatta atlanabilir. İçerdiği bilgiler yalnızca geliştiriciyi hedefler;
  
  
• sonraki 3 satır (6'dan 8'e kadar olan satırlar) Parametre Bloğunu temsil eder. Bu bilgi, terminalde EA başlatılırken gözlemlenebilir;
  
  
• Bunu OnInit() fonksiyonu izler (12'den 19'a kadar olan satırlar). Bu OnInit() Bloğudur. Bu fonksiyon herhangi bir parametre almaz, ancak başlatma kodunu (olmasa da) verir;
  
  
• OnDeinit(const int reason) fonksiyonu bundan sonra gelir (22'den 26'ya kadar olan satırlar). Bu, OnDeinit() Bloğudur. EA'nın kapanma nedenini belirten bir parametresi vardır.
  EA başlatma başarısız olursa, bu fonksiyon parametre olarak ilgili bir kodu alır;
  
  
• son fonksiyon OnTick() fonksiyonudur (30'dan 34'e kadar olan satırlar). Bu, daha önce açıklanan OnTick() Bloğudur. Bu bloğun, alım satımlardan sorumlu tüm fonksiyonları içerdiği için EA'nın "beyni" olduğu söylenebilir.

Daha önce söylediğim gibi, yapı çok daha karmaşık olabilir ve bu anlaşılması kolay örneğin aksine çok sayıda bloktan yapılabilir. Bunun yeterli olmadığını düşündüğünüzde kendi bloklarınızı ekleyebilirsiniz.
 

Göstergeler ve Bunların Nasıl İşleneceği

Göstergeler fiyat grafiğinde veya fiyat grafiğinin altında ayrı bir pencerede görüntülenen ve piyasanın teknik analizini yapmamızı sağlayan MQL ile yazılmış küçük programlardır.

Tüm göstergeler iki türde sınıflandırılabilir: trend takip eden göstergeler ve osilatörler.

Trend takip eden göstergeler, kural olarak, fiyat grafiğinde çizilir ve trend yönünü belirlemek için kullanılırken, osilatörler normalde fiyat grafiğinin altında görülebilir ve giriş noktalarını belirlemeye yarar.

Çoğu gösterge, belirli bir zamanda okuma verilerini içeren en az bir tampona (gösterge tamponu) sahiptir. Bir EA gibi, göstergenin de sembolü ve hesaplandığı zaman dilimi vardır.

Gösterge tamponu, son elemanı çalışan bir değer olan bir kuyruk olarak düşünülebilir.

   Şekil 3. Hareketli Ortalama Göstergesi Örneği

Gösterge tamponu, birinci öğenin (0 indeksli) en sağdaki mumdaki verileri ve takip eden öğenin (1 indeksli) sağdaki ikinci mumdaki verileri vb. taşıdığı bir dizidir. Öğelerin bu şekilde düzenlenmesine zaman serisi denir.

Örneğe aşağıdaki gibi bir göz atın:
Elimizdeki para birimi çiftinin EUR/USD olduğunu, zaman diliminin 1 saat olduğunu varsayalım.
Öncelikle, göstergeyi EA'ya eklememiz ve tanıtıcısını almamız gerekiyor.

Tanıtıcı, bu göstergeyi programın herhangi bir yerinde ele almamızı sağlayan benzersiz bir göstergedir.

int iMA_handle; 
iMA_handle=iMA("EURUSD",PERIOD_H1,10,0,MODE_SMA,PRICE_CLOSE);

Daha yakından bakalım.

Birinci satır, gösterge tanıtıcısını depolayacak bir değişkeni tanımlar. İkinci satır göstergeyi çağırır (burada Hareketli Ortalama göstergesi), parametrelerini belirtir ve tanıtıcıyı ileride kullanmak üzere değişkene kaydeder.

MetaEditor'da "iMA(" yazdıktan sonra, bu satırın üzerinde virgülle ayrılmış gösterge çağrı parametrelerini gösteren bir araç ipucu görünecektir.

   Şekil 4. Hareketli Ortalama gösterge parametreleri için araç ipucu örneği

Aşağıdaki parametreleri soldan sağa listelenmiş şekilde görebiliriz:

1. sembol adı (araç ipucunda kalın harflerle görünür) bir metin parametresidir, para birimi çiftidir (sembol);
2. zaman dilimi;
3. gösterge periyodu (burada ortalama periyot);
4. N çubuk ileri/geri grafik kaydırma. Pozitif bir sayı, grafiğin N çubuk ileri kaymasını, negatif bir sayı ise grafiğin N çubuk geri kaymasını belirtir;
5. ortalama alma yöntemi;
6. uygulanan fiyat veya farklı bir göstergenin tanıtıcısı.

Her gösterge için benzersiz bir değişken seti ve türleri vardır. Bilinmeyen bir göstergeyle karşılaşırsanız, bununla ilgili bilgiler her zaman yerleşik Yardım bağlamında bulunabilir. Örneğin, iMA yazıp F1 tuşuna bastığınızda, bu belirli gösterge hakkında bilgi ve tüm özelliklerinin ayrıntılı bir açıklamasını sağlayan bir Yardım penceresi açılacaktır.

   Şekil 5. F1 tuşuna basarak göstergenin açıklaması için Yardım penceresinin çağrılması örneği

Kodu yazdıktan ve terminalde EA'yı başlattıktan sonra, (EA fiyat grafiğinin sağ üst köşesinde göründüğünde) göstergenin grafikte eksik olduğunu göreceğiz. Bu bir hata değildir - böyle tasarlanmıştı. Görünmesi için başka bir satır eklememiz gerekiyor:

ChartIndicatorAdd(ChartID(),0,iMA_handle);

Şimdi ne yaptığını görelim. İmleci ChartIndicatorAdd komutunun üzerine getirin ve komutun amacına ilişkin Yardım bilgilerini okumak için F1 tuşuna basın. Bu komutun şunu yaptığını söyler:

Belirtilen tanıtıcıya sahip bir göstergeyi belirtilen grafik alt penceresine ekler.

Sıfıra eşit olan ikinci parametre alt pencere numarasıdır. Alt pencereler genellikle fiyat grafiğinin altında osilatörler içerir. Unutmayın? Bunlardan çokça olabilir. Göstergeyi alt pencerede görüntülemek için, alt pencere numarasını, halihazırda var olan sayıdan 1, yani en son var olandan sonraki numara olacak şekilde belirtmeniz yeterlidir.

Kod satırını aşağıdaki gibi değiştirdikten sonra:

ChartIndicatorAdd(ChartID(),1,iMA_handle);

göstergemiz fiyat grafiğinin altındaki alt pencerede görünecektir.

Şimdi göstergeden bazı verileri almaya çalışmanın zamanı geldi. Bunun için dinamik bir dizi tanımlıyoruz, kolaylık olması açısından dizi indekslemeyi zaman serisi olarak düzenliyoruz ve gösterge değerlerini bu diziye kopyalıyoruz.

double iMA_buf[];
ArraySetAsSeries(iMA_buf,true);
CopyBuffer(iMA_handle,0,0,3,iMA_buf);

Yukarıdaki örnek, Hareketli Ortalama göstergesi fiyatlara dayalı olduğundan ve fiyatların kesirleri olduğundan, iMA_buf[] dinamik dizisini double türünde bildirdiğimizi göstermektedir.

Sonraki satır, dizi için indekslemeyi ayarlar, böylece daha küçük indekslere sahip öğeler daha eski değerleri depolarken, daha büyük indekslere sahip öğeler daha yeni değerleri depolar. Bu, tüm göstergelerdeki gösterge tamponları zaman serisi olarak indekslendiğinden, karışıklığı önlemek için kolaylık sağlamak üzere kullanılır.

Son satır, gösterge değerlerini iMA_buf[] dizisine kopyalamaya yarar. Bu veriler artık kullanıma hazırdır. 

 

Emirler, Alım Satımlar ve Pozisyonlar

Emirlerle başlayalım.

• Emirler alım satım sunucusu tarafından kabul edilen alım satım talepleridir. Talep geçersiz ise reddedilecektir.
  Alım satım talebini doldurmanın zorluğundan kaçınmak için, bunun standart kitaplıklar kullanılarak nasıl yapılabileceğini daha sonra göstereceğim ve her şeyi çok daha kolay hale getireceğim.
  2 tür emir vardır: piyasa (hemen yürütme için) ve bekleyen.

Piyasa emirleri, belirli bir finansal enstrümanın belirli bir miktarını mevcut piyasa fiyatından satma veya satın alma talimatlarını temsil eder.
Bekleyen emirler, belirli koşullara tabi olarak alım satım gerçekleştirilmesine yönelik talimatları temsil eder. Bekleyen emirlerin silindiği belirli bir sona erme süresi vardır.

• Alım Satımlar, emirlerin yerine getirilmesinin sonuçlarını temsil eder (bir alım satım gerçekleştirme talimatları). Her alım satım belirli bir tek emre dayanırken, tek bir emir birden fazla alım satımla sonuçlanabilir. Örneğin, 10 lot satın alma emri, bir dizi ardışık alım satımın kısmi olarak yürütülmesiyle gerçekleştirilebilir. Alım satımlar her zaman alım satım geçmişinde depolanır ve değiştirilemez. Terminal, alım satımları "Geçmiş" sekmesinde görüntüler.

• Pozisyonlar eylemdeki emirlerin sonucunu temsil eder. Her bir sembol için Uzun veya Kısa olmak üzere yalnızca bir pozisyon açılabilir.

Daha açık hale getirmek için, bir örnekle açıklayayım: 1 lotluk uzun bir pozisyon açıyoruz, yani mevcut piyasa fiyatından (örneğin) ve 1 lotluk bir emir veriyoruz. Talep geçerliyse, işlenmek üzere sunucuya gönderilir. İşlem tamamlanır tamamlanmaz, terminalin "Alım Satım" sekmesinde emir parametrelerine sahip bir pozisyon görünecektir. Daha sonra 1 lot büyüklüğünde başka bir uzun pozisyon açmaya karar verdiğimizi varsayalım. Emrin işlenmesini takiben, "Alım Satım" sekmesinde iki emir değil, 2 lot büyüklüğünde bir pozisyon göreceğiz. Yani pozisyon, bir dizi emrin yerine getirilmesinin sonucudur.

Şimdi uygulamaya geçelim. Talepte bulunmak için aşağıdaki yapı alanlarının doldurulması gerekir:

struct MqlTradeRequest
{
ENUM_TRADE_REQUEST_ACTIONS action; // Type of action
ulong magic; // Expert Advisor ID (magic number)
ulong order; // Order ticket
string symbol; // Trade instrument
double volume; // Requested trade size in lots
double price; // Price 
double stoplimit; // StopLimit level of the order
double sl; // Stop Loss level of the order
double tp; // Take Profit level of the order
ulong deviation; // Maximum allowed deviation from the requested price
ENUM_ORDER_TYPE type; // Order type
ENUM_ORDER_TYPE_FILLING type_filling; // Order type by execution
ENUM_ORDER_TYPE_TIME type_time; // Order type by duration
datetime expiration; // Order expiration time (for orders of the ORDER_TIME_SPECIFIED type)
string comment; // Comment to the order
};

Çeşitli emirler olduğu için her bir emir türünün kendi zorunlu parametreleri vardır. Bu alanlara uzun uzun değinmeyeceğim. Web sitesi bu konuda birçok bilgi sunmaktadır. Belirli bir emir türü için zorunlu parametrelerden biri bile belirtilmemişse veya yanlış belirtilmişse, talep başarısız olacaktır.

Yukarıdaki yapı, yalnızca doldurulurken ortaya çıkan zorluğu daha iyi göstermek için burada düzenlenmiştir.

Zararı Durdur ve Kar Al

Zarar Durdur ve Kar Al, "geri çekilme önlemi" olarak verilen özel emirlerdir. Yani, Uzman Danışman (EA) tarafından açılan ve zarar gösteren bir pozisyon olması durumunda, Zararı Durdur emri, zararları önceden tanımlanmış belirli bir seviyede sınırlayabilir.

Kar Al benzer şekilde hareket eder, bu durumda sadece karı sınırlar. Bir pozisyonu kapatma konusunda endişelenmeyi bırakmak gerekebilir. Bu, belli bir fiyat seviyesine ulaştığında kapanacaktır. Başka bir deyişle, bu emirler, piyasa aleyhimize dönerse veya biz kar etmek istersek, bizim "sigorta planımızı" temsil eder.

Bu tür emirler tek başına ayrı olarak verilemez - sadece mevcut pozisyonları değiştirebilir.

Standart Kitaplıkları Kullanma

Sonunda Standart Kitaplığa ulaştık. Bu kitaplık terminal ile birlikte gelir, dolayısıyla adı Standart Kitaplıktır. EA'ların programlanmasını kolaylaştıran ve kısmen karmaşık işlemleri üstlenen, örneğin alım satım talebi oluşturma gibi fonksiyonlar içerir.

Alım satım kitaplıkları (ayrıca alım satım sınıflarına bakın) aşağıdaki yolda bulunur: Include\Trade\ ve #include direktifi kullanılarak eklenebilir.
Örnek:

#include <Trade\Trade.mqh>
#include <Trade\PositionInfo.mqh>

Uzman Danışmanların (EA) çoğunluğu sadece bu iki sınıf (kitaplık) kullanılarak programlanabileceği için, yukarıdaki sınıflar temel sınıflar olarak kabul edilebilir. Ben bunlara kitaplıklar diyorum:

• Birincisi, emir vermek ve değiştirmek için tasarlanmıştır.
• İkincisi, mevcut pozisyonlar hakkında bilgi edinmeye hizmet eder.

Bazen başka bir kitaplık yararlı olabilir:

#include <Trade\OrderInfo.mqh>

Örneğin, stratejimiz bekleyen emirlerin kullanılmasını gerektiriyorsa, emirlerle çalışmak için fonksiyonlar içerir.

Bilginin doğru kullanılmasını gerektiren çeşitli parametrelerle dolu alım satım talebi yapısını hatırlıyor musunuz?
Şimdi size kitaplık kullanılarak yapılan bir alım satım talebi örneğini vereceğim:

CTrade m_Trade;
m_Trade.Sell(lot,symbol_name,price,sl,tp,comment);

Burada sadece biri zorunlu olan toplam 6 parametre vardır (emir boyutu - bu birinci parametredir).
Şimdi her birini belirteceğim:

• lot verilecek emrin büyüklüğüdür;
• symbol_name emrin geçerli olduğu semboldür (para birimi çifti) (hiçbiri belirtilmemişse, Uzman Danışmanın (EA) mevcut sembolü kullanılır);
• fiyat açılış fiyatıdır (bu, aktif bir emir açma fonksiyonu olduğundan, fiyatı belirtilmemiş olabilir, bu durumda otomatik olarak doğrudan fiyat grafiğinden elde edilecektir);
• sl fiyatın bizim lehimize olmaması durumunda emrin kapanacağı fiyattır (strateji, zararı durdur kullanımını ima etmiyorsa, dışarıda bırakılabilir);
• tp fiyatın gerekli yöne gitmesi, yani kar alması durumunda emrin kapanacağı fiyattır (strateji, kar al kullanımını ima etmiyorsa, dışarıda bırakılabilir);
• yorum emre yapılan yorumdur, örneğin emir verme nedenini belirtir.

Bir pozisyonu kapatmanın birkaç yolu vardır:

1. tüm pozisyonu kapatmak için
   

   CPositionInfo m_Position;
   m_Position.Select(symbol_name);
   m_Trade.PositionClose(symbol_name);

2. aynı boyutta ters emir vererek pozisyonu kapatmak için

   CTrade m_Trade;
   m_Trade.Buy(lot,symbol_name,price,sl,tp,comment);

3. daha karmaşık bir yöntem kullanarak, tüm açık pozisyonlar, daha sonra kapatılacak gerekli parametreleri (sembol, tip, sihirli sayı, pozisyon tanımlayıcı vb.) karşılayanı seçmek için ilk önce aranır.
   Yeni başlayanlar için zorluğundan dolayı yukarıdakilere herhangi bir örnek vermeyeceğim.
   
   

Hepsini Bir Araya Getirme

Artık yeni edinilen bilgileri tek bir Uzman Danışmana (EA) koymanın tam zamanı.

//+------------------------------------------------------------------+
//|                                           fast-start-example.mq5 |
//|                        Copyright 2012, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2012, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
#include <Trade\Trade.mqh>                                         //include the library for execution of trades
#include <Trade\PositionInfo.mqh>                                  //include the library for obtaining information on positions

int               iMA_handle;                              //variable for storing the indicator handle
double            iMA_buf[];                               //dynamic array for storing indicator values
double            Close_buf[];                             //dynamic array for storing the closing price of each bar

string            my_symbol;                               //variable for storing the symbol
ENUM_TIMEFRAMES   my_timeframe;                             //variable for storing the time frame

CTrade            m_Trade;                                 //structure for execution of trades
CPositionInfo     m_Position;                              //structure for obtaining information of positions
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int OnInit()
  {
   my_symbol=Symbol();                                      //save the current chart symbol for further operation of the EA on this very symbol
   my_timeframe=PERIOD_CURRENT;                              //save the current time frame of the chart for further operation of the EA on this very time frame
   iMA_handle=iMA(my_symbol,my_timeframe,40,0,MODE_SMA,PRICE_CLOSE);  //apply the indicator and get its handle
   if(iMA_handle==INVALID_HANDLE)                            //check the availability of the indicator handle
   {
      Print("Failed to get the indicator handle");              //if the handle is not obtained, print the relevant error message into the log file
      return(-1);                                           //complete handling the error
   }
   ChartIndicatorAdd(ChartID(),0,iMA_handle);                  //add the indicator to the price chart
   ArraySetAsSeries(iMA_buf,true);                            //set iMA_buf array indexing as time series
   ArraySetAsSeries(Close_buf,true);                          //set Close_buf array indexing as time series
   return(0);                                               //return 0, initialization complete
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   IndicatorRelease(iMA_handle);                             //deletes the indicator handle and deallocates the memory space it occupies
   ArrayFree(iMA_buf);                                      //free the dynamic array iMA_buf of data
   ArrayFree(Close_buf);                                    //free the dynamic array Close_buf of data
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   int err1=0;                                             //variable for storing the results of working with the indicator buffer
   int err2=0;                                             //variable for storing the results of working with the price chart
   
   err1=CopyBuffer(iMA_handle,0,1,2,iMA_buf);               //copy data from the indicator array into the dynamic array iMA_buf for further work with them
   err2=CopyClose(my_symbol,my_timeframe,1,2,Close_buf);    //copy the price chart data into the dynamic array Close_buf for further work with them
   if(err1<0 || err2<0)                                    //in case of errors
   {
      Print("Failed to copy data from the indicator buffer or price chart buffer");  //then print the relevant error message into the log file
      return;                                                               //and exit the function
   }

   if(iMA_buf[1]>Close_buf[1] && iMA_buf[0]<Close_buf[0])   //if the indicator values were greater than the closing price and became smaller
     {
      if(m_Position.Select(my_symbol))                     //if the position for this symbol already exists
        {
         if(m_Position.PositionType()==POSITION_TYPE_SELL) m_Trade.PositionClose(my_symbol);  //and this is a Sell position, then close it
         if(m_Position.PositionType()==POSITION_TYPE_BUY) return;                              //or else, if this is a Buy position, then exit
        }
      m_Trade.Buy(0.1,my_symbol);                          //if we got here, it means there is no position; then we open it
     }
   if(iMA_buf[1]<Close_buf[1] && iMA_buf[0]>Close_buf[0])  //if the indicator values were less than the closing price and became greater
     {
      if(m_Position.Select(my_symbol))                     //if the position for this symbol already exists
        {
         if(m_Position.PositionType()==POSITION_TYPE_BUY) m_Trade.PositionClose(my_symbol);   //and this is a Buy position, then close it
         if(m_Position.PositionType()==POSITION_TYPE_SELL) return;                             //or else, if this is a Sell position, then exit
        }
      m_Trade.Sell(0.1,my_symbol);                         //if we got here, it means there is no position; then we open it
     }
  }
//+------------------------------------------------------------------+

Uzman Danışmanımızı (EA) aşağıdaki parametrelerle test edelim:

• sembol - EURUSD;
• zaman dilimi - H1;
• alım satım modu "Yalnızca açılış fiyatları". 

Birinci çubuktan başlayan gösterge değerlerini ve kapanış fiyatlarını kullandığımız için (sıfır çubuk güncel, aktif bir çubuktur), grafik yeniden çizilmeyecektir. Bu, "Yalnızca açılış fiyatları" alım satım modunu kullanabileceğimiz anlamına gelir. Bu, test kalitesini etkilemeyecek ancak daha hızlı çalışmasını sağlayacaktır.

Ve işte geçmiş verileri kullanan hızlı test sonuçları. 

   Şekil 6. Uzman Danışman test sonuçlarımız

Dezavantajlar kesinlikle gözden kaçmaz. Ancak bu makale, minimum düşüşle büyük kar potansiyeline sahip olacak bir "süper Uzman Danışman (EA)" programlamayı amaçlamamış, bunun yerine temel bilgilerle donanmış bir EA'nın ne kadar kolay yapılabileceğini göstermeyi amaçlamıştır.
Yüz satırdan daha az koddan oluşan Uzman Danışmanımız (EA) var.
 

Sonuç

Bu makale, bir EA'yı programlarken göz önünde bulundurulması gereken ana ilkeleri kapsamaktadır. Çeşitli fonksiyonlar hakkında bilgi almak için MetaEditor 5'teki yerleşik bağlam Yardımını nasıl kullanacağımızı öğrendik, genel emirler ve pozisyonlar hakkında fikir sahibi olduk ve standart kitaplıkların kullanımını benimsedik.