Como se tornar um bom programador (Parte 4): agilizando a velocidade de programação

Introdução

Todo programador sonha com produzir seu código o mais rápido possível. Ninguém quer passar uma semana escrevendo um pequeno programa ou um trecho de código, muito menos trabalhar durante horas ou mesmo dias resolvendo um problema que retarda todo o processo de desenvolvimento.

Todos os programadores querem ser mais rápidos

• Você já viu vídeos no YouTube em que alguém escreve código MQL5? Há momentos em que é quase impossível acompanhar o ritmo desse tipo de vídeo, porque você está se desenvolvendo a um ritmo muito mais lento. Porém, você quer se aproximar um pouco mais dessa velocidade.
• Alguns programadores escrevem código a uma velocidade simplesmente absurda. Eles empregam apenas alguns minutos na elaboração de um algoritmo complexo, quando para você podem ser necessárias horas ou até mesmo dias.
• Às vezes, o desejo de aprender a trabalhar com mais rapidez e produtividade está associado ao trabalho no Freelance, demonstrando ter um diferencial competitivo em relação aos concorrentes, atendendo os pedidos dos clientes mais agilmente.
• E outras vezes só queremos impressionar alguém próximo ou parceiro com nossos superpoderes para escrever código de forma rápida e eficiente, cometendo menos erros e gastando menos tempo ao desenvolver algoritmos complexos.
  
• Além disso, a velocidade pode ser particularmente importante quando precisamos lançar, por exemplo, uma atualização de um produto no Mercado com correção de bugs.

Fique à vontade, pegue uma caneta e um caderno - agora você acessará um fluxo de informações valiosas que lhe dirá como aumentar a velocidade de escrita de código e manter um resultado de alta qualidade. 

O que você NÃO vai precisar:

• Ampla experiência em desenvolvimento
• Teclado de última geração
• Forte habilidade de teclar às cegas
• Memória robusta, muitos núcleos ou uma poderosa unidade de processamento gráfico

Programador rápido Vs codificador rápido

Em primeiro lugar, gostaria de explicar a diferença entre dois conceitos que uso no artigo: programador e codificador.

Programador

Codificador

Os programadores têm mais experiência na elaboração de códigos. Eles são responsáveis por quase tudo no projeto, por exemplo: design, planejamento do trabalho, elaboração de códigos e qualquer outra coisa relacionada ao projeto.

Qualquer pessoa que saiba escrever algum código costuma ser chamada de codificador. Mas, normalmente, os codificadores são considerados o nível de programadores menos treinado ou experiente. Essas pessoas não possuem o mesmo conhecimento algorítmico que um programador ou desenvolvedor, pois geralmente são iniciantes na área, com habilidade em apenas uma linguagem de programação. Os codificadores geralmente recebem a tarefa de escrever trechos decisivos de código que podem ser facilmente delegados pelos desenvolvedores. O codificador não precisa saber em detalhes o que está acontecendo dentro do projeto. Imagine que um cliente no Freelance contrata um codificador para escrever uma função de trailing-stop num EA. Nesse caso, nosso amigo começará a escrever o código, adicionará uma chamada dentro da função Ontick, testará o resultado no MetaTrader 5 um par de vezes, para se certificar que tudo funciona antes de enviá-lo ao cliente.

Neste artigo também falaremos sobre "desenvolvedores" num sentido mais amplo - como agilizam o desenvolvimento de sistemas. Assim, abordaremos diferentes partes do projeto, incluindo o design, a ética de trabalho, as ferramentas utilizadas, o processo de escrita de código, depuração, etc. 

Como programar mais rápido

1. Evite os erros e uma péssima formatação

Os desenvolvedores sentem que passam muito tempo escrevendo código. Mas, na realidade, passamos a maior parte do nosso tempo revisando código, depurando e pensando em soluções.

Às vezes, são necessárias três horas para depurar um código que foi escrito em 30 minutos. E quanto mais erros houver no código, mais tempo será necessário para conseguir um projeto pronto. Em outras palavras, todo o processo é retardado por erros. Por isso, a melhor solução é não cometê-los.

Péssima formatação + erros = esqueça um resultado rápido

