Como se tornar um bom programador (Parte 6): 9 hábitos para desenvolver de maneira produtiva

Introdução

Como programadores, podemos adquirir alguns hábitos para nos ajudar a manter o foco o tempo todo enquanto estamos criando código. Pode ser que estejamos sentados, trabalhando em algo, mas a eficiência do processo está longe de ser a ideal. As razões podem ser variadas, como a falta de foco, a ausência de um plano, ou um plano errado.

Sumário:

• Planejando o projeto antes da fase de desenvolvimento
• Criando uma coleção de snippets de código
• Cronograma
• Planejando dias de trabalho intensivo
• Criando pequenas funções e testando
• Adicionando comentários para trabalho futuro
• Digitação às cegas
• Usando as melhores ferramentas
• Controle de versão

Atenção!

Todos os trechos de código e exemplos utilizados no artigo são apenas para fins de demonstração. Para alguns deles, não foram realizados testes/depurações. Eles são usados apenas para ilustrar ideias. Se você decidir usar qualquer código, use-o por sua própria conta e risco.

1. Planejando o projeto antes da fase de desenvolvimento

Se você perguntar a 100 programadores se eles fazem um plano de trabalho antes de começarem a programar, menos de dez responderiam que sim.

Afinal, ser capaz de elaborar um bom plano é uma habilidade importante para um desenvolvimento produtivo.

Você vai pegar transporte público, digamos, um ônibus, sem saber para onde está indo? Tenho certeza que não.

Antes de começar a escrever o código, anote o tipo de programa que deseja, as ferramentas e bibliotecas que deseja utilizar nele, etc.

Na seção Freelance existe um guia, termos de referência. Este também é um exemplo de planejamento, e todo desenvolvedor deveria ter tal plano antes de iniciar o desenvolvimento.

Podemos empregar qualquer programa padrão, por exemplo Microsoft Word, WPS ou, se der mais jeito, escrever o plano com uma caneta no papel. Podemos fazer diagramas e figuras explicando como funcionará.

Eu concordo absolutamente com Charles Kettering, que disse: "Um problema exposto com clareza já fica meio resolvido”.

Por exemplo, podemos criar um EA Simple Grid com controle de capital baseado no sistema Labouchere.

Este é um plano de trabalho simples.

Observação: todos os valores iniciais abaixo podem ser otimizados/eles são variáveis de entrada

Valores iniciais: Lotsize = 0.01; xgrid = 100; LotIncrement = 0.01;

Minha estratégia	Fórmula para calcular o tamanho do lote por tipo de posição	Condições da rede (estratégia em termos mais claros)	Controle de capital	Bibliotecas
Condição 1. Se não houver posições abertas, abrimos duas posições - uma para compra, a segunda para venda.	X = Lotsize + (LotIncrement * Número de posições por tipo de posição)  Exemplo: BuyLotsize = 0.01 + ( 0.01 * Número de posições de compra);	A condição de compra é atendida quando o número de posições de compra = 0 (zero) ou quando já existem posições de compra e o preço Bid é inferior <preço de abertura da última posição de compra> menos xgrid puntos	StopLoss = 0 (por padrão)	Biblioteca padrão — classes de posições Biblioteca padrão — informações sobre o símbolo Biblioteca padrão — classes de negociação
Condição 2 (condição de venda). Se o preço percorrer xgrid puntos para cima em relação ao preço de abertura da última posição de venda, devemos abrir uma posição de venda com Lotsize igual ao tamanho do lote da posição Lotsize anterior  mais LotIncrement.		A condição de venda é atendida quando o número de posições de venda = 0 (zero) ou quando já existem posições de venda e o preço Ask é maior <preço de abertura da última posição de venda> mais xgrid puntos	TakeProfit = 100 (por padrão)
Condição 3 (condição de compra). Se o preço percorrer xgrid puntos para baixo em relação ao preço de abertura da última posição de compra, devemos abrir uma posição de compra com Lotsize igual ao tamanho do lote da posição Lotsize anterior  mais LotIncrement.

