Aprendiendo MQL5 de principiante a profesional (Parte I): Comenzamos a programar

Introducción

A veces recibo mensajes personales de personas que quieren aprender a escribir sus propios asesores o indicadores. Y, a pesar de que tanto en este sitio web como en la Web en general hay mucho material, incluyendo material muy bueno, a la gente le falta algo. Algunos quieren ver más coherencia en la presentación, otros claridad, otros algo más.... A veces piden: "Comente el código de un asesor que funcione, ¡lo entenderé todo y haré uno yo mismo!"... Pero cuando ven cien líneas de código, se asustan, se confunden y dicen: "Oh vamos, esto es demasiado complicado... Será mejor que usted mismo me escriba el asesor".

No obstante, sí que es cierto que el deseo de "entenderlo todo" de algunas personas nunca desaparece, y entonces puede resultar útil algún tipo de guía paso a paso, de lo sencillo a lo complejo. Sin embargo, no existe una guía paso a paso para MQL5.

Todos los manuales (los que yo conozco) dan por sentado que el lector ya tiene ciertas nociones de programación y entiende cómo funciona esta, por lo que bastará con explicarle algunos matices para que todo le salga bien.

Así, hoy empezamos esta serie de artículos solo para principiantes, para aquellos que se encuentran con la programación por primera vez pero quieren entenderla. Aquí pretendemos guiar a los tráders que quieren dejar de depender de los programadores y entender cómo funciona todo al nivel de un "usuario seguro" del lenguaje MQL5.

Y este lenguaje no solo permitirá automatizar el trading, sino también resolver otras tareas relacionadas de los tráders. Por ejemplo, podrá usarlo para dibujar indicadores, resultados de optimización, cualquier forma no estándar, etc.; crear cualquier archivo, por ejemplo, listas de cotizaciones de ticks o capturas de pantalla de la situación comercial actual, enviar mensajes a Telegram y otros bots, trabajar con bases de datos, y mucho más.

Poco a poco, desvelaremos las máximas posibilidades del lenguaje: el uso de "símbolos virtuales", el trabajo con bibliotecas matemáticas, y... muchas otras cosas. Pero aquí y ahora, empezaremos por lo básico.

Términos técnicos clave

Casi todos los ordenadores modernos se basan en la arquitectura Von Neumann. Y para leer con éxito la bibliografía, deberá entender los términos que utilizan los programadores.

• Unidad Central de Procesamiento (o simplemente "Procesador" o CPU). Este módulo se encarga de todos los cálculos y la lógica.
• Memoria Operativa (a menudo denominada simplemente "Memoria" o RAM). En la memoria se almacenan los datos y los programas. Cuando se apaga el ordenador o se finaliza un programa, los datos de la RAM son eliminados.
  
• Dispositivos de almacenamiento externo (discos duros, unidades flash, SSD...) El procesador puede escribir datos en ellos en forma de archivos.
  
• Archivos: información guardada en un soporte externo (no en la memoria RAM).
• Flujo de ejecución. Durante su funcionamiento, el procesador toma datos de la memoria, "entiende" si se trata de una instrucción o de datos, ejecuta la instrucción y escribe los resultados en la memoria o en el dispositivo externo indicado por el programa en ejecución. A continuación, vuelve a leer el siguiente fragmento de memoria, y así sucesivamente hasta que el programa finaliza. Todo este proceso se denomina "flujo de ejecución".
  

Para medir la información, se han ideado algunas magnitudes especiales.

• Un bit es la unidad más pequeña de información. En esencia, se trata de un "interruptor" que determina el estado de un fragmento de memoria concreto y minúsculo. Contiene, o bien un "0" ("off"), o bien un "1" (on).
• Byte, del inglés se puede traducir como "sílaba", y es el "paquete" mínimo de información igual a 8 bits. Cuando los ordenadores eran grandes y ocupaban pisos enteros, y la RAM era diminuta y los archivos se almacenaban en tarjetas perforadas, los 8 bits demostraron ser el compromiso técnico más conveniente entre la velocidad (¡se pueden leer hasta 8 agujeros a la vez!) y el tamaño del soporte.
  

A veces resulta importante que un programador sepa cuánto espacio ocupará su programa. En el mundo moderno, los programas (y sobre todo sus datos) suelen "pesar" bastante, así que a la palabra "byte" se le añaden prefijos "ampliadores".