É um problema se seu projeto tem bugs, mas é ainda pior se você não consegue detectá-los ou depurá-los por causa de uma formatação fraca. Para dar um exemplo, veja a seguir um pequeno trecho de código de um EA que uma vez me mandaram corrigir.

ouble NPB=ND(m_account.Balance()*PortionPC,2);
if(CbT==0||PortChange<0||(PortChange>0&&NPB>PortionBalance))PortionBalance=NPB;
if(Pb+Ph<0)DrawDownPC=-(Pb+Ph)/PortionBalance;
if(!FirstRun&&DrawDownPC>=MaxDDPercent/100)
{       ET(A,displayColorLoss,"Equity Stop Loss Reached");
        if(PlaySounds)PlaySound(AlertSound);
        return(0);
}
if(-(Pb+Ph)>MaxDD)MaxDD=-(Pb+Ph);
MaxDDPer=MathMax(MaxDDPer,DrawDownPC*100);
if(SaveStats)Stats(false,TimeCurrent()<NextStats,PortionBalance,Pb+Ph);

//+-----------------------------------------------------------------+
//|                                                                 |
//+-----------------------------------------------------------------+
double StepAB=InitialAB*(1+StopTradePercent),StepSTB=m_accout.Balance()*(1-StopTradePercent), NextISTB=StepAB*(1-StopTradePercent);
if(StepSTB>NextISTB){   InitialAB=StepAB;
        StopTradeBalance=StepSTB;       }
        
double InitPortion=StopTradeBalance*PortionPC;
if(PortionBalance<InitPortion)
{       if(CbT==0)
 {      AllowTrading=false;
        if(PlaySounds)PlaySound(AlertSound);
        Print("Portion Balance dropped below stop trade percent");
        MessageBox("Reset EA, account balance dropped below stop trade percent on "+Symbol()+Period()," Warning",48);
        return(0); }
        else if(!ShutDown&&!RecoupClosedLoss)
        {       ShutDown=true; if(PlaySounds)PlaySound(AlertSound);
                Print("Portion Balance dropped below stop trade percent");
                return(0);              }
}

Eis um excelente exemplo de uma péssima formatação. Não nos resta dúvida do motivo pelo qual há muitos bugs no código. Como você pode ver, o código é tão confuso que é difícil entendê-lo de imediato. Possivelmente nem o próprio autor compreendeu plenamente o que tinha escrito.

Você também pode ter azar (como é o meu caso) e aceitar um pedido no Freelance para corrigir bugs num programa com 10 000 linhas de código semelhantes a este exemplo (já gastei mais de três semanas e ainda não o terminei).

Eu acho que é importante ser consistente ao escrever o código, cumprir certas regras ao nomear funções, criar variáveis, etc. Escolha aquelas que são mais próximas e mais compreensíveis para você.

2. Domine uma rápida depuração

No que diz respeito ao primeiro ponto, já está claro que os erros atrasam todo o processo e nos roubam o tempo. O tratamento de erros e depuração é um tópico muito amplo, não pode ser abordado num único artigo. Recomendo que todos leiam o artigo "Depuração de programas em MQL5"..

E na questão da depuração, há maneiras de economizar tempo com algumas técnicas de depuração rápida.

1. No MetaEditor, use o estilizador de código.

O estilo não está diretamente relacionado com a depuração, mas é um passo importante para realizá-la. Esta ótima ferramenta irá arrumar a aparência de seu código, tornando-o mais claro e fácil de ler.

2. Use Print e Comment.

Para analisar e entender rapidamente o que não está funcionando corretamente, adicione comentários e mensagens de log sempre que algo for suspeito.

Isto pode ajudá-lo a detectar erros onde você não os esperaria.

3. Não comece a fazer alterações antes de ter 100% de certeza de como as coisas funcionam.

Muitas pessoas provavelmente já apagaram um trecho de código para que o sistema funcionasse corretamente, e em seguida perceberam que o problema não estava naquele código. Aí é preciso passar tempo recuperando-o, sem ter garantia de que não se cometerão mais erros.  