Inclusive com um plano tão simples, será muito mais fácil do que começar sem uma imagem clara e tentar entender as coisas à medida que avançamos. Um bom plano ajudará a identificar áreas que podem precisar ser afinadas ou revisadas.

Convém dar início a qualquer projeto elaborando um plano de trabalho. E quanto mais detalhado melhor.

2. Criando uma coleção de snippets de código

Muitas vezes as mesmas funções ou classes são usadas em diferentes programas, Expert Advisors, indicadores ou scripts. Nesse caso, torna-se muito conveniente criar uma coleção com os códigos dessas função e usá-los em projetos, em vez de criá-los do zero a cada vez. É neste ponto que as habilidades de programação orientada a objetos são úteis (POO).

No exemplo acima, pode-se ver no plano que deveremos criar duas funções no EA: 

1. Função para contar posições por tipo
2. Função para obter o preço de abertura da última posição por tipo de posição

Estas funções são utilizadas em quase todos os EAs, por isso podemos criar uma arquivo include (.mqh), nomeá-lo, digamos, gridmodule e salvar tais funções nele. Assim, podemos anexá-las ao arquivo nativo .mq5.

Conteúdo 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;
 }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+

A implementação desse tipo de uso tem muitas vantagens. Por exemplo, facilitará a depuração de código, porque você já terá funções de depuração prontas e haverá menos código para depuração no arquivo nativo .mq5.

3. Cronograma

Um cronograma diário ajuda o cérebro a se sintonizar com os períodos propícios e geralmente aumenta a produtividade. Além disso, ao seguir uma rotina, você dedicará consistentemente um certo tempo à programação dia após dia.

Por exemplo, você poderia indicar claramente o horário de início: das 08:00 às 11:00 horas sem interrupção.

Se você se ater à rotina, após algumas semanas ou meses você pode notar que seu cérebro já se ajusta ao trabalho em determinadas horas.

Faça um horário com o qual você se sinta confortável e com o qual você possa trabalhar.

4. Planejando dias de trabalho intensivo

Há tantas distrações nos dias de hoje. É tão difícil se concentrar numa coisa em particular se for um trabalho monótono. Você já notou que você tem apenas alguns minutos/horas por dia para estar hiperfocado.

Às vezes você precisa deste estado de espírito para lidar com as coisas, para se focar no trabalho e não se distrair com outras coisa. Para esses casos, você precisa planejar dias de trabalho intensivo.

São necessárias longas horas de trabalho árduo para concluir projetos complexos ou resolver problemas emergentes. Por isso, aconselho a todos a planejar dias em que você esteja totalmente dedicado à programação e nada o distrairá.

5. Criando pequenas funções e testando

Não vale a pena incluir muitas operações numa única função. Se você estiver programando operações básicas, é melhor escrever uma nova função do que adicionar uma a uma já existente.

Então, se você adicionar um monte de loops a uma função Ontick (ou a qualquer outra função importante ou não tão importante), não haverá como fugir desse problema. É como remover o pino de uma granada que está no seu bolso.

Colocar toda a lógica em um só lugar e transformar algoritmos simples em complexos é uma das melhores maneiras de obter erros, que lhe custarão dinheiro e o recurso mais valioso de sua vida - seu tempo.

Acredito que a programação deve ser divertida, para que você não queira desistir dela. Não há nada de interessante nos algoritmos complicados, por mais experiente ou inteligente que seja o leitor de tal código. Confie a uma função uma ação. Além disso, deixe que cada função tenha um nome claro e fácil de ler, que permita ver o que faz.

Olhemos para a função CountPositions com o argumento para o tipo de posição do exemplo 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;
 }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+

Somente olhando para o nome da função, todos entendem que ela é projetada para contar posições por tipo, e isso é exatamente o que a função faz, nem mais, nem menos.

6. Adicionando comentários para trabalho futuro

Os comentários podem parecer insignificantes - por que perder tempo com eles? Mas quando usadas corretamente, elas se tornam simplesmente vitais.

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