Al medir cantidades físicas en lugar de informativas, cada prefijo de este tipo multiplica por 1000 el tamaño anterior. Por ejemplo, un kilómetro equivale a 1 000 metros y un megavoltio a 1 000 kilovoltios o 1 000 000 de voltios.

Cuando hablamos específicamente de datos informáticos, cada tamaño es 1024 veces mayor que el anterior .

Así, un kilobyte (Kbyte, KB,) equivale a 1024 bytes, un megabyte (Mbyte, MB) contiene 1024 kilobytes), y así sucesivamente.

Los siguientes prefijos en orden serían: giga-, tera-, peta-....

En próximos artículos, mucho más adelante, nos ocuparemos de cómo los programadores gestionan la memoria, de los comandos al procesador, de la escritura de archivos usando MQL5 y de otras cosas rutinarias.

Los términos en negrita se encontrarán constantemente en los artículos, por lo que los describimos aquí al principio. Presentaremos el resto de términos en el momento en que sean necesarios. No prescindiremos de ellos en absoluto, pero intentaremos reducirlos al mínimo.

Qué programas se necesitan para empezar a programar en MQL5

Para que un ordenador resulte útil a la gente, hay que escribir un programa para cada actividad: para comerciar, mirar fotos, escuchar música...

Escribir programas directamente en comandos del procesador... es posible, pero muy improductivo.

Por eso, en el mundo moderno se han desarrollado muchos programas de ayuda para convertir textos escritos en lenguajes cercanos al humano en comandos comprensibles para los procesadores.

Aquí vemos una lista mínima de este tipo de programas para programadores:

1. Editor de texto: Es el programa que usará para escribir su código. Cualquiera que le guste servirá, siempre que no añada caracteres propios además del texto que está escribiendo. Resulta muy cómodo cuando el editor es capaz de resaltar la sintaxis del lenguaje que necesita (en este caso - MQL5).

   Al instalar MetaTrader, se instala automáticamente en el sistema un editor muy potente, llamado MetaEditor. Este puede hacer todo lo que necesite que haga.

   No obstante, si no le gusta por alguna razón, es libre de elegir cualquier otra cosa. Por ejemplo, un editor muy popular entre los programadores es Visual Studio Code (VSCode). También se puede configurar para que funcione con MQL5, utilizando para ello plugins.

2. Compilador: Un compilador convierte el texto escrito por un programador en un editor en código máquina. Solo después de la conversión el procesador podrá ejecutar este código.

   Para MQL5, el compilador está integrado en MetaEditor. Para otros lenguajes, como C++, el compilador puede ser un programa aparte.

   Algunos lenguajes, como Python, carecen de un compilador explícito. Estos ejecutan directamente el texto de su archivo.

   El programa que lee los archivos de estos lenguajes se denomina "intérprete", y los propios lenguajes, "interpretados". Sin embargo, resulta importante considerar que incluso los intérpretes acaban ejecutando exactamente el código máquina. Lo que sucede es que las conversiones de texto a código no se producen de forma tan explícita.
   

3. Depurador: Es una herramienta para encontrar y corregir errores en su programa. Le permite ejecutar código paso a paso y comprobar los datos con los que trabaja su programa en cada momento y en cada paso.

   MetaEditor tiene un depurador incorporado.

4. Sistema de control de versiones (Version Control System, VCS): Le ayudará a monitorear los cambios en su código.

   Si ha escrito mucho código y de repente se da cuenta de que la versión que tenía hace un día funcionaba mucho mejor y que debería tomar otro camino, el VCS le permitirá "retroceder" al estado anterior de un archivo (o incluso de todo el proyecto) literalmente en unos pocos clics o comandos de texto desde el teclado.

   Y, lo que es más importante, la mayoría de las veces el VCS guarda los datos en un servidor remoto y no en su ordenador local, lo cual garantiza que si se produce un fallo (por ejemplo, en el disco duro), usted pueda restaurar rápidamente su trabajo.

   Estos dos importantes factores han hecho que los distintos sistemas de control de versiones sean prácticamente obligatorios para el trabajo corporativo, ya que permiten, entre otras cosas, la cooperación con otros desarrolladores. No obstante, el hábito de utilizar estos medios resulta de gran ayuda también al trabajar de forma independiente, ya que se dan casos distintos.

   Existen herramientas de terceros, como por ejemplo Git.

   Sin embargo, esta herramienta también está incorporada en el MetaEditor, y las capacidades del VCS incorporado serán suficientes para un principiante en sus primeras experiencias.