Antes de remover algo, leia cuidadosamente a documentação (se se tratar de uma função padrão ou um método embutido). Se você ainda não tem certeza, pergunte no fórum. Às vezes, quando surge uma dúvida em alguns lugares, copio todo o código para um arquivo de texto. Desta forma não tenho medo de apagar, modificar e tentar novas soluções, para assim poder aplicá-las no código fonte que estava falhando.

3. As bibliotecas não foram inventadas ao acaso

Quando se trabalha com bibliotecas, é muito importante utilizar as classes conforme seu propósito. Tentar pular etapas importantes por causa da preguiça ou outros motivos causará inevitavelmente um desastre.

Se você estiver usando a Biblioteca Padrão, é recomendável seguir os procedimentos padrão ao criar ou acessar as instâncias das classes da biblioteca, exatamente como os desenvolvedores da biblioteca pretendiam.

Por exemplo, em vez de acessar preguiçosamente as classes de negociação da biblioteca e usar nomes estranhos e inconsistentes como, por exemplo, neste trecho de código:

#include <Trade\AccountInfo.mqh> //Class for working with trade account properties
#include <Trade\SymbolInfo.mqh>  //Class for working with trade instrument properties
#include <Trade\OrderInfo.mqh>   //Class for working with pending order properties
#include <Trade\OrderHistoryInfo.mqh>  //Class for working with history order properties
#include <Trade\PositionInfo.mqh>   //Class for working with open position properties
#include <Trade\DealInfo.mqh>       //Class for working with history deal properties
#include <Trade\Trade.mqh>          //Class for trade operations execution
#include <Trade\TerminalInfo.mqh>   //Class for getting the properties of the terminal environment
//--- 
CAccountInfo       ac;
CSymbolInfo        symb;
COrderInfo         orders;
CHistoryOrderInfo  hist_orders;
CPositionInfo      pos;
CDealInfo          _clos;
CTrade             my_trade;
CTerminalInfo      info;

vale a pena acessar as bibliotecas de maneira consistente e compreensível. A melhor maneira de fazer isso é por meio dos membros de classe, onde m_*** denota membros de uma classe específica.

Assim:

#include <Trade\AccountInfo.mqh> //Class for working with trade account properties
#include <Trade\SymbolInfo.mqh>  //Class for working with trade instrument properties
#include <Trade\OrderInfo.mqh>   //Class for working with pending order properties
#include <Trade\OrderHistoryInfo.mqh>  //Class for working with history order properties
#include <Trade\PositionInfo.mqh>   //Class for working with open position properties
#include <Trade\DealInfo.mqh>       //Class for working with history deal properties
#include <Trade\Trade.mqh>          //Class for trade operations execution
#include <Trade\TerminalInfo.mqh>   //Class for getting the properties of the terminal environment
//--- 
CAccountInfo       m_account;  //members of account info
CSymbolInfo        m_symbol;   //members of symbolInfo
COrderInfo         m_order;    //mambers of OrderInfo
CHistoryOrderInfo  m_orderhistory; //members of Orderhistory info
CPositionInfo      m_position; //members of position info
CDealInfo          m_deal;     //members of deal info
CTrade             m_trade;    //members of trade info
CTerminalInfo      m_terminal; //members of terminal info

E não se esqueça de adicionar links para a biblioteca ao final dos comentários, para que da próxima vez fique claro que dados devem ser obtidos aqui. 