Em algumas semanas ou dias, você terá esquecido a maioria das variáveis, funções e trechos de código em que você está trabalhando agora. Sem comentários que tenham sentido, pode ser difícil entender seu próprio código depois de um tempo.

Adicione comentários ao código MQL5, que o editor de código MetaEditor irá ajudá-lo a lembrar quando você retornar a ele no futuro.

O editor dará estes tipos de dicas, muito úteis.

Além disso, não se esqueça que você não está sozinho neste mundo e em seu trabalho. Imagine um código que possa ser passado a outros. Para que qualquer programador possa lê-lo e entendê-lo. Não há como contornar isso sem o uso de comentários.

7. Digitação às cegas

É muito difícil imaginar uma escrita de código eficaz sem excelentes habilidades no uso do teclado. Acredito que qualquer programador deve desenvolver e melhorar constantemente suas habilidades de digitação. E, claro, o melhor que se pode fazer é aprender a digitar às cegas, ou seja, digitar com precisão e rapidez sem olhar para o teclado.

Pense em como seu trabalho pode ser muito mais produtivo se você não tiver que tirar os olhos da tela e ficar olhando para o teclado.

Você tem que se forçar a desistir do chamado teclar com dois dedos (em inglês, hunt-and-peck) e habitue-se a digitar o código sem olhar para o teclado. Para fazer isso, precisamos desenvolver a memória muscular.

Não é fácil aprender o método de digitação às cegas, mas os benefícios são muitos. É tudo uma questão de prática.

Pessoalmente, levei algumas semanas de prática no keybr.com, é gratuito. É um site muito útil para praticar, recomendo-o a qualquer pessoa que queira aprender a digitar sem olhar para o teclado.

8. Usando as melhores ferramentas 

As ferramentas podem desempenhar um grande papel na produtividade do programador. Por isso, são necessárias boas ferramentas, mesmo que não sejam as melhores (tanto de hardware como de software) para fazer um bom trabalho.

Preste atenção às bibliotecas com as quais você está trabalhando (recomendo a biblioteca MQL5 padrão). Também é necessário acesso a informações, fontes para problemas e questões que surgem, fontes de novos conhecimentos (recomendo a leitura deste artigo). E com certeza é preciso um computador com bom desempenho e uma conexão de internet rápida e estável.

9. Controle de versão

Alguma vez você escreveu um programa, fez mudanças e depois disso você quis voltar ao código escrito antes por alguma razão?

É muito importante manter o controle das versões de código: além de poder reverter a qualquer uma das versões anteriores a qualquer momento, será possível acompanhar o progresso.

Conheço duas maneiras. A primeira é usar Git e a segunda é copiar e colar manualmente os métodos de armazenamento de código através de um arquivo de texto.

Usando o Git

Não há uma maneira rápida de aprender a usar o git, por isso, se você não está familiarizado com Git e Github, eu recomendo a leitura da documentação do git.

Usando um arquivo de texto

Crie uma pasta para seu projeto, adicione todos os arquivos necessários. Em seguida, abra esta pasta no explorador para visualizar o conteúdo da pasta (veja a imagem abaixo do meu exemplo anterior).

Após grandes mudanças no arquivo .mq5 (por exemplo, após ter adicionado uma nova função), crie um arquivo de texto. No nome, especifique a versão do código e o que foi adicionado. Veja o exemplo na imagem

Você pode abrir um arquivo de texto junto com o arquivo principal .mq5 ou .mqh e salvar tudo pressionado CTRL+F7 - o comando compilará todos os arquivos no editor. Após a compilação, os erros associados ao arquivo de texto podem ser ignorados, basta fechar o arquivo.

Conclusão

Assim concluímos este artigo. Espero que você tenha aprendido algo útil que o leve um passo adiante em direção a uma programação mais produtiva. Se você tiver alguma dica, compartilhe comigo e com outros programadores nos comentários do artigo. Todos os códigos dos exemplos estão anexados ao artigo.

Obrigado pela atenção!