Cómo ser un mejor programador (parte 06): 9 hábitos que conducen a una codificación eficaz
791
0
Introducción
Antes de comenzar a codificar, vamos a hablar de ciertos hábitos que podemos adquirir para mejorar nuestra codificación, y que sin duda nos ayudarán a mantenernos centrados todo el tiempo que dediquemos a esta tarea. La mayoría de las veces, puede que estemos codificando sin darnos cuenta de nuestra escasa eficacia debido a varias razones, como la falta de concentración, la ausencia de un plan de ejecución o la deficiencia del mismo.
Contenidos:
- Planifique su proyecto antes de codificar
- Haga una colección de fragmentos de código
- Tenga una rutina
- Programe trabajos profundos
- Cree pequeñas funciones con un solo propósito y póngalas a prueba
- Añada comentarios para su futuro yo
- El hábito de la escritura al tacto
- Use las mejores herramientas
- Haga control de versiones
Descargo de responsabilidad:
Todos los fragmentos de código y los ejemplos de codificación usados en este artículo tienen fines únicamente educativos. Algunos de ellos no se han probado/depurado meticulosamente, y se utilizan solo para aclarar mi punto de vista. Si decide usar alguno de los códigos, lo utilizará bajo su propia responsabilidad.
01: Planifique su proyecto antes de codificar
Si pregunta a 100 programadores si planean sus sistemas antes de comenzar a codificar, menos de diez le dirán que planean su trabajo antes de ponerse a escribir código en el teclado.
Este es el principal problema que debemos abordar si queremos codificar de forma eficaz.
¿Acaso usted se subiría a un autobús público sin saber a dónde se dirige? Claro que no.
Antes de comenzar a escribir código en el teclado, tendremos que escribir el tipo de programa que necesitamos, las herramientas, las bibliotecas que podríamos querer usar dentro, etc.
Existe algo llamado especificaciones de trabajo en Freelance, o lo que es lo mismo: el plan de trabajo que todo desarrollador debe tener antes de comenzar a codificar cualquier cosa.
Puede usar programas gratuitos como Microsoft Word o WPS office para planificar sus trabajos si no tiene un bolígrafo y un cuaderno o una hoja de papel. También puede dibujar diagramas e ilustraciones para describir todo lo que necesite.
Estoy totalmente de acuerdo con Charles Kettering cuando dijo que "un problema bien planteado está medio resuelto".
Por ejemplo, solo quiero crear un asesor Simple Grid con sistemas de gestión de dinero Labouchere.
Aquí tenemos un plan de trabajo simple.
Nota: todos los valores iniciales que veremos a continuación se pueden optimizar/son variables de entrada
Valores iniciales: Lotsize = 0.01; xgrid = 100; LotIncrement = 0.01;
| Mi estrategia | Fórmula de tamaño de lote según el tipo de posición | Condiciones de la cuadrícula (estrategia, pero de una forma más clara) | Gestión de dinero | Bibliotecas |
|---|---|---|---|---|
| Condición 01: Cuando no hay una posición abierta Abrimos posiciones de compra y venta (posición única para cada tipo) | X = Lotsize + (LotIncrement * Number Of Position By Position Type) Ejemplo: BuyLotsize = 0.01 + (0.01 * Number Of Buy Positions); | La condición de compra ocurre cuando el número de posiciones de compra es 0 (cero) o cuando ya hay una posición de compra y el precio Bid está por debajo del precio de apertura de la última posición de compra menos xgrid puntos | StopLoss = 0 (por defecto) | Biblioteca de clases de posiciones estándar |
| Condición 02 (Condición de venta): si el precio de mercado asciende xgrid puntos respecto a la anterior posición de venta, abrimos una posición de venta con un tamaño de lote igual a la anterior posición de venta Lotsize más el valor LotIncrement. | La condición de venta ocurre cuando el número de posiciones de venta es 0 (cero) o cuando ya hay una posición(es) de venta y el precio Ask está por encima del precio de apertura de la última posición de venta más xgrid puntos | TakeProfit = 100 (por defecto) | ||
| Condición 03 (Condición de compra): si el precio de mercado desciende xgrid puntos respecto a la anterior posición de compra, abrimos una posición de compra con un Lotsize igual al Lotsize previo más el valor LotIncrement. |
Solo con un plan de trabajo simple, podemos ver que resulta mucho más fácil ejecutar el trabajo, en lugar de comenzar a codificar con la vaga mentalidad de resolver las cosas a lo largo del camino. Un plan mejor puede ayudarnos a identificar las áreas que necesitamos aprender o recordarnos a nosotros mismos en caso de que las olvidemos eventualmente.
Antes de comenzar a codificar, asegúrese de tener un plan correctamente expuesto para su trabajo. Cuanto más claro, mejor
02: Haga una colección de fragmentos de código
Si descubre que está definiendo funciones o clases varias veces en varios programas, como asesores expertos, indicadores o scripts, probablemente necesite una colección de estos para poder reutilizarlos sin tener que definirlos una y otra vez. Para poder hacer esto de forma más efectiva, usaremos la Programación Orientada a Objetos (OOP).
En el ejemplo del plan de trabajo, hemos visto que necesitamos crear dos funciones en nuestro asesor.
- Una función para contar las posiciones según su tipo.
- Y otra para conseguir el precio de apertura de la última posición según el tipo de posición
Estas funciones son necesarias en casi todos los asesores de cuadrícula, por lo que podemos crear un archivo Include(.mqh) llamado gridmodule y guardar esas dos funciones en él para incluirlas en nuestro archivo principal .mq5.
Dentro de gridmodule.mqh
//+------------------------------------------------------------------+ //| 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; } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+
Logrará muchos beneficios haciendo esto, ya que le facilitará la depuración de su código: esta debe realizarse en un solo lugar, y nos ofrece menos código para trabajar en el archivo .mq5.
03: Tenga una rutina
Las rutinas pueden resultar excelentes a la hora de "sintonizar" el marco mental correcto para codificar, mejorando significativamente nuestra productividad en general. También es la mejor manera de ayudarnos a mantenernos comprometidos y convertirnos en programadores constante día a día.
Por ejemplo, podemos tener una rutina para codificar todos los días de 08:00 am a 11:00 am.
Respetando la misma rutina, después de varias semanas o meses, notaremos que nuestra mente se carga de buenas emociones para comenzar a codificar cada vez que conectamos en nuestro PC durante esas horas.
Cree un horario que se adapte a sus necesidades.
04: Programe trabajos profundos
Hoy en día, es muy fácil distraerse con muchas cosas. Resulta difícil concentrarse, especialmente cuando la codificación se complica. Tenga en cuenta que solo hay unos pocos momentos/horas al día en los que estamos suficientemente concentrados como para ser creativos.
Con frecuencia, nuestra mente necesita mucho tiempo de trabajo libre de distracciones para llegar a ese nivel. Para poder alcanzar ese estado, deberemos planear días en los que programaremos durante largas horas sin pausa.
Solo tras largas horas de trabajo profundo podremos llevar a buen puerto la mayor parte de las duras tareas a las que nos hemos enfrentado mientras nos dedicábamos a nuestras rutinas habituales. Recomiendo a todos los programadores que planifiquen ciertos días en los que trabajarán duro y sin distracciones.
05: Cree pequeñas funciones con un solo propósito y póngalas a prueba
Evite incluir demasiadas operaciones dentro de una función. Considere la posibilidad de crear otra función cada vez que se dé cuenta de que debe codificar una operación importante.
Tener demasiados ciclos en la función Ontick (o en cualquier otra función mayor o menor) le perjudicará en poco tiempo. Es como sacar el pasador de una granada de mano que lleva en el bolsillo.
Convertir algoritmos simples en complejos haciendo que toda la lógica aparezca a la fuerza en un solo lugar es una de las mejores formas de generar errores que le costarán dinero y el recurso más valioso en su vida, el tiempo.
Creo que la codificación tiene que ser divertida la mayor parte del tiempo, para que podamos utilizarla de forma coherente. No hay diversión alguna en los algoritmos complejos, no importa cuán experimentado e inteligente sea el lector del código. Asegúrese de que cada función realice una operación, y que tenga además un nombre de función fácil de leer y que explique claramente de qué trata la propia función.
Echemos un vistazo a la función CountPositions con un argumento para el tipo de posición del ejemplo anterior:
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; } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+
Con solo mirar el nombre de la función, cualquiera podría decir que esta solo se dedica a contar posiciones según su tipo, y precisamente eso es lo que se ha implementado en el interior de la función: ni más ni menos.
06: Añada comentarios para su futuro yo
El sencillo hábito de añadir comentarios a su código podría verse como una forma prematura de codificación, pero también puede cambiar las reglas del juego para aquellos que sepan usarlo de forma efectiva.
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
La mayoría de las variables, funciones y fragmentos de código que escribimos ahora serán olvidados dentro de varias semanas o incluso días. Sin comentarios significativos, no estaremos familiarizados con el código que hemos escrito antes (¡¡piense en lo estúpido que es eso!!).
Añadir comentarios en MQL5 permitirá que el IDE de MetaEditor nos ayude a recordar más fácilmente cada vez que queramos usarlo.
¿Por qué hacer más difíciles las ayudas de MetaEditor? Eso es un sinsentido.
No olvide que no está solo en esta carrera: siempre resultará deseable tener un código que otros desarrolladores puedan transmitir y usar fácilmente en CodeBase o de otra forma, y la única manera de conseguir esto es crear un código fácil de leer y comprender, cosa que hacen posible los comentarios.
07: El hábito de la escritura al tacto
No olvidemos que para codificar de forma eficaz necesitamos escribir bien con el teclado. Cada codificador debe esforzarse por desarrollar y mejorar sus habilidades de escritura con el mismo. La mejor manera de convertirse en un buen escritor de código es mejorar los hábitos de escritura al tacto, pulsando los caracteres correctos sin mirar el teclado.
La mayoría del tiempo, codificamos mirando el teclado y la pantalla al mismo tiempo, sin notar que supone una forma inexperta de escribir.
Debemos olvidar este hábito de escritura con dos dedos y entrenar para escribir mirando solo la pantalla. Solo lograremos esto con la escritura por memoria muscular.
Resulta un tanto difícil desarrollar este hábito, pero una vez que lo logramos, la escritura se convierte en una práctica automatizada.
Yo he sido capaz de desarrollar este hábito tras varias semanas de práctica en un sitio web gratuito llamado keybr.com: lo recomiendo encarecidamente a todo el que quiera mejorar su escritura al tacto.
08: Use las mejores herramientas
Las herramientas pueden jugar un enorme papel en la mejora de su productividad general como programador. Nunca se enfatizará lo suficiente: necesitamos mejores herramientas, si no las mejores (tanto de hardware como de software).
Asegúrese siempre de estar utilizando las mejores bibliotecas (recomiendo a todos las bibliotecas estándar MQL5). También deberemos tener las mejores fuentes de información cuando estemos atascados y necesitemos aprender y probar cosas nuevas (lea este artículo para conocer más detalles). Además de lo mencionado, necesitaremos un PC en buenas condiciones y una buena conexión a Internet.
09: Haga control de versiones
Siempre es un buen hábito tener el control de versiones de su código para poder monitorear su progreso y regresar a versiones anteriores del código en cualquier momento.
Conozco dos formas de hacer esto. La primera es utilizar Git, y la segunda, un proceso manual que implica copiar y pegar métodos de almacenamiento de código usando un archivo de texto.
b>Usando Git
Esta es una forma de reparación no-rápida que puedo enseñarle en unos minutos si no está familiarizado con Git y Github: le recomiendo leer la documentación de Git.
b>Usando un archivo de texto
Cree una carpeta para su proyecto y añada todos los archivos necesarios en ese proyecto. Luego abra esa carpeta en su explorador de archivos para ver qué hay en ella (vea la imagen a continuación de mi ejemplo anterior).
Después de realizar un cambio importante en su .mq5 como, por ejemplo, añadir una nueva función, deberá crear un archivo de texto con un nombre que especifique la versión del código y lo que ha añadido. Mire la imagen
Podrá abrir un archivo de texto junto con el archivo .mq5 o .mqh principal y guardar estos en un solo clic CTRL+F7 en Windows, que compilará todos los archivos abiertos en su editor. Después de realizar la compilación con éxito, podrá ignorar todos los errores prodecentes de ese archivo de texto y cerrarlo.
Conclusión
Eso es todo por hoy. Espero que haya aprendido algo nuevo y positivo que le lleve un paso más allá y le convierta en un mejor programador. Si echa algo en falta en el artículo, comparta sus ideas conmigo y los demás programadores en la sección de comentarios a continuación. Todo el código usado en este artículo se adjunta más abajo.
Gracias por su atención y saludos cordiales.
Traducción del inglés realizada por MetaQuotes Ltd.
Artículo original: https://www.mql5.com/en/articles/9923
Gráficos en la biblioteca DoEasy (Parte 85): Colección de objetos gráficos - añadiendo los objetos nuevamente creados
Gestionando el Horario (Parte 2): Funciones
Programamos una red neuronal profunda desde cero usando el lenguaje MQL
Gráficos en la biblioteca DoEasy (Parte 84): Clases herederas del objeto gráfico abstracto estándar
- Aplicaciones de trading gratuitas
- 8 000+ señales para copiar
- Noticias económicas para analizar los mercados financieros
Usted acepta la política del sitio web y las condiciones de uso