Além disso, resolver problemas usando bibliotecas padrão prontas, em vez de escrever código próprio sempre do zero, aumenta por si só a velocidade com que escrevemos código. Estas bibliotecas foram criadas por programadores profissionais para trabalhar de forma otimizada com a linguagem MQL5. Elas permitem respeitar o princípio DRY (don't repeat yourself, não se repita) e acelerar o processo de desenvolvimento. Aconselho a todos a usar as bibliotecas padrão, bem como as muitas bibliotecas adicionais publicadas no CodeBase ou disponíveis no Mercado. 

Dê uma olhada nesses dois exemplos de código e determine qual desenvolvedor é mais rápido:

Tudo do zero (semelhante ao estilo de um programador iniciante)

Código utilizando a biblioteca padrão

double SymbolAsk(string symbol) {         if (symbol == "") symbol = Symbol();         return SymbolInfoDouble(symbol, SYMBOL_ASK); } double SymbolBid(string symbol) {         if (symbol == "") symbol = Symbol();         return SymbolInfoDouble(symbol, SYMBOL_BID); } int SymbolDigits(string symbol) {         if (symbol == "") symbol = Symbol();         return (int)SymbolInfoInteger(symbol, SYMBOL_DIGITS); } double SymbolLotSize(string symbol) {         if (symbol == "") symbol = Symbol();         return SymbolInfoDouble(symbol, SYMBOL_TRADE_CONTRACT_SIZE); } double SymbolLotStep(string symbol) {         if (symbol == "") symbol = Symbol();         return SymbolInfoDouble(symbol, SYMBOL_VOLUME_STEP); } double SymbolMaxLot(string symbol) {         if (symbol == "") symbol = Symbol();         return SymbolInfoDouble(symbol, SYMBOL_VOLUME_MAX); } double SymbolMinLot(string symbol) {         if (symbol == "") symbol = Symbol();         return SymbolInfoDouble(symbol, SYMBOL_VOLUME_MIN); }

#include <Trade\SymbolInfo.mqh> CSymbolInfo   m_symbol; input string Input_symbol = "EURUSD"; //+------------------------------------------------------------------+ //| Expert initialization function                                   | //+------------------------------------------------------------------+ int OnInit()   { //---      string symbol = Input_symbol=="" ? Symbol() : Input_symbol;       m_symbol.Name(symbol); //Sets symbol name for our CSymbolInfo class object //---    return(INIT_SUCCEEDED);   } //+------------------------------------------------------------------+ //| Expert tick function                                             | //+------------------------------------------------------------------+ void OnTick()   { //---       m_symbol.RefreshRates(); //Refresh to Get the Last quote       double    SymbolAsk = m_symbol.Ask();       double    SymbolBid = m_symbol.Bid();       double    SymbolDigits = m_symbol.Digits();       double    SymbolLotSize = m_symbol.ContractSize();       double    SymbolLotStep = m_symbol.LotsStep();       double    SymbolMaxLot = m_symbol.LotsMax();       double    SymbolMinLot = m_symbol.LotsMin();   }

Aqueles que usam a biblioteca padrão podem ser três vezes mais produtivos. Além disso, o encurtamento do código reduz as chances de erros no mesmo.

4. Empenhe-se em manter um código ordenado

Durante sua carreira como programador, você provavelmente já se deparou com este tipo de código também nos EAs:

        if(LbT>0)
        {       BEb=ND(BEb/LbT,Digits());
                if(BCa<0)BEb-=ND(BCa/PipVal2/(LbB-LbS),Digits());
                if(Pb>PbMax||PbMax==0)PbMax=Pb;
                if(Pb<PbMin||PbMin==0)PbMin=Pb;
                if(!TradesOpen)
                {       FileHandle=FileOpen(FileName,FILE_BIN|FILE_WRITE);
                        if(FileHandle>-1)
                        {       FileWriteInteger(FileHandle,TbF);
                                FileClose(FileHandle);
                                TradesOpen=true;
                                if(Debug)Print(FileName+" File Written: "+TbF);
                        }
                }
        }

Esse pedaço de código não é difícil de escrever. Mas não será fácil trabalhar posteriormente com ele - por exemplo, durante a depuração, há grandes chances de que você não se lembre dos valores de algumas variáveis e tenha que escrever tudo de novo. Você pode economizar tempo no processo de escrita do código, mas depois gastará muito mais.

Você será odiado e detestado por usar algoritmos demasiado complicados, que também o confundirão a si próprio.

É simplesmente repugnante enfiar toda a lógica num só lugar e amontoar um sem-número de declarações numa única função - você vai gastar muitíssimo tempo organizando cuidadosamente o código e certificando-se de que tudo funciona.

Se você precisar de operadores específicos, pode valer a pena criar funções separadas, que irão dinamizar suas ações, completando uma coisa antes de passar para outra.

5. Elimine as distrações

"Esteja alerta quando as distrações lhe vierem ao encontro. Você vai perceber que é uma distração quando você deixar de fazer o que deveria fazer e se encontra pensando em coisas que não têm valor", - Beverly R. Eames.

Silencie seu telefone (ou desligue completamente). Aprenda a se controlar. Não precisa pegar nele toda vez para verificar se há 'likes' ou novas mensagens nas mídias sociais. Se você é frequentemente distraído pelas mídias sociais, a produtividade está fora de questão. Se sua casa é barulhenta e agitada, tente encontrar um lugar onde você possa terminar seu projeto em paz.

Se o projeto for realmente importante, você pode evitar todas as distrações: fechar as portas, desligar o telefone, fechar as mídias sociais, concentrar-se e terminar.

É tão difícil para nós como desenvolvedores neste mundo moderno, onde tantas coisas estão a apenas alguns cliques de distância ou em nossos telefones ao nosso alcance. Todos esses vídeos de gatinhos e fotos do Instagram são uma distração enorme.

E é quando nosso projeto enfrenta alguma tarefa difícil, quando a solução ou o código não vem à mente, é tão tentador parar e ver o que está acontecendo no mundo ou não querer saber de nada e ir pra' balada.

É natural que você tenha que fazer intervalos e sair com os amigos. Eu mesmo não permaneço sentado em frente ao meu computador 24 horas por dia, apesar de muitos projetos da MQL5 surgirem. De qualquer modo, continuo acreditando que deve haver um cronograma de trabalho adequado e que ele deve ser cumprido. Se sua agenda ainda não lhe permite verificar as redes sociais, não as abra. Se sua agenda exige que você escreva código agora, escreva código, resolva as tarefas pendentes, não desista embora enfrente algo difícil. Para ser honesto, eu pessoalmente nem sempre cumpro o cronograma no sentido de que posso ficar mais tempo trabalhando num projeto se não houver outras coisas urgentes a fazer.

Acredite, com todas essas distrações, você pode despender cinco horas num código que você poderia ter escrito em 45 minutos.

6. Consulte a documentação e aprenda

Você já encontrou uma solução para seu problema no fórum? Embora às vezes você queira economizar tempo e terminar tudo mais rápido, não tenha pressa em copiá-la em seu projeto (falei sobre cópia de código no primeiro artigo). É muito mais importante entender como funciona a solução proposta, até porque, depois, pode ser difícil trabalhar com este tipo de código copiado e colado quando algo der errado. Especialmente em casos em que o código em si apresenta algum erro e você não o entende.

Eu recomendo que o leitor consulte a documentação com mais frequência, especialmente aqueles tópicos em que se sinta inseguro ou não tenha estudado o suficiente.

Como isso ajuda você a programar com mais rapidez?

À medida que você vai entendendo mais a linguagem MQL5, mais confiante você se torna, mais rápido você pode tomar decisões e mais rápido você pode elaborar um código válido. Na verdade, custa muito encontrar o código adequado para implementar sua ideia. Por isso digo que são a busca e o trabalho de pensar que demandam tanto tempo. E inclusive o código mais simples pode ser difícil de escrever quando você ainda não tem conhecimentos suficientes numa determinada área, como na de programação de indicadores, de Expert Advisors ou de scripts. As habilidades de que você precisa só vêm com a experiência.

Naturalmente, você dirá "mas onde posso adquirir essa experiência?". A resposta é simples: aprenda, ponha o conhecimento em prática e experimente

Aqueles que são bons em MQL5 têm possibilidades praticamente infinitas e podem facilmente transformar sua ideia num código funcional e robusto. Pode-se dizer que eles sabem perfeitamente quando usar

• matrizes,
• ciclos For/While, 
• arquivos para armazenamento/leitura de dados,
• consulta e leitura de dados desde um servidor da web
• e um monte de outras coisas úteis que é impossível de colocar num só artigo.

7. Repetições espaçadas

De acordo com a teoria de Herman Ebbinghaus, é mais fácil memorizar ou aprender determinadas matérias quando se estudam várias vezes durante um período de tempo prolongado com repetição a intervalos regulares do que quando se tenta memorizá-las num curto período de tempo.

Retomando o material em intervalos, repetindo-o de tempos em tempos, relembramos muito melhor o conteúdo. A memória no cérebro é limitada e só armazena o que usamos regularmente. Por conseguinte, se for preciso reter algo na memória, é preciso repeti-lo regularmente. É por isso que é necessário aprimorar constantemente nossas habilidades e reforçá-las.

Como?

Visto que uma das razões pelas quais demoramos tanto a escrever código é motivada por lacunas no nosso conhecimento sobre determinadas áreas, precisamos encontrá-las (algumas são discutidas neste artigo). Para isso, devemos trabalhar nelas com persistência e regularidade, até nos sentirmos suficientemente confiantes de que não dificultarão jamais o processo de desenvolvimento. Com o uso de técnicas de aprendizagem eficazes, mesmo as habilidades mais complexas, como aprendizagem de máquina ou algoritmos auto-adaptativos, podem ser dominadas.

8. Teclas de atalho e recursos do MetaEditor

Teclas de atalho

Decorar as teclas de atalho não é difícil e, na verdade, ajuda você a economizar muito tempo na elaboração de código. Eu me considero um profissional no uso de atalhos de teclado. Será um prazer compartilhar aqui alguns atalhos práticos e particularmente vantajosos no MetaEditor.

Comece a usar as teclas de atalho e sua vida vai mudar. O ideal é fazer tudo com o teclado e não usar o mouse. Acho que todo programador no início de sua jornada deve dominar o máximo possível o teclado, porque ele é nossa ferramenta de trabalho.

Aqui estão alguns dos meus atalhos de teclado favoritos do Window PC. Acho que os usuários de Mac podem substituir CTRL por COMMAND;

Teclas	Ação
F4	Alternar entre MetaTrader 5 e MetaEditor
F7	Compilar código
CTRL+F7	Compilar todos os documentos abertos
CTRL+C	Copiar código destacado
CTRL+V	Colar código destacado
CTRL+X	Cortar código destacado
CTRL+Z	Reverter alterações no código
CTRL+Y	Reverter alterações no código
CTRL+A	Selecionar todo o código
CTRL+END	Mover o cursor para a última linha de código no documento
CTRL+HOME	Mover o cursor para a primeira linha de código no documento
SHIFT + setas (para esquerda, para cima, para direita, para baixo)	Destacar código na direção desejada
TAB	Aumentar recuo no código selecionado
SHIFT+TAB	Diminuir recuo no código selecionado
CTRL+ Backspace	Excluir todas as palavras na string
HOME	Mover o cursor para o início da string
END	Mover o cursor para o fim da string
CTRL+ ?	//--- Put a code separator to the next line
CTRL+>	//+------------------------------------------------------------------+ //|           Add this to the current line and the next two          | //+------------------------------------------------------------------+
CTRL+"	// adds two forward slashes to the beginning of a line
CTRL+,	Aplicar formatação automática ao documento atual
CTRL+F4	Fechar documento atual
CRL +F5	Iniciar/retomar a depuração com base em dados históricos
CTRL+T	Abrir/fechar caixa de ferramentas
CTRL+D	Abrir/fechar navegador
ALT+G	Ir para declaração de variável/função
WINDOWS+T	Navegar pelos aplicativos na barra de tarefas, p. ex., se eu quiser abrir o navegador (Chrome) e pesquisar informações
CTRL+F	Abrir a caixa de pesquisa
CTRL+S	Salvar o documento atual
CTRL + setas de direção	Deslocar-se por espaços (por palavras)
CTR + +	Ir para frente
CTRL+ -	Ir para trás
CTRL+SHIFT+U	Converter o código destacado (palavra) em maiúsculas
CTRL+U	Converter o código destacado (palavra) em minúsculas

Configurações do MetaEditor

Umas corretas configurações do MetaEditor também podem ajudar a escrever código mais rápido. Para isso, recomendo a todos que experimentem assim:

Temos que marcar estas opções

• Inserir () e fechamento }])'" — uma maneira eficaz de evitar erros bobos (encerramento inesperado do programa, falta de parênteses) que às vezes são difíceis de notar, especialmente quando se trabalha com códigos grandes.
• Destacar parêntesis — ajudá-lo-á a entender os limites da função ou do bloco de código em que você se encontra.
• Destaque da linha atual — às vezes é difícil encontrar uma linha de código com a qual você acabou de trabalhar. O destaque ajuda você a ver rapidamente a linha certa ao fazer a rolagem.
• Habilitar área de transferência — o histórico de cópia tornará mais fácil selecionar qualquer fragmento copiado anteriormente.

