Linguagem de programação visual DRAKON — ferramenta de comunicação Desenvolvedor/Cliente MQL
260
2
Introdução
A linguagem DRAKON foi desenvolvida através dos esforços conjuntos da Agência Espacial Federal (Centro de Produção Científica de Automação e Instrumentação em nome do acadêmico N.A. Pilyugin, Moscou) e da Academia Russa de Ciências (Instituto de Matemática Aplicada em nome do acadêmico M.V. Keldysh, Moscou) como uma generalização da experiência adquirida na criação da nave espacial "Buran".
V.D. Parondjanov
Há muito tempo, quando a glasnost, ou transparência informativa, fez incursões nos estados soviéticos, o desenvolvimento espacial secreto Linguagem Algorítmica Russa Amigável Clara/Confiável (DRACON) se tornou disponível ao público. Atualmente, V.D. Parondjanov é o maior divulgador dessa linguagem. Ele desenvolveu um site inteiro dedicado a DRACON, participa ativamente de fóruns, conferências e escreve livros sobre o tema. Graças ao seu esforço pessoal, utilizando a linguagem DRACON, profissionais da química e da medicina conseguem documentar seus processos.
Outros entusiastas começaram a lançar rotinas que convertiam essa linguagem em linguagens de programação mais amplamente usadas: C, C++, TCL/TK, Java, JavaScript... Na verdade, a lista é muito mais longa. E, quando necessário, ela pode ser expandida, pois todos os editores de texto que conheço geram arquivos facilmente legíveis (texto simples no formato *.csv, *.xml; bancos de dados como o SQLight...), e muitos desses programas têm código aberto para regras de conversão em outras linguagens algorítmicas.
Na verdade, essa linguagem não é "simbólica" como a maioria das linguagens modernas, como o MQL, mas sim gráfica. Isso significa que todos os algoritmos contidos nela são literalmente desenhados na tela por meio de ícones especiais. E esses ícones, por sua vez, são combinados em algoritmos por meio de regras intuitivas. Como resultado, temos esboços tão simples e claros que até quem não é programador consegue entendê-los. Assim, com um clique, esses esboços podem ser convertidos em programas funcionais...
Vamos relembrar o conceito de algoritmo.
Algoritmo é uma descrição clara e compreensível para o executor, orientando-o em determinados processos que resultam na realização de alguma tarefa específica.
Existem outras definições, possivelmente mais precisas, mas vou me ater a esta. Simplesmente porque gosto dela.
Bem, de acordo com esta definição, um algoritmo é uma maneira de resolver algum problema com os esforços do executor. Idealmente, se eu estou criando um algoritmo, seria melhor que o executor pudesse ser não só eu, mas também outra pessoa (ou algo mais, como um robô).
E foi pensando nisso que programei um Expert Advisor extremamente lucrativo, que opera usando um martingale senoidal complexo, e o sinal varia de acordo com o comprimento da vela cuja distância em relação à atual é uma fração exponencial de um dia da semana, e com a fase da formação anterior de 10 picos. Entenderam, né? Não??? Pois é, eu expliquei tudo!!!
O que vocês me sugeririam se estivessem interessados neste projeto, digamos, por razões financeiras? Provavelmente sentar e projetar no papel, certo? Assim também ficaria claro para vocês o que implementar ou como codificar. E daí nasceria um esboço, que seria assinado como termo de referência (TdR), e só então você pegaria todo esse material para transformá-lo em código...
Esse esboço poderia ser um diagrama DRAKON.
Agora bem, imagine que você é um programador e desenhou esse esboço sozinho. Então, basta pressionar algumas teclas (ou, para exagerar, clicar em um enorme item de menu "Fazer bem") para obter um código funcional. Bem, ou, pelo menos, será necessário criar uma estrutura confiável, que pode ser ajustada com uma série de autossubstituições.
Caso seja cliente, será muito mais fácil explicar ao programador o que você pretende, se você mostrar a ele um esboço-projeto que descreva claramente o que fazer em determinados casos.
Por exemplo, ao cruzar duas MAs (Médias Móveis), é necessário apenas registrar o sinal, e negociar no momento em que o preço se recupera da "menor" média, mas não depois das 19 horas segundo o horário local.
Descrever isso com palavras... é possível. E, eventualmente, você será entendido.
Mas também é possível desenhar um esboço, no qual você faz ao computador (ou melhor, a um executor abstrato) perguntas simples do tipo: "'O horário atual é maior que 19?' ou 'As médias se cruzaram?'", e detalhar o que fazer se a resposta for "sim" e se a resposta for "não".
O programador não terá menos trabalho técnico, mas entenderá muito melhor suas ideias e terá menos probabilidade de cometer erros nas primeiras versões. Afinal, depois esses erros terão que ser corrigidos, o que pode exigir tempo adicional (e/ou dinheiro).
De modo geral, os diagramas DRAGON trazem vantagens tanto para o programador quanto para o cliente, que não sabe de programação, mas tem uma ideia muito boa (melhor do que ninguém) de como exatamente ele quer que seu EA funcione.
Para resumir esta introdução, gostaria de dizer que para mim, DRAKON é bom porque:
- É uma linguagem construída de tal forma que realmente ajuda a pensar. Quando vejo um algoritmo desenhado na minha frente, percebo mais facilmente as interrelações das partes nos módulos e dos módulos inteiros, encontro erros e recorro a soluções que não são óbvias em si mesmas, mas que decorrem do diagrama.
- O DRAGON ajuda a entender melhor o cliente.
- É mais fácil comunicar minhas sugestões, se houver, ao cliente.
- O cliente consegue criticar meus erros com mais facilidade.
- Se o cliente tiver esboçado um diagrama DRAGON, esse diagrama poderá ser literalmente transformado em código e os TdR poderão ser considerados satisfeitos. Isso evita que, durante o processo, eu veja que não sei, por exemplo, o que fazer se o sinal não funcionar. Mesmo que isso seja tão óbvio para o cliente que ele não especificou o assunto e, inclusive fazendo o esclarecimento, é preciso escrever mais três telas de código... É melhor resolver essas coisas antes de codificar, e os diagramas ajudam muito a resolver esses "desnorteamentos".
Para mim, os diagramas nos algoritmos são simplesmente um meio maravilhoso de comunicação. Quando duas partes estão interessadas no resultado e mantêm um diálogo, é melhor que falem a mesma língua. E os diagramas DRAGON são universais para especialistas em qualquer profissão, uma vez que sejam compreendidos.
Principais ambientes de desenvolvimento na linguagem DRAKON
Ao preparar este artigo, utilizei três ferramentas fundamentais:
- Em primeiro lugar, está o Drakonhub, um editor online que permite desenhar todos os tipos de diagramas usando a linguagem DRAKON. A interface é muito simples, mas infelizmente não é possível exportar diagramas como código. Ele tem um projeto para programadores, drakon.tech, mas ele só lida com JavaScript (bem, não sei como usá-lo corretamente)... e o número de diagramas disponíveis para não-programadores no drakon.tech parece ser muito menor do que no drakonhub. Em geral, para clientes é perfeito, para desenvolvedores é bastante aceitável, se não se importarem, digamos, em adicionar manualmente a tipificação para variáveis após a geração... Possui interfaces em russo, inglês e norueguês.
- Em segundo lugar, está o "Fábula" (também disponível em um link direto para download). O programa tem interface em russo e inglês, é um aplicativo offline para Windows (embora escrito usando a biblioteca QT, tem código fechado). É gratuito. A interface para mim é quase ideal, os dados são salvos em XML, compactados com zip (ou seja, se desejado, é possível escrever algum XSLT e converter seus programas diretamente), pode rastrear algoritmos, o que pode ser usado para apresentações ou criação de pseudocódigo. O pseudocódigo, por sua vez, pode ser transformado em um programa funcional com uma série de substituições automáticas... A maior parte dos diagramas neste artigo será criada com a ajuda dele.
- Em terceiro lugar, está o Editor DRAKON, cuja interface é um pouco menos conveniente, pois os ícones precisam ser posicionados manualmente. Além disso, faltam alguns ícones e alguns, como as anotações, não são implementados da melhor maneira. Mas a vantagem é que posso converter seus diagramas para meu código no MQL5 sem muito trabalho preparatório. Ele também destaca algumas palavras-chave. E mais, ele é escrito em TCL/TK e, portanto, é multiplataforma, o que significa que é executado no Linux naturalmente, sem Wine. Não que isso seja crítico, mas é um pequeno bônus adicional. E a principal vantagem deste editor é o suporte a uma grande quantidade de linguagens de programação. Ou seja, pode facilmente converter um diagrama DRAKON em C++, Java, JavaScript, D, TCL, Go e muito mais. Por isso, para programadores, é uma ferramenta muito útil, se gostarem de DRAKON. No entanto, o código que ele gera nem sempre é bonito. E os métodos de preparação dos arquivos... não são intuitivos, é necessário ler a documentação. Mas, uma vez compreendido, ele funciona muito bem. Tem interface em russo e inglês.
- Existe também o IS DRAKON, que é pago, o que para mim é um ponto negativo. Não aprofundei detalhadamente na interface porque é semelhante à do Editor DRAKON, mas quando olhei não encontrei nenhuma vantagem especial.
A maioria dos diagramas neste artigo, como já mencionei, será preparada com a ajuda do "Fábula". Acho que seus diagramas são os mais bonitos, sem nenhuma preparação prévia complicada.
Eu farei o diagrama no Editor DRAKON se o código for gerado a partir dele.
Comandos principais da linguagem
A linguagem DRACON foi desenvolvida com base nos fluxogramas existentes naquela época e que eram bem conhecidos pelos programadores. Por esse motivo, os elementos principais da linguagem em geral correspondem às normas de fluxogramas. Mas a principal fortaleza deste desenvolvimento está nas regras de posicionamento desses elementos no plano.
O primeiro elemento funcional da linguagem é os "ícones". Um ícone é um símbolo gráfico especial que define alguma ação, condição, operação do algoritmo.
| Imagem | Nome (alternativas) | Descrição | |||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
 | Início (start) | O ícone "Início" indica o ponto de partida do programa. Aqui começa a execução do algoritmo. | |||||||||||||||
 | Fim (stop) | O ícone "Fim" indica a conclusão da execução do programa. Aqui termina a execução do algoritmo. | |||||||||||||||
 | Ação (processo) | O ícone "Ação" representa um bloco de ações simples. Contém comandos que são executados em sequência. | |||||||||||||||
 | Pergunta (condição, decisão) | O ícone "Pergunta" é usado para verificar uma condição. Se a condição for atendida, o programa segue por um caminho; caso contrário, por outro. | |||||||||||||||
 | Escolha (análise) | O ícone "Escolha" atua como um nó distribuidor para várias opções. Em outras palavras, o programa executa diferentes ações dependendo das condições definidas dentro da "Escolha". Ao contrário da "Pergunta", pode haver mais de duas opções. | |||||||||||||||
 | Opção | O ícone "Opção" representa uma condição ou ramo de execução associado ao ícone "Escolha" na linguagem DRACON. Define quais ações devem ser executadas se uma determinada condição no bloco "Escolha" for verdadeira. | |||||||||||||||
 | Nome do ramo | O ícone "Nome do ramo" descreve o nome de algum fragmento neste módulo, um certo estágio do algoritmo, estado do programa. | |||||||||||||||
 | Endereço | O ícone "Endereço" indica para onde se deve ir após a execução do ramo atual. | |||||||||||||||
 | Inserção | O ícone "Inserção" é usado para inserir outro diagrama ou bloco de ações no algoritmo atual. Isso permite preparar e estruturar o código de forma mais compacta e lógica. | |||||||||||||||
 | Prateleira | O ícone "Prateleira" pode ter vários significados.