Se trata de un conjunto de herramientas sin el que es muy difícil imaginar la programación moderna. A veces ocurre que los programadores usan todas estas herramientas por separado, pero en el mundo actual, esto es relativamente raro. Más usados son programas como MetaEditor, que incluye todas estas funciones (e incluso más) a la vez.

Los programas que incluyen todos los componentes anteriores (editor de texto, compilador, depurador, etc.) se denominan Entorno de Desarrollo Integrado (IDE).

Principales tipos de programas MQL

Los programas ejecutados en MetaTrader pueden dividirse en cuatro tipos:

1. Scripts. Puede mostrar cualquier información, comerciar, mostrar objetos gráficos... Pero para que un script se ejecute, deberá volver a ejecutarse cada vez.
   
2. Indicadores. Diseñado para mostrar cierta información importante para la estrategia comercial en cada tick. Sin embargo, no sabe cómo negociar por su cuenta.
3. Asesores (también conocidos como "expertos"). Son programas diseñados para el trading. Al igual que los indicadores, se ejecutan en cada tick, pero en ellos las herramientas para dibujar todo tipo de flechas vistosas o líneas útiles están cortadas.
4. Servicios. A diferencia de los tipos de programas anteriormente mencionados, los servicios no requieren un horario específico para funcionar. Se inician una vez con el arranque del terminal. Podemos hacer que permanezcan en la memoria hasta que se cierre el terminal (e incluso durante algún tiempo después), pero estos no saben cómo reaccionar ante eventos del terminal como un nuevo tick o un clic del ratón.

Comparación de los programas disponibles en MQL5

Todo lo relacionado con el uso de programas en MQL5 se puede resumir en una simple tabla:

Tabla 1. Comparación de las capacidades de los principales tipos de programas MQL5.

Características del programa	Scripts	Indicadores	Asesores	Servicios
Vinculado a un horario específico	sí	sí	sí	no
Puede negociar	sí	no	sí	sí
Se descarga de la memoria al cambiar el intervalo temporal	sí	sí	sí	no
Se ejecuta en cada tick	no	sí	sí	no
Se activa una vez al abrir el terminal	no	no	no	sí
Funcionan mientras la ventana del gráfico esté abierta	no	sí	sí	no
Puede procesar varios eventos del terminal o el gráfico	no	sí	sí	no
Puede iniciar y detener el temporizador	no	sí	sí	no
Las funciones de inicialización y desinicialización se llaman automáticamente	no	sí	sí	no
Solo se puede ejecutar un ejemplar de un programa en un gráfico	sí	no	sí	—

Funciones

Todo programa tiene que hacer algo, es decir, ejecutar alguna función.

Cualquier función supone un conjunto de acciones de un programa que conducen a algún resultado (a menudo elemental). Por ejemplo, imprimir una línea de texto, dibujar una letra, abrir una transacción...

Algunos lenguajes de programación no requieren que las funciones se describan de forma explícita. En MQL5, esta descripción es obligatoria: cada programa debe tener al menos una función de inicio descrita, de lo contrario se dará un mensaje de error. Aunque las funciones iniciales se llamarán de forma distinta para cada tipo de programa, en cualquier caso el programa debe tener funciones, de lo contrario carecerá de sentido, ya que no hará nada en absoluto.

Casi cualquier lenguaje de programación le permite crear sus propias funciones personalizadas para aislar trozos de código que son repetitivos y luego reutilizar dichos trozos con una sola línea en lugar de reescribirlos una y otra vez. Además, cualquier lenguaje tiene siempre un conjunto de funciones predefinidas. Precisamente estas funciones predefinidas distinguen a un lenguaje de programación de todos los demás.

En realidad, la historia del lenguaje se reduce a que los autores intentan describir de una forma u otra qué funciones están predefinidas en él y cómo utilizarlas de la mejor manera para obtener un resultado útil para el usuario.

Y MQL5 no es una excepción. Contiene un conjunto de funciones incorporadas y permite crear otras funciones personalizadas. Resulta muy cómodo utilizar la ayuda contextual para estudiar las funciones incorporadas del lenguaje. Para llamarlo, basta con abrir cualquier código (incluso de otra persona) en el MetaEditor, clicar en cualquier palabra resaltada y pulsar <F1>.

Ciertas funciones incorporadas no pueden llamarse desde algunos tipos de programas. Algunas, como ya hemos mencionado, deben aplicarse exactamente como se describe en la ayuda, siendo además necesarias distintas funciones en diferentes tipos de programas.

Por lo demás, podemos considerar que nuestra creatividad no tiene límites. Podremos crear cualquier función auxiliar, organizarla como queramos e incluso utilizar funciones descritas con otros lenguajes como C++ o Python. Nos aseguraremos de volver sobre estas características en futuros artículos,

pero ahora empezaremos por lo más sencillo que nos permite crear el lenguaje MQL5: vamos a crear un script que se ejecutará una vez cuando es arrastrado a un gráfico con el ratón. Usando una función MQL estándar en este script, simplemente mostraremos al usuario un mensaje de texto ordinario en el panel estándar en la parte inferior del terminal.

Inicio y configuración del IDE

Bueno, ya llegamos a la parte práctica. Realizaremos todo el trabajo en MetaEditor. Puede iniciarse usando un acceso directo (en el escritorio o en el menú Inicio) o directamente desde el terminal MetaTrader, de una de las formas que se muestran en la imagen (figura 1).

.

Figura 1. Tres formas de llamar al MetaEditor: 1 - botón de la barra de herramientas, 2 - menú, 3 - tecla de acceso rápido (F4)

Cuando aparezca la ventana del editor, le recomiendo que introduzca directamente su nombre de usuario y contraseña de mql5.com (o, si aún no está registrado, hágalo). El registro le permitirá guardar tus proyectos directamente en el servidor usando el programa de control de versiones integrado en el MetaEditor. Nadie verá sus archivos guardados a menos que le otorgue acceso, por lo que guardar su trabajo en la nube de MetaQuotes es tan seguro como puede serlo almacenar información en Internet, y es una buena práctica (guardar su trabajo no solo en su ordenador).

Figura 2. Ventana de diálogo de autorización en la comunidad MQL5.com

Para acceder a la ventana de diálogo de autorización, seleccione "Herramientas -> Configuración" en el menú principal de la ventana del editor y clique en la pestaña "Comunidad". Este ajuste deberá hacerse una vez. Además, los datos introducidos se guardarán y podrá trabajar con el sistema de control de versiones y otros servicios MQL útiles sin tener que pensar en la autorización durante mucho tiempo.

Primer script

Y ahora... Bastará con clicar con el botón derecho del ratón en la carpeta del panel izquierdo en la que queremos crear el script y seleccionar "Nuevo archivo"... O el atajo de teclado <Ctrl>+<N>... Seleccione "Script" en la ventana que aparecerá; luego, en la ventana siguiente, deberá introducir el nombre del archivo...

Figura 3. Métodos para crear un nuevo archivo.

Figura 4. Ventana de diálogo del "asistente" de creación de archivos — selección del tipo de programa a crear.

Figura 5. Ventana de diálogo del "asistente" para la creación de archivos — introducimos el nombre del programa a crear.

El resultado será una nueva ventana con un contenido como éste:

//+------------------------------------------------------------------+
//|                                                   HelloWorld.mq5 |
//|                                       Oleg Fedorov (aka certain) |
//|                                   mailto:[e-mail] |
//+------------------------------------------------------------------+
#property copyright "Oleg Fedorov (aka certain)"
#property link      "mailto:[e-mail]"
#property version   "1.00"
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//---
   
  }
//+------------------------------------------------------------------+

Ejemplo 1. Plantilla de script generada por el "asistente".

No parece nada complicado, son solo 17 líneas; podemos abarcarlas de un solo vistazo...

Veamos qué pone aquí exactamente.

• En primer lugar, hay varias líneas que comienzan con caracteres de doble barra ( // ). Líneas similares van en el centro del programa.

Son los comentarios. Están escritos para los humanos, y el compilador los desechará por completo al generar el código de bytes. Los comentarios que comienzan con una barra doble se denominan comentarios de una línea. Deben colocarse al final de la línea. La regla es muy simple: todo lo que esté antes de la doble barra será considerado código por el compilador, todo lo que esté después será considerado texto humano.

En esta plantilla creada por el asistente, el código de "antes" simplemente no era necesario en este contexto.

En el MetaEditor puede comentar rápidamente varias líneas: selecciónelas y pulse la combinación de teclas " <Ctrl>+< ' > (control+ apóstrofo). Para descomentar estas líneas, selecciónelas de nuevo y pulse la combinación <Ctrl>+< ; >

También hay comentarios multilínea. Comienzan con los caracteres " /* " y terminan con la secuencia inversa " */ ". Los comentarios multilínea pueden insertarse en cualquier lugar del código donde estén permitidos los espacios. Al realizar la compilación, el compilador también "descarta" primero este tipo de secuencias y luego intenta averiguar "qué quería decir el autor".

En la práctica, los comentarios rara vez se insertan en mitad del código. La mayoría de las veces, resulta un inconveniente. Pero comentar grandes bloques de código innecesario o describir "encabezados" de funciones con su ayuda es un placer.

A esto podría parecerse el "encabezado" de este archivo usando un comentario de varias líneas (si lo escribimos por nosotros mismos, en lugar de usar la automatización del MetaEditor):

/*
                                                   HelloWorld.mq5 
                                       Oleg Fedorov (aka certain) 
                                   mailto:[e-mail] 
*/

Ejemplo 2. Comentarios multilínea.

O así:

/*******************************************************************
 *                                                  HelloWorld.mq5 *
 *                                      Oleg Fedorov (aka certain) *
 *                                  mailto:[e-mail] *
 *******************************************************************/

Ejemplo 3. Comentarios multilínea decorados.

En general, cualquier texto en cualquier lenguaje puede ir entre /* y */ (o después de // ), ya que los editores modernos soportan la codificación Unicode en su totalidad. Pero sigue siendo recomendable usar el inglés, porque ahorra tiempo en el cambio de diseño (y en proyectos grandes es fundamental).

• El segundo bloque que llama la atención son las líneas que empiezan por el signo " # ". En este archivo, las palabras iniciales en cada línea de este bloque serán #property.

En general, toda palabra que empiece por un carácter de rejilla será una directiva de preprocesador. El compilador no solo deberá desechar todos los comentarios antes de convertir el texto en código máquina, también deberá hacer otros preparativos. El trabajo preparatorio suele ser bastante, porque en los proyectos grandes hay que montar el proyecto partiendo de varios archivos, definir algunos datos (normalmente constantes como el número π o algo similar, aunque hay casos más complicados), etc. Pero nos ocuparemos de todas estas directivas mucho más adelante,

por ahora, para entender el código obtenido, bastará con saber que la directiva #property describe alguna propiedad del programa obtenido. Lo más frecuente es que estas "propiedades" afecten a la ventana inicial, que aparece justo después de que el usuario inicie nuestro programa arrastrando su icono al gráfico.

Para ilustrarlo, vamos a añadir una línea más al código:

#property copyright "Oleg Fedorov (aka certain)"
#property link      "mailto:[e-mail]"
#property version   "1.00"
#property script_show_inputs

Ejemplo 4. Añadimos la propiedad script_show_inputs.

Esta línea nos permitirá mostrar la ventana de propiedades, y solo entonces empezar a ejecutar el código principal. Si esta línea no está presente, el script comenzará a ejecutarse directamente sin mostrar ningún mensaje. Los parámetros, si los hay, los utilizará con valores por defecto.

Así que, tras escribir la línea necesaria en el lugar correcto del archivo (justo después de la propiedad version), realizaremos la primera compilación de nuestro programa.

Seleccione uno de los métodos que se muestran en la figura (por ejemplo, pulse la tecla <F7>).

Figura 6. Diversas formas de compilar un programa.

Apenas unos segundos de espera... Y aquí tenemos el programa compilado (figura 7).

Figura 7. Resultados de la compilación. En este caso, la compilación se ha realizado correctamente (0 errores), ha tardado 527 milisegundos y el código de bytes se ha creado para un procesador de 64 bits.

En la figura 9 se puede ver que la compilación se ha realizado correctamente. Si hubiera errores en el archivo de texto, los mensajes sobre ellos irían a esa misma ventana.

Tras la compilación, el icono del script aparecerá automáticamente en la lista de scripts de su terminal comercial. Para cambiar al terminal, puede pulsar, por ejemplo, la tecla <F4> en el editor. Así ahorrará tiempo.

Ahora arrastraremos el script al gráfico y nos admiraremos con la ventana de propiedades.

Figura 8. Ventana de parámetros del script.
(1)En la esquina superior derecha de la ventana principal se representa el icono del script en ejecución.
(2) La pestaña "General" muestra cómo se utilizan las propiedades descritas mediante las directivas #property.
(3) El MetaEditor ha añadido parámetros adicionales a la dirección especificada en la propiedad "link".
Probablemente para que si el enlace es a un sitio web, pueda ayudar a entender de dónde vienen los visitantes.

Luego cerremos la ventana, volvemos al editor e intentamos persuadir al script para que haga algo útil, como mostrar un mensaje al usuario.

Para ello, comentamos la línea que muestra la ventana de parámetros (aún no tenemos nada que cambiar, ¿verdad?) y añadimos otra línea que escriba un mensaje:

//+------------------------------------------------------------------+
//|                                                   HelloWorld.mq5 |
//|                                       Oleg Fedorov (aka certain) |
//|                                   mailto:[e-mail] |
//+------------------------------------------------------------------+
#property copyright "Oleg Fedorov (aka certain)"
#property link      "mailto:[e-mail]"
#property version   "1.00"
//#property script_show_inputs

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//---
   Print("Hello, MQL5 world!");
  }
//+------------------------------------------------------------------+

Ejemplo 5. Script que envía una línea al registro de usuario.

• Ahora prestaremos atención a las palabras predefinidas.

Las palabras #property, copyright, link, version, void, OnStart, Print están predefinidas en este código. Pruebe a clicar en cualquiera de ellas en el MetaEditor y pulse <F1> para que aparezca la ayuda incorporada.

• Dentro de la función OnStart generada por el asistente, llamaremos a otra función estándar, Print, y utilizando los parámetros (también conocidos como argumentos) listados entre paréntesis, le indicaremos qué imprimir.

En el ejemplo 5, la función Print solo toma un argumento: el texto escrito entre comillas. No obstante, puede haber más de un argumento de este tipo. Así, podemos llamar a la misma función Print con cualquier número de parámetros (hasta 64).

Si una función necesita transmitir varios parámetros, estos deberán enumerarse mediante una coma, como en el ejemplo 6:

Print("Привет, мир MQL5!", " Я написал собственную программу. ", "Ура!");

Ejemplo 6. Función que acepta tres parámetros

Después de cada coma que separa los parámetros entre sí, puede añadir un carácter de salto de línea (tecla <Enter>) para evitar comillas confusas.

Y fíjese también en los espacios dentro del segundo argumento. La cuestión es que la función Print "fusiona" sus argumentos en una gran línea, por lo que el programador deberá ocuparse él mismo de todos los signos de puntuación y separadores adicionales entre palabras.

La función OnStart se ejecuta automáticamente (una vez) cuando se inician los scripts y los servicios.

La compilamos y ejecutamos de la forma ya conocida.

Figura 9. El primer trabajo útil: mostrar una línea en el registro.

Conclusión

Los expertos y los indicadores también tienen funciones predefinidas, pero con nombres distintos. Su principio es el mismo que el de las funciones de script: nuestro código se escribe mayoritariamente dentro, mientras que las propiedades se escriben fuera. Sin embargo, hay diferencias.

Por ejemplo, algunas funciones en asesores e indicadores son ejecutadas por el terminal en cada tick , no una vez, como OnStart.

Así que sugiero a quienes quieran comprobar lo que han aprendido en el artículo (y para consolidar sus conocimientos) que hagan un poco de "investigación casera" por su cuenta:

1. Use el asistente de archivos para generar todos los demás tipos de programas no contemplados en los ejemplos de este artículo.
   
2. Piense si puede usar las herramientas descritas en este artículo para averiguar qué funciones se llaman y en qué orden al inicio de cada tipo de programa.
3. Para los curiosos: usted puede probar lo que sucede si:
   
• añadimos la función OnStart a los indicadores y asesores;
• añadimos a los scripts y servicios las funciones que el asistente creará para otros tipos de programas;
  

Tal vez estos estudios le aporten nuevas ideas, y tal vez comprenda más profundamente cómo funcionan exactamente los programas MQL5.

Le deseo mucho éxito. ¡Nos vemos pronto en los próximos artículos de la serie!