Outras configurações de utilidade são a seleção de um tamanho de fonte que atenda às suas necessidades.

Pratique com as configurações para definir o que funciona para você. As configurações estão disponíveis no menu Serviço \ Configurações.

9. Aprenda a usar o Google

Aprender como buscar informações de forma eficaz também economiza tempo e acelera a elaboração de códigos. Quando programamos, muitas vezes nos deparamos com problemas e dificuldades que exigem soluções imediatas. Você não pode saber tudo, mas pode saber onde procurar e então será capaz de resolver quase qualquer tarefa.

Basta pesquisar no Google para encontrar a resposta certa, não é?  Não!  

Vamos dar uma olhada num exemplo em que um usuário comum está encalhado lendo um array num arquivo binário e abre o Google para encontrar a solução.

A primeira coisa que a maioria das pessoas faz é abrir o Google e na barra de busca escrever algo assim como ler um array em um arquivo binário (how to read an array in a binary file). O resultado da busca é o seguinte:

Atenção: o número total de resultados de pesquisa excede 98 milhões.

A internet abunda em lixo e em informações desnecessárias. Corremos o risco de perdermos muito tempo procurando o que precisamos, ou pior, de acabarmos num site não confiável, onde hackers podem roubar nossos dados pessoais. A pesquisa mostrada acima foi muito vaga para obter o resultado concreto que desejávamos. Para obter o resultado necessário, é preciso fazer uma consulta muito precisa e específica.