| |||||||||||||||
 | Parâmetros | No ícone "Parâmetros", colocam-se os dados de entrada para o algoritmo. | |||||||||||||||
 | Início do ciclo PARA | O ícone "Inicio do ciclo PARA" geralmente é usado em conjunto com o seguinte. Descreve a repetição de alguma ação um número conhecido (calculável) de vezes. P. ex., se precisamos contar de 1 a 10, ou percorrer todos os elementos em algum array... | |||||||||||||||
 | Fim do ciclo PARA | O ícone "Fim do ciclo PARA" geralmente é usado em conjunto com o anterior. Descreve a repetição de alguma ação um número conhecido (calculável) de vezes. | |||||||||||||||
 | Saída | O ícone "Saída" indica o ponto onde os dados ou resultados do programa são transmitidos ao usuário, outra parte do programa ou dispositivos externos. Parte superior contém a palavra-chave ou frase-chave. Normalmente, há um verbo. Parte inferior contém o objeto ou informação descritiva. | |||||||||||||||
 | Entrada | O ícone "Entrada" indica o local onde o programa espera receber dados do usuário, de outro programa ou de fontes externas. Assim como a entrada, contém uma parte superior e uma parte inferior. | |||||||||||||||
 | Pause | O ícone "Pause" denota um momento de suspensão da execução do programa até um determinado evento ou tempo. | |||||||||||||||
 | Timer | O ícone "Timer" é usado para controlar intervalos de tempo e planejar ações. Frequentemente utilizado com o ícone "Tempo". | |||||||||||||||
 | Tempo | O ícone "Tempo" visualiza operações relacionadas ao tempo e seu registro. Permite que o programa acompanhe intervalos de tempo e eventos. | |||||||||||||||
 | Processo Paralelo | O ícone "Processo Paralelo" gerencia a execução de uma tarefa que ocorre simultaneamente com o programa principal. O processo paralelo funciona em segundo plano e seu algoritmo é definido em outro diagrama DRACON. O processo principal continua funcionando, sem esperar pela conclusão da tarefa paralela. A comunicação com o processo paralelo pode ser estabelecida usando os ícones "Entrada" e "Saída". | |||||||||||||||
 | Comentário na linha principal | O ícone "Comentário na linha principal" ajuda a tornar o diagrama mais compreensível. Não afeta o curso do programa, mas oferece a possibilidade de esclarecer um fragmento não compreendido. | |||||||||||||||
  | Comentários à direita e à esquerda. | Os ícones de comentários à direita e à esquerda permitem comentar qualquer ação exatamente onde ela ocorre. Geralmente, variáveis e parâmetros são explicados. | |||||||||||||||
 | Chamada de atenção | Os ícones de "Chamada de atenção" são mais frequentemente usados em vez de comentários à direita e à esquerda, se for necessário explicar algum fragmento do algoritmo. Em algoritmos que são traduzidos em programas, são usados raramente. Mais frequentemente, é uma maneira de focar a atenção em algoritmos escritos em linguagens humanas (p. ex., para médicos), ou se o cliente deseja esclarecer sua descrição com alguns pontos de destaque. | |||||||||||||||
 | Processos paralelos | O ícone "Processo paralelo" é usado para iniciar várias tarefas ou processos que ocorrem simultaneamente. Cada uma das setas neste ícone pode representar um thread ou tarefa separada. | |||||||||||||||
 | Laço de ciclo | As setas representam eventos recorrentes, cujo número exato de repetições é desconhecido. P. ex., verificar se a chaleira ferveu, até que finalmente ferva. | |||||||||||||||
 | Laço de silhueta | Usado apenas em um local do diagrama: para indicar a continuação da ação e a transição para o próximo ramo da silhueta (ver adiante). |