Há muitas dicas de busca para aqueles que querem ir mais fundo neste assunto. O que recomendo, por exemplo, é assistir a este pequeno vídeo. No entanto, aqui vou lhes falar apenas de duas dicas.

1. Pesquisa num site específico

O melhor lugar para procurar respostas relacionadas à MQL5 é, obviamente, o site MQL5.com. Por isso, ao pesquisar no Google, podemos indicar explicitamente o site MQL5.com para encontrar respostas e soluções.

Adicione  site:MQL5.com no final da consulta. Este é o resultado que você obtém:

Desta vez, foram retornados apenas 568 resultados, todos do site MQL5.com. Quando especificamos  site: URL, informamos ao Google em que site procurar.

2. Pesquisa mais específica

Às vezes, pode haver muitos resultados vindos do site MQL5.com, porque ele é muito grande. Há alturas em que você sabe claramente o que deseja obter. Para esses casos, existe um método que eu uso pessoalmente, embora não seja recomendado pelo Google. Em qualquer caso, funciona, mas para pesquisa, precisamos conhecer em que seção do site MQL5 os resultados serão de maior prioridade: artigos, fórum, Codebase, etc. Esse tipo de pesquisa pode ser útil quando:

•  Você quer estudar um assunto mais profundamente por meio dos artigos
•  Deseja obter uma solução rapidamente no fórum 
•  Quer ver como outras pessoas fizeram em códigos prontos do Codebase

A pesquisa deve ser especificada no formato MQL5 + seção + consulta de pesquisa. Em nosso exemplo, será assim: 

MQL5 forum how to read an array in a binary file

Embora este método deva pesquisar numa seção específica, ainda não dissemos ao google em qual site pesquisar - neste caso, seria melhor escrever site:MQL5.com. Como resultado, a consulta de pesquisa agora é a seguinte: forum how to read an array in a binary file site:MQL5.com. Desse modo, o Google retornará 399 resultados.

Conclusão

Continuo a coletar dicas para ajudar a melhorar a qualidade e a velocidade da programação e aumentar a produtividade em geral. No próximo artigo vou acrescentar mais conselhos novos. Serão regras simples que se podem respeitar todos os dias e desenvolver hábitos úteis.

Obrigado pela atenção. Seus comentários, acréscimos e novas dicas de utilidade são bem-vindos na discussão do artigo.