Às vezes, outros ícones são usados, como "entrada simples" (parece com a parte superior do ícone "Saída") ou um retângulo com cantos arredondados. Alguns programas não permitem o uso de todos os ícones. Mas, em geral, a tabela fornece um conjunto praticamente exaustivo de fragmentos a partir dos quais os diagramas são construídos.
Criação de esboços visuais simples ("primitivos")
Os diagramas da linguagem DRACON são construídos de acordo com certas regras.
Como já mencionado, o principal bloco de construção do diagrama são os ícones. No entanto, para que eles interajam corretamente, eles precisam de linhas de conexão.
As linhas de conexão podem ser horizontais e verticais, MAS
As ações ocorrem apenas verticalmente.
Conexões horizontais são indicadas apenas ao escolher uma entre várias opções ou em algumas outras ações auxiliares. Se não houver ações auxiliares, como a entrada de parâmetros em uma função ou comentários para um determinado algoritmo, então todo o algoritmo será colocado em um único "espeto" vertical.
P. ex., precisamos obter a soma de dois números. Recebemos ambos os números do usuário, exibimos os dados, digamos, no console usando a função printf ou Print, neste caso, não importa. Como seria o diagrama na linguagem DRACON? Muito simplesmente:
Figura 1. Algoritmo da soma de dois números
E se quisermos especificamente programar esse código, provavelmente precisaremos de uma função, e ela deverá aceitar parâmetros (ação auxiliar). Então, desenhamos isso da seguinte maneira:
Figura 2. Soma como função.
E imediatamente o código, gerado pelo programa a partir do meu diagrama:
double Summ(double a, double b) { // item 6 return (a+b); }
Então, lembre-se da primeira regra: a direção principal dos diagramas DRACON é de cima para baixo. Ou seja, se um algoritmo é executado linearmente, seu primitivo sempre será desenhado verticalmente, e deve ser executado de cima para baixo. Portanto, setas não são necessárias no diagrama - tudo já é claro assim.
Mas e se precisarmos de ramificação? Se algumas ações ocorrem apenas sob certas condições? Digamos, a entrada em uma operação apenas no cruzamento das médias móveis deve ser decidida com o ícone de pergunta:
Figura 3. Algoritmo de entrada na operação pelo cruzamento das médias móveis
Cada ícone de condição sempre tem duas saídas: uma para baixo e uma para a direita (e apenas assim). Ou seja, quaisquer ações no algoritmo sempre ocorrerão de cima para baixo e da esquerda para a direita. Setas novamente não são necessárias. Ao verificar o algoritmo, simplesmente seguimos as linhas até chegarmos ao fim. E então, geralmente, paramos...
Às vezes acontece que a decisão deve ser tomada com base não em duas, mas em três ou mais opções. Imaginemos, o usuário pressionou uma tecla específica, e dependendo de qual tecla ele pressionou, o programa deve executar certas ações. Isso pode ser desenhado, claro, usando questões comuns, mas o diagrama se tornaria complicado.
Nesse caso, uma estrutura de escolha é muito mais adequada.
Figura 4. Processamento de pressionamentos de tecla.
Note que o último ícone de opção ficou vazio. Na linguagem MQL, essa opção corresponde ao operador default, isto é, executa a ação padrão, se nenhuma outra opção couber.
Este exemplo ilustra outra regra do DRACON: todas as ramificações verticais são dispostas da esquerda para a direita, sendo que quanto mais à direita a opção, pior ela é. O caminho mais à esquerda é às vezes chamado de "Caminho do Rei" ou "Caminho Feliz" (happy path).
Se as opções são equivalentes, elas são simplesmente ordenadas por algum critério. P. ex., eu as ordenei pela posição da letra pressionada no alfabeto.
No entanto, existe uma situação em que é necessário voltar ao início de algum bloco, sem chegar ao fim do programa. Isso são os ciclos ENQUANTO.
Figura 5. Esperamos pelo sinal, até que ele apareça. A ação "Esperar pelo sinal" é executada pelo menos uma vez sob quaisquer circunstâncias.
Ou o mesmo ciclo pode ser reescrito de modo que primeiro verifique a condição e, em seguida, execute algumas ações.
Figura 6. Esperamos pelo sinal, até que ele apareça. A ação "Esperar pelo sinal" pode nunca ser executada, se o sinal já chegou.
De qualquer forma, a seta aqui se torna um elemento necessário, sem ela, o diagrama seria muito mais difícil de ler.
E há ainda uma regra importante sobre ciclos. No ciclo pode haver quantas saídas forem necessárias, mas o entrada pode ser apenas uma. Ou seja, não é possível estender uma seta de qualquer lugar do programa para qualquer lugar dentro do ciclo. É necessário sempre retornar ao início.
Diagramas "Silhueta" no DRACON
Como o DRACON é uma linguagem visual, é importante que seus diagramas sejam facilmente legíveis. E para isso, é melhor que todo o diagrama caiba na tela (ou na folha) completamente.
Esse requisito nem sempre é viável, mas deve-se aspirar a isso. E a única maneira de colocar os ícones da linguagem que pode ajudar nisso é a "Silhueta".
Silhueta é simplesmente uma maneira de dividir alguma função longa em partes componentes, em etapas de execução, mas ao mesmo tempo mantê-la como um todo unificado.
Aqui está, p. ex., como poderia parecer o processamento de um tick em um EA típico, processamento esse escrito como silhueta.
Figura 7. Silhueta é a segunda configuração básica de diagrama na linguagem DRACON
No topo de cada ramo está seu nome convencional em linguagem humana. Abaixo está o endereço de transição, isto é, para onde redirecionar o fluxo de comandos após a conclusão dessa ramificação. Como regra, a transição é feita para o ramo adjacente, mas há casos em que é necessário ir para outro lugar.
Se a transição for mais para a direita, simplesmente se indica o nome do ramo.
Se a transição ocorrer para o início desse mesmo ramo ou para um ramo à esquerda, os marcadores de início e fim dos respectivos ramos são marcados com um triângulo preto:
Figura 8. Ciclo em um único ramo da silhueta
Se você tiver que usar tal ciclo, certifique-se de que tem uma condição de saída que direcione o programa para outro ramo. Caso contrário, o ciclo ameaça se tornar infinito.
Eu tento evitar esse tipo de ciclos em meus fluxogramas. Nas tarefas que resolvo, pode-se prescindir deles em 95.4% dos casos...
De fato, a silhueta é interpretada como um diagrama de estado. Como regra, os editores entendem cada ramo exatamente dessa forma, isto é, como certos estados do processo no momento, assim a silhueta é interpretada, como um ciclo infinito com a seleção de estados usando o operador switch-case dentro. Por isso são necessárias etiquetas de entrada e saída: o programa precisa saber para onde mudar, e a pessoa precisa ver qual fragmento exatamente está ativo em um dado momento.
A entrada em um ramo é possível somente pelo seu início. A saída do último ramo é feita através do ícone "Fim".
Nuances adicionais dos diagramas DRACON
Espero que você tenha notado que em nenhum dos esboços apresentados acima as linhas se cruzam, a menos que haja uma conexão. Este é um ponto crucial que adiciona clareza aos diagramas. Não deve haver cruzamentos. Podem haver apenas fusões de caminhos ou transições por rótulos. Lá onde há um cruzamento, pode-se escolher esse caminho quando a tarefa se move para a solução.
Aliás, na figura 7, o ramo de adição de posições adicionais (o terceiro da esquerda) não está desenhado corretamente. Deve haver o mínimo possível de linhas paralelas no desenho. Essa regra também acrescenta clareza. Infelizmente, o "Fabula" não sabe desenhar ramificações corretamente. Embora isso não seja um erro, é mais uma imprecisão de interpretação.
A exceção à regra "Movimentos para baixo ou para a direita" é a linha mais baixa do diagrama, que une os espetos da silhueta. Ela sempre retorna o processo ao início, para escolher um novo estado. Por isso, movemo-nos da direita para a esquerda, em direção à seta.
Em princípio, quase todos os programas permitem criar vários esquemas em uma única folha. E às vezes isso pode ser justificado.
Se os diagramas são pequenos, e quase todos são verticais (as silhuetas podem ser muito compactas)... E há distância suficiente entre os diagramas (ou eles são bem marcados por cores, ou melhor ainda por bordas adicionais)... Sob todas essas condições, a clareza dos diagramas quando combinados pode aumentar.
Se seus diagramas devem ser impressos em papel, faz sentido tentar organizá-los da forma mais compacta possível, usando as recomendações do parágrafo anterior.
No entanto, em todos os outros casos, é melhor dispor cada diagrama em seu próprio espaço. Especialmente se entre eles houver grandes "silhuetas" ou esses diagramas forem impressos em preto e branco. Mais frequentemente, DRACON é sobre clareza, não compactação. É justamente a clareza que reduz o esforço mental necessário para entender: "O que está desenhado aqui???", e permite direcionar esses esforços para o desenvolvimento de soluções eficazes.
Importação de diagramas de DRACON para MQL
Quando estou elaborando algoritmo grande e bonito usando ícones, quero minimizar o esforço de transferir o desenho para o código escrito.
Geralmente, para esses fins, uso o Editor DRAKON.
Ao abrir o editor, a primeira coisa a fazer é criar (ou abrir um arquivo existente).
Figura 9. Editor DRAKON - Diálogo de criação de arquivo
Na verdade, o Editor DRAKON (DE) usa salvamento automático: todas as alterações na tela são imediatamente salvas no arquivo.
Com letras amarelas nesta janela, está escrito que, ao arrastar ícones pela tela ao criar diagramas, você pode usar a tecla "Shift" - então o arrasto se tornará "inteligente".
Os diagramas esboçados serão convertidos em linguagem Java. Este é o caminho mais simples se você não quer escrever um parser especial para MQL (eu ainda não quero). A estrutura dos arquivos Java é o mais próximo possível da estrutura dos programas MQL5, portanto, os arquivos gerados serão compilados com o mínimo de modificações.
No canto superior esquerdo da janela principal do programa, há um botão para abrir a descrição do arquivo e o menu "File", onde você também pode encontrar esse item:
Figura 10. Editor DRAKON - Menu e botão de propriedades do arquivo
A descrição do arquivo é funcional!!!
Na descrição, além de explicações gerais, é possível inserir duas seções que serão totalmente transferidas para o programa final. Enquanto ainda não houver nada lá, essas seções parecerão muito simples:
===header=== ===class=== class Main {
Após a linha "===class===" basta escrever as palavras "class Main {". Note que aqui há uma chave. A segunda chave será adicionada pelo editor durante a geração.
Só pode haver uma classe no arquivo.
Tudo que é inserido após a linha "===header===", o DE inserirá no seu arquivo diretamente. Portanto, se você está escrevendo um programa inteiramente na linguagem DRACON, nesta seção é necessário colocar todas as variáveis globais, instruções "#include", descrições de estruturas e enumerações, etc.
Tudo que está antes da seção "===header===", é ignorado. Ou seja, aqui realmente pode-se inserir quaisquer textos descritivos
Se você está escrevendo um indicador simples, as palavras "class Main {" e a chave de fechamento do arquivo final devem ser removidas.
No entanto, se você entende como a programação orientada a objetos funciona, pode usar a descrição da classe diretamente neste mesmo cabeçalho, como de costume, excluindo a implementação das funções. A implementação das funções ocorrerá nos diagramas. Apenas tenha em mente que, em Java, tudo é uma classe, enquanto em MQL ainda existem funções que operam em um escopo global.
Quero demonstrar a criação de um indicador simples NR4, que marca a vela se o seu tamanho for menor que o das outras velas antes dela. A quantidade de velas "grandes" é definida nos parâmetros de entrada. Frequentemente a aparição de tal vela indica a probabilidade de um movimento brusco iminente.
Aqui está o código da minha descrição:
===header=== //+------------------------------------------------------------------+ //| NR4.mq5 | //| Oleg Fedorov (aka certain) | //| mailto:coder.fedorov@gmail.com | //+------------------------------------------------------------------+ #property copyright "Oleg Fedorov (aka certain)" #property link "mailto:coder.fedorov@gmail.com" #property version "1.00" #property indicator_chart_window #property indicator_buffers 2 #property indicator_plots 2 //--- plot NRBars #property indicator_label1 "NRBarsUp" #property indicator_type1 DRAW_ARROW #property indicator_color1 clrRed #property indicator_style1 STYLE_SOLID #property indicator_width1 0 //--- plot NRBars #property indicator_label2 "NRBarsDn" #property indicator_type2 DRAW_ARROW #property indicator_color2 clrRed #property indicator_style2 STYLE_SOLID #property indicator_width2 0 //--- input variables input int NRPeriod=4; //--- indicator buffers double NRBarsBufferUp[]; double NRBarsBufferDn[]; ===class=== class Main {
UFA! Descrição do arquivo concluída...
Agora, das configurações, resta apenas uma coisa: informar ao editor que nosso arquivo deve ser adaptado a Java.
Selecionamos o menu "Arquivo -> Propriedades do arquivo" e, no diálogo que aparece, selecionamos da lista na linha superior "Java".
Imagem 11. Escolha da linguagem para a qual o diagrama é adaptado.
Pronto, a configuração está concluída. Agora podemos começar a programar o algoritmo.
Nos ícones, pode-se escrever qualquer texto, mas neste caso, cada ícone conterá um fragmento de código que vai para o arquivo final. Se for uma demonstração para o cliente, basta escrever comentários em linguagem humana, mas se você deseja armazenar código compilável nos diagramas, descreva o que deve acontecer em detalhes... No meu caso, é o segundo.
E, sim, o ícone "Inserir" em DE não funciona na compilação, deve-se usar simplesmente o ícone "Ação".
Para cada função deve ser criado seu próprio diagrama.
DE realmente exige isso (outros editores são mais "flexíveis"). Aqui não é possível criar vários esboços sem criar várias entidades para os diagramas usando o botão na barra de ferramentas ou a combinação de teclas Ctrl+N.
No meu caso, foram apenas duas funções: OnInit e OnCalculate. Aqui estão elas:
Figura 12. Função OnInit
Figura 13. Função OnCalculate
Se o texto nas imagens estiver muito pequeno, baixe e instale o Editor DRAKON (o site contém instruções detalhadas e descreve todas as dependências). E então, abra diretamente o arquivo de diagrama que eu anexei.
Bem, depois, com o menu "DRAKON -> Gerar código", tentamos converter o diagrama em código compilável. Se houver erros nele (p. ex., uma linha não conectada a outra linha ou ícone), o DE avisará sobre isso no painel inferior. Se não houver erros, um arquivo com a extensão *.java aparecerá na pasta que contém o arquivo do projeto.
Salve-o em seu diretório de indicadores, altere a extensão para *.mq5, remova a descrição da classe, se necessário, compile e execute...
Aqui está o conteúdo do meu arquivo antes de remover tudo que está a mais:
// Autogenerated with DRAKON Editor 1.31 //+------------------------------------------------------------------+ //| NR4.mq5 | //| Oleg Fedorov (aka certain) | //| mailto:coder.fedorov@gmail.com | //+------------------------------------------------------------------+ #property copyright "Oleg Fedorov (aka certain)" #property link "mailto:coder.fedorov@gmail.com" #property version "1.00" #property indicator_chart_window #property indicator_buffers 2 #property indicator_plots 2 //--- plot NRBars #property indicator_label1 "NRBarsUp" #property indicator_type1 DRAW_ARROW #property indicator_color1 clrRed #property indicator_style1 STYLE_SOLID #property indicator_width1 0 //--- plot NRBars #property indicator_label2 "NRBarsDn" #property indicator_type2 DRAW_ARROW #property indicator_color2 clrRed #property indicator_style2 STYLE_SOLID #property indicator_width2 0 //--- input variables input int NRPeriod=4; //--- indicator buffers double NRBarsBufferUp[]; double NRBarsBufferDn[]; class Main { int OnCalculate(const int rates_total, const int prev_calculated, const datetime &time[], const double &open[], const double &high[], const double &low[], const double &close[], const long &tick_volume[], const long &volume[], const int &spread[]) { // item 15 int i,j, limit; // item 16 if (rates_total < NRPeriod) { // item 19 return 0; } else { // item 20 if (prev_calculated < NRPeriod) { // item 23 limit = NRPeriod; // item 24 ArrayInitialize(NRBarsBufferUp, EMPTY_VALUE); ArrayInitialize(NRBarsBufferDn, EMPTY_VALUE); } else { // item 25 limit = rates_total - NRPeriod; } // item 310001 i = limit; while (true) { // item 310002 if (i<rates_total-1) { } else { break; } // item 340001 j=1; while (true) { // item 340002 if (j<NRPeriod) { } else { break; } // item 36 if (high[i]-low[i]>high[i-j]-low[i-j]) { // item 39 break; } else { } // item 340003 j++; } // item 40 if (j==NRPeriod) { // item 43 NRBarsBufferUp[i]=high[i]; NRBarsBufferDn[i]=low[i]; } else { } // item 310003 i++; } } // item 48 return(rates_total); } int OnInit() { // item 11 //--- indicator buffers mapping SetIndexBuffer(0,NRBarsBufferUp,INDICATOR_DATA); SetIndexBuffer(1,NRBarsBufferDn,INDICATOR_DATA); // item 12 //--- setting a code from the Wingdings charset as the property of PLOT_ARROW PlotIndexSetInteger(0,PLOT_ARROW,218); PlotIndexSetInteger(1,PLOT_ARROW,217); // item 13 //--- IndicatorSetString(INDICATOR_SHORTNAME,"NR4 ("+IntegerToString(NRPeriod)+")"); // item 14 //--- return(INIT_SUCCEEDED); } }
Lembro mais uma vez: para que este indicador simples funcione, o texto destacado em amarelo precisa ser removido - tanto de cima quanto de baixo. Aqui, conscientemente, não utilizei um estilizador para que o leitor pudesse avaliar como exatamente o arquivo seria formatado automaticamente pelo DE.
Ler este código, claro, é muito mais difícil do que se eu o escrevesse manualmente, mas... Ele funciona. E não é necessário lê-lo, mas sim observar os diagramas. ;-)
Considerações finais
Se você é desenvolvedor e gostou do DRAKON, sinta-se à vontade para usar qualquer uma das ferramentas para criar diagramas que mencionei acima. O melhor é se você mesmo testar cada um dos editores listados e formar sua própria opinião sobre o que é melhor ou pior para você... Essencialmente, todos eles são simples.
Se você quer acostumar o cliente com ser arrumado, dê a ele o link para Dragon.Tech ou para drakonhub, explique em poucas palavras como criar um projeto em linguagem humana e como os ícones se relacionam entre si, e diga que descrever em palavras o que ele quer ver é normal. O principal é que haja uma estrutura clara.
Se você é o cliente e chegou até aqui, então para você tudo já deve estar claro. ;-)
Ficaram fora de cena muitos temas: o uso do DRAKON em apresentações interativas, métodos para organizar e estruturar informações para facilitar a memorização, não apenas de programas de computador, críticas ao idioma DRAKON e a todos os idiomas gráficos...
Se for do seu interesse, escreva em mensagens privadas ou nos comentários deste artigo — vamos discutir o assunto. Você também pode visitar o site de V.D. Parondjanov e explorar os links lá, desse jeito você poderá "descobrir" muito mais...
E eu espero que tenha conseguido despertar ao menos algum interesse por esta abordagem e que pelo menos algumas das pessoas que leram este texto comecem a usar esta ferramenta maravilhosa na prática.
Se alguém precisar dos códigos-fonte de outros algoritmos descritos neste artigo, escreva, e eu enviarei para você.
Anexo. No arquivo — o arquivo de projeto do Editor DRAKON, contendo o algoritmo do indicador descrito na seção anterior. A partir desse arquivo, você pode gerar um código bastante funcional do indicador NR4.
Traduzido do russo pela MetaQuotes Ltd.
Artigo original: https://www.mql5.com/ru/articles/13324
Teoria das Categorias em MQL5 (Parte 20): autoatenção e transformador
Pairs Trade
Algoritmos de otimização populacionais: salto de sapo embaralhado
Modelos prontos para integrar indicadores nos Expert Advisors (Parte 2): Indicadores de volume e Bill Williams
- Aplicativos de negociação gratuitos
- 8 000+ sinais para cópia
- Notícias econômicas para análise dos mercados financeiros
Você concorda com a política do site e com os termos de uso
Nada de especial. O início é tão surreal:"A linguagem DRAGON foi desenvolvida por esforços conjuntos da Agência Espacial Federal", que por um momento pensei que estava lendo Strugatsky.
É uma visão assustadora! Ao imaginar quantos diagramas os desenvolvedores do software Buran tiveram que desenhar para fazer um pouso automático, lágrimas vieram aos meus olhos!
É uma visão horrível! Quando imagino quantos diagramas os desenvolvedores do software Buran tiveram que desenhar para fazer um pouso automático, lágrimas vêm aos meus olhos!