Idea por sistema de negociação

& # 8220; 1 Hour Forex & # 8221; Sistema de Negociação.
de vez em quando alguém desenvolve algo que vale a pena chamar a atenção. Isso acontece muito raramente, mas ainda acontece.
Se isso também for desenvolvido por alguém que eu pessoalmente conheço, então é algo que dá ainda mais confiança ao pacote inteiro.
O & # 8220; 1 Hour Forex & # 8221; é um sistema de troca manual aplicado ao prazo de 1 hora (a partir do qual o nome vem). Um simples e eficaz.
Tudo o que você precisa fazer é baixar o manual de pdf e passar menos de duas horas assistindo todos os 8 vídeos para aprender em profundidade como funciona o sistema comercial e o que você pode esperar dele. Meu amigo Jason também desenvolveu um par de indicadores s para se inscrever em seus gráficos que tornarão o assunto ainda mais fácil.
O número médio de pips por troca com 1 Hour Forex é entre 15 e # 8211; 30 pips, às vezes maiores. Mas, vamos usar o cenário pessimista de 15 & # 8211; 30 pips com mais de 90% de resultados, considerando que você não precisa de mais de 45 minutos para gastar, a fim de decidir se um possível trade set up pode ocorrer, não tenho dúvidas de que será o seu mais rentável sem stress 45 minutos !
Lembre-se, para ser rentável, você precisa de consistência e confiança em seu sistema comercial. Mesmo 15 a 30 pips por dia podem ser mais do que suficientes se você tiver uma porcentagem elevada de fazê-los. Essa é uma das principais razões pelas quais particularmente amo o & # 8220; 1 Hour Forex & # 8221; sistema de negociação.
Se quiser ler mais e manter-se informado sobre o próximo lançamento do sistema, basta clicar aqui.

Gerenciamento de dinheiro - A regra de 2% (dois por cento).
A regra de 2 porções é um princípio básico do gerenciamento de risco (eu prefiro os termos "gerenciamento de risco" ou "preservação de capital", pois são mais descritivos do que "gerenciamento de dinheiro"). Mesmo que as probabilidades sejam empilhadas a seu favor, não é aconselhável arriscar uma grande parte do seu capital em um único comércio.
Larry Hite, no Jack Schwager's Market Wizards (1989), menciona duas lições aprendidas de um amigo:
Nunca aposte seu estilo de vida - nunca arrisque um grande pedaço de sua capital em um único comércio; e sempre saiba qual é o pior resultado possível.
Hite continua descrevendo sua regra de 1 por cento que ele aplica a uma ampla gama de mercados. Isso já foi adaptado por comerciantes de capital de curto prazo como a Regra de 2 porções:
NUNCA RISQUE MAIS DE 2 POR CENTO DE SUA CAPITAL EM QUALQUER STOCK.
Isso significa que uma série de 10 perdas consecutivas consumiriam apenas 20% do seu capital. Isso não significa que você precisa trocar 50 ações diferentes! Se você usa stop loss, como o ATR Trailing Stops, seu capital em risco normalmente é muito inferior ao preço de compra do estoque.
Como aplicar a regra de 2 por cento.
Calcule 2% do seu capital de negociação: sua corretora de Dedução de Capital em Risco na compra e venda para chegar ao seu Risco Máximo Permitido Calcule seu Risco por Ação:
Imagine que seu capital total de negociação de ações é de US $ 20.000 e seus custos de corretagem são fixados em US $ 50 por comércio.
Seu Capital em risco é: US $ 20.000 * 2 por cento = $ 400 por comércio. Corretora de dedução, na compra e venda, e seu risco máximo permitido é: $ 400 - (2 * $ 50) = $ 300. Calcule seu risco por ação:
Se uma ação tiver um preço de US $ 10,00 e você deseja colocar um stop-loss em US $ 9,50, seu risco é de 50 centavos por ação.
Adicione uma derrapagem de dizer 25 centavos e seu Risco por ação aumenta para 75 centavos por ação. O número máximo de ações que você pode comprar é, portanto:
$ 300 / $ 0.75 = 400 ações (a um custo de $ 4000)
Teste rápido.
Seu capital é de US $ 20.000 e a corretora é reduzida para US $ 20 por comércio. Quantas ações de US $ 10,00 você pode comprar se você colocar sua perda de parada em US $ 9,25? Aplique a regra de 2 por cento.
Dica: lembre-se de permitir a corretagem, comprar e vender e derrapagens (de dizer 25 centavos por ação).
Resposta: 360 partes (a um custo de $ 3600).
Capital em risco: US $ 20.000 * 2 por cento = $ 400.
Corretora de dedução: $ 400 - (2 * $ 20) = $ 360.
Risco por ação = $ 10,00 - $ 9,25 + $ 0,25 deslizamento = $ 1,00 por ação.
Número máximo de ações = $ 360 / $ 1 = 360 ações.
2 Percentagem é adequada para todos os comerciantes de equidade?
Nem todos os comerciantes enfrentam a mesma taxa de sucesso (ou confiabilidade como Van Tharp o chama). Os comerciantes de curto prazo geralmente conseguem maiores taxas de sucesso, enquanto os comerciantes de longo prazo geralmente conseguem maiores rácios de risco e recompensa.
Taxa de sucesso (confiabilidade)
Sua taxa de sucesso é o número de negociações vencedoras expressadas como uma porcentagem da sua quantidade total de negócios:
Taxa de sucesso = negociações vencedoras / (negociações vencedoras + negociações perdidas) * 100%
Relação Risco-Recompensa.
Sua relação risco-recompensa é o seu ganho esperado em relação ao seu capital em risco (ele deve realmente ser chamado de razão de recompensa / risco porque essa é a forma como é normalmente expressa). Se o seu ganho médio (depois de deduzir a corretora) em negociações vencedoras é de US $ 1000 e você arriscou consistentemente US $ 400 por comércio (como no exemplo anterior da regra de 2 por cento), sua relação risco-recompensa seria 2,5 a 1 (ou seja, $ 1000 / $ 400) .
Relação risco-recompensa = ganho médio em negociações vencedoras / capital médio em risco.
Níveis de Confiança.
Se tivermos três comerciantes:
Negociações de curto prazo e médias de lucro de 125% em todas as suas negociações.
Negociações de médio prazo e médias 200% de lucro em todas as suas negociações.
Negociações de longo prazo e médias de lucro de 325% em todas as suas trades.
Isso não significa necessariamente que o Trader C seja mais rentável do que A. O Trader A (curto prazo) é susceptível de fazer muitos outros negócios do que o Trader C. Você poderia ter a seguinte situação:
Risco relativo.
Calculamos agora o risco relativo que cada comerciante possui de uma redução de 20%. Use a calculadora de probabilidade binomial em faculty. vassar. edu/lowry/ch5apx. html:
Obviamente, quanto maior a sua taxa de sucesso, maior a porcentagem que você pode arriscar em cada comércio.
Tenha em mente que, com uma maior relação risco-recompensa, o Trader C só precisa de uma vitória em 10 negociações para se equilibrar; enquanto o comerciante A precisaria de cinco vitórias. No entanto, se compararmos os pontos de ponto de equilíbrio, ainda é claro que taxas de sucesso mais baixas são mais propensas a sofrer de redução.
Baixas taxas de sucesso.
Embora seu sistema de negociação possa ser lucrativo, se for suscetível a grandes retiradas, considere usar uma porcentagem menor de capital em risco (por exemplo, 1 por cento).
De volta ao mundo real.
Na negociação da vida real, não nos deparamos com uma distribuição binomial perfeita, como no exemplo acima:
os ganhos não são todos iguais; algumas perdas são maiores do que outras - parar as perdas ocasionalmente falhar quando os preços caem para cima / para baixo; probabilidades variam; e os resultados se influenciam - quando os estoques caem, tendem a cair juntos.
Covariância.
A maior falha na maioria dos sistemas de gerenciamento de riscos é que os movimentos de ações se influenciam. Os negócios individuais não são independentes. Os mercados marcham em uníssono e as ações individuais seguem. Claro que existem mavericks: ações que se elevam em um mercado de urso ou colapso no meio de um mercado de touro, mas são um punhado. A maioria segue como um rebanho de ovelhas.
Thomas Dorsey em Point & amp; Figure Charting dá um exemplo dos riscos que afetam um estoque típico:
O risco de o mercado se mover contra você é claramente o maior fator de risco único. Como protegemos contra isso?
Protegendo seu capital de uma série de perdas.
A regra de 2 por cento sozinha não o protegerá se você estiver segurando um grande número de ações bancárias durante uma bolha de ativos; estoques de seguros durante um desastre natural; ou estoque de tecnologia durante o boom Dotcom. Precisamos de uma rápida regra geral para medir a nossa exposição a uma determinada indústria ou mercado.
Setores independentes.
Limite sua exposição a setores específicos da indústria. No entanto, nem todos os setores são criados iguais. Os grupos industriais do setor de matérias-primas (ICB ou GICS) têm uma correlação bastante baixa e podem ser tratados como setores separados, enquanto os grupos industriais na maioria dos outros setores devem ser tratados como uma única unidade.
Podemos ver a partir do gráfico acima que Chemicals and Containers & amp; A embalagem tende a se mover em uníssono e deve ser tratada como um setor industrial, mas outros índices mostrados são suficientemente independentes para serem tratados separadamente.
Risco do setor.
Como regra geral, limite o seu capital total em risco em qualquer setor da indústria para 3 vezes o seu capital em risco (máximo) por ação (por exemplo, 6% do seu capital se você estiver usando a regra de 2 por cento).
Isso não significa que você está limitado a segurar 3 ações em qualquer setor. Você pode comprar um quarto estoque quando uma das suas 3 negociações iniciais já não estiver em risco (quando você moveu a parada acima do seu ponto de equilíbrio sobre o comércio); e um quinto quando você cobriu seu risco em outro comércio; e assim por diante.
Apenas tenha cuidado para não mover suas paradas com muita rapidez. Na sua pressa, você pode ser interrompido muito cedo - antes que a tendência seja iniciada.
Eu também sugiro que você aperte suas paradas em todas as posições de um setor se as paradas de proteção forem acionadas em 3 negociações diretas nesse setor (dentro de um período de tempo razoável). Por paradas de proteção, quero dizer, uma parada final projetada para sair da sua posição se a tendência mudar (por exemplo, um fechamento abaixo de um MA de longo prazo). Um período de tempo razoável pode variar de alguns dias para transações de curto prazo para várias semanas para transações de longo prazo.
Risco de mercado.
Você pode limitar o nosso risco de mercado de forma semelhante.
Limite o seu total de capital em risco no mercado para entre 5 e 10 vezes o seu capital em risco (máximo) por ação (por exemplo, 10% a 20% do seu capital se você estiver usando a regra de 2 por cento). Ajuste essa porcentagem de acordo com seu próprio perfil de risco. Além disso, quanto menor for o seu prazo e quanto maior for sua taxa de sucesso, maior será a porcentagem com a qual você possa arriscar-se confortavelmente.
Também é aconselhável apertar suas paradas em todas as posições se as paradas de proteção forem acionadas em 5 transações diretas dentro de um período de tempo razoável. As paradas de proteção não precisam ser as paradas originais definidas em uma troca. Você pode fazer um lucro geral no comércio, mas a parada deve indicar uma mudança de tendência.
Resumo do gerenciamento de dinheiro.
Uma regra geral para os mercados de ações é nunca arriscar mais de 2% do capital em qualquer estoque. Esta regra pode não ser adequada para os comerciantes de longo prazo que desfrutam de taxas de risco-recompensa mais altas, mas taxas de sucesso mais baixas. A regra também não deve ser aplicada isoladamente: seu maior risco é o risco de mercado, onde a maioria dos estoques se move em uníssono. Para proteger contra isso, limite seu capital em risco em qualquer setor, e também seu capital em risco em todo o mercado, em qualquer momento.

Idéia por sistema de comércio
(Por Jonathan Simon)
É fácil distanciar-se de uma grande coleção de padrões ou de uma linguagem padrão. Os padrões são a abstração de uma idéia em uma forma reutilizável. Muitas vezes, a natureza muito genérica dos padrões que os torna tão úteis também os torna difíceis de entender. Às vezes, a melhor coisa para ajudar a entender os padrões é um exemplo do mundo real. Não é um cenário artificial do que poderia acontecer; mas o que realmente acontece e o que acontecerá.
Este capítulo aplica padrões para resolver problemas usando um processo de descoberta. O sistema que discutiremos é um sistema de negociação de títulos com o qual trabalhei durante dois anos desde o projeto inicial até a produção. Exploraremos cenários e problemas que foram encontrados e como resolvê-los com padrões. Isso envolve o processo de decisão de escolher um padrão, bem como como combinar e ajustar padrões para atender às necessidades do sistema. E tudo isso é feito levando em consideração as forças encontradas em sistemas reais, incluindo requisitos de negócios, decisões de clientes, requisitos arquitetônicos e técnicos, bem como integração de sistemas legados. A intenção desta abordagem é proporcionar uma compreensão mais clara dos próprios padrões através da aplicação prática.
Construindo um sistema.
Um grande banco de investimento de Wall Street pretende construir um sistema de preços de títulos em um esforço para agilizar o fluxo de trabalho de sua mesa de negociação de títulos. Atualmente, os comerciantes de títulos têm que enviar preços para um grande número de títulos para vários locais de negociação diferentes, cada um com sua própria interface de usuário. O objetivo do sistema é minimizar as minúcias de avaliar todos os seus títulos combinados com funcionalidades analíticas avançadas específicas do mercado de títulos em uma única interface de usuário encapsulada. Isso significa integração e comunicação com vários componentes em vários protocolos de comunicação. O fluxo de alto nível do sistema parece ser o seguinte:
Fluxo de alto nível.
Primeiro, os dados do mercado entram no sistema. Os dados de mercado são dados relativos ao preço e outras propriedades do vínculo que representam o que as pessoas estão dispostas a comprar e vender o vínculo no mercado livre. Os dados do mercado são imediatamente enviados para o mecanismo de análise que altera os dados. A análise refere-se a funções matemáticas para aplicações financeiras que alteram os preços e outros atributos dos títulos. Estas são funções genéricas que usam variáveis ​​de entrada para adaptar os resultados da função a uma ligação particular. O aplicativo cliente que será executado em cada área de trabalho do comerciante configurará o mecanismo de análise por base de comerciante, controlando as especificidades da análise para cada vínculo, o comerciante está classificando os preços. Uma vez que a análise é aplicada aos dados do mercado, os dados modificados são enviados para vários locais de negociação em que os comerciantes de outras empresas podem comprar ou vender os títulos.
Arquitetura com padrões.
Com esta visão geral do fluxo de trabalho do sistema, podemos abordar alguns dos problemas arquitetônicos que encontramos durante o processo de design. Vamos dar uma olhada no que sabemos até agora. Os comerciantes precisam de uma aplicação muito receptiva nas estações de trabalho Windows NT e Solaris. Portanto, decidimos implementar o aplicativo cliente como um cliente de Java grosso devido à independência de sua plataforma e sua capacidade de responder rapidamente aos dados de entrada e ao mercado do usuário. Do lado do servidor, estamos herdando componentes C ++ legados que o nosso sistema utilizará. Os componentes de dados do mercado se comunicam com a infra-estrutura de mensagens TIBCO Information Bus (TIB).
Estamos herdando os seguintes componentes:
Market Data Price Feed Server: publica dados de mercado recebidos para o TIB. Mecanismo de análise: executa análises de dados de mercado recebidos e transmite os dados de mercado modificados para o TIB. Servidor de Contribuição: Executa toda a comunicação com os locais de negociação. Os locais de negociação são componentes de terceiros não controlados pelo banco.
Subsistema de dados do mercado legado.
Subsistema de contribuição legado.
Precisamos decidir como os subsistemas separados (Java thick client, data de mercado e contribuição) se comunicarão. Poderíamos que o cliente grosso se comunicasse diretamente com os servidores legados, mas isso exigiria muita lógica de negócios no cliente. Em vez disso, construiremos um par de gateways Java para se comunicar com os servidores herdados - O Gateway de preços para dados de mercado, um Contribution Gateway para enviar preços para os locais de negociação. Isso alcançará um bom encapsulamento da lógica de negócios relacionada a essas áreas. Os componentes atuais do sistema são mostrados abaixo. As conexões marcadas como ". - indicam que ainda não temos certeza de como alguns dos componentes se comunicarão.
O sistema e seus componentes.
A primeira questão de comunicação é como integrar o Java thick client e os dois componentes do servidor Java para trocar dados. Olhe nos quatro estilos de integração sugeridos neste livro: Transferência de arquivos, banco de dados compartilhado, Invocação de procedimento remoto e mensagens. Nós podemos descartar o banco de dados compartilhado imediatamente porque queríamos criar uma camada de abstração entre o cliente eo banco de dados e não queremos ter o código de acesso ao banco de dados no cliente. A transferência de arquivos pode ser descartada de forma similar, uma vez que é necessária uma latência mínima para garantir que os preços atuais sejam enviados para os locais de negociação. Isso nos deixa uma escolha entre Invocação de Procedimento Remoto ou Mensagens.
A plataforma Java fornece suporte incorporado para Invocação de Procedimentos Remotos e Mensagens. A integração com o estilo RPC pode ser alcançada usando o Remote Method Invocation (RMI), CORBA ou Enterprise Java Beans (EJB). O Java Messaging Service (JMS) é a API comum para integração com o estilo de mensagens. Portanto, ambos os estilos de integração são fáceis de implementar em Java.
Então, o que funcionará melhor para este projeto, Invocação de Procedimento Remoto ou Mensagens? Há apenas uma instância do Pricing Gateway e uma instância do Contribution Gateway no sistema, mas geralmente muitos Clientes Grossos se conectam simultaneamente a esses serviços (um para cada comerciante de títulos que esteja logado em um horário específico). Além disso, o banco gostaria que este fosse um sistema genérico de preços que possa ser utilizado em outras aplicações. Portanto, além de um número desconhecido de Think Clients, pode haver um número desconhecido de outras aplicações usando os dados de preços que saem dos Gateways.
Um Thick Client (ou outro aplicativo usando os dados de preços) pode bastante facilmente usar o RPC para fazer chamadas nos Gateways para obter dados de preços e invocar o processamento. No entanto, os dados de preços serão constantemente publicados, e certos clientes só estão interessados ​​em determinados dados, de modo que obter dados relevantes aos clientes adequados em tempo hábil pode ser difícil. Os clientes poderiam pesquisar os Gateways, mas isso criará muitas despesas gerais. Seria melhor para os Gateways disponibilizar os dados aos clientes assim que estejam disponíveis. Isso, no entanto, exigirá que cada Gateway fique atento a quais clientes estão atualmente ativos e que querem quais dados específicos; então, quando um novo pedaço de dados ficar disponível (o que acontecerá várias vezes por segundo), o Gateway terá que fazer um RPC para cada cliente interessado para transmitir os dados ao cliente. Idealmente, todos os clientes devem ser notificados simultaneamente, então cada RPC precisa ser feito em seu próprio segmento simultâneo. Isso pode funcionar, mas está ficando muito complicado muito rápido.
O Messaging simplifica muito esse problema. Com o Messaging, podemos definir canais separados para os diferentes tipos de dados de preços. Então, quando um Gateway obtém uma nova peça de dados, ele adicionará uma mensagem contendo esses dados ao Canal de Publicação-Inscrição para esse tipo de dados. Enquanto isso, todos os clientes interessados ​​em um determinado tipo de dados escutarão no canal para esse tipo. Desta forma, os Gateways podem facilmente enviar novos dados para quem está interessado, sem precisar saber quantos aplicativos de ouvintes existem ou o que são.
Os clientes ainda precisam ser capazes de invocar comportamentos nos Gateways também. Uma vez que existem apenas dois Gateways, e o cliente provavelmente pode bloquear enquanto o método é invocado de forma síncrona, essas invocações de cliente para Gateway podem ser facilmente implementadas usando o RPC. No entanto, uma vez que já estamos usando mensagens para a comunicação do Gateway para o cliente, as mensagens provavelmente são uma maneira tão boa de implementar a comunicação do cliente para o gateway também.
Portanto, toda comunicação entre os Gateways e os clientes será realizada através de mensagens. Como todos os componentes estão escritos em Java, o JMS apresenta uma escolha fácil para o sistema de mensagens. Isso efetivamente está criando um barramento de mensagens ou uma arquitetura que tornará possível que sistemas futuros se integrem com o sistema atual com poucas ou nenhuma alteração na infra-estrutura de mensagens. Desta forma, a funcionalidade de negócios da aplicação pode ser facilmente usada por outra aplicação que o banco desenvolve.
Componentes Java que Comunicam com o JMS.
O JMS é simplesmente uma especificação e precisamos decidir sobre um sistema de mensagens compatível com JMS. Nós decidimos usar o IBM MQSeries JMS porque o banco é uma "loja do Google", usando servidores de aplicativos da WebSphere e muitos outros produtos da IBM. Como resultado, usaremos o MQSeries já que já possuímos uma infraestrutura de suporte e uma licença de site do produto.
A próxima pergunta é como conectar o sistema de mensagens MQSeries com o servidor autônomo de C ++ Contribution e os servidores do Market Data e Analytics Engine baseados em TIBCO. Precisamos de um modo para os consumidores do MQSeries terem acesso às mensagens TIB. Mas como? Talvez possamos usar o padrão do Message Translator para traduzir mensagens TIB para mensagens MQSeries. Embora o cliente C ++ para MQSeries serve como um Message Translator, o uso dele sacrificaria a independência do servidor JMS. E embora a TIBCO tenha uma API Java, o arquiteto e o gerente do cliente rejeitaram. Como resultado, a abordagem do Message Translator deve ser abandonada.
A ponte do servidor TIB para o servidor MQSeries requer comunicação entre C ++ e Java. Podemos usar o CORBA, mas, então, sobre a mensagem? Um olhar mais atento sobre o padrão do Message Translator mostra que ele está relacionado ao Adaptador de Canal em seu uso de protocolos de comunicação. O coração de um Adaptador de Canal é conectar sistemas que não sejam de mensagens para sistemas de mensagens. Um par de adaptadores de canal que conecta dois sistemas de mensagens é uma ponte de mensagens.
A finalidade de um Messaging Bridge é transferir mensagens de um sistema de mensagens para outro. Isso é exatamente o que estamos fazendo com a complexidade adicionada da comunicação intra-linguagem Java para C ++. Podemos implementar a ponte de mensagens em linguagem cruzada usando uma combinação de Channel Adapter s e CORBA. Construiremos dois servidores de Adaptadores de Canal leves, um em gerenciamento de comunicação C ++ com o TIB e outro em Java gerenciando comunicação com o JMS. Esses dois canais de adaptador, que são os próprios pontos de mensagem, se comunicarão entre si através do CORBA. Como a nossa escolha para o MQSeries, usaremos CORBA em vez de JNI, uma vez que é um padrão da empresa. A ponte de mensagens implementa a tradução de mensagens efetivamente simulada entre sistemas de mensagens aparentemente incompatíveis e diferentes idiomas.
Message Translator usando Adaptadores de canais.
O próximo diagrama mostra o design do sistema atual, incluindo os Gateways e outros componentes. Este é um bom exemplo de aplicação de padrões. Combinamos dois Channel Adapter s com um protocolo não-mensagens para implementar o padrão Message Translator, usando efetivamente um padrão para implementar outro padrão. Além disso, mudamos o contexto do adaptador do canal para vincular dois sistemas de mensagens com um protocolo de conversão de idioma cruzado que não seja de mensagens em vez de conectar um sistema de mensagens a um sistema que não seja de mensagens.
O sistema atual com os Adaptadores de Canal.
Canais Estruturadores.
Uma chave para trabalhar com padrões não é apenas saber quando usar qual padrão, mas também como usá-lo de forma mais eficaz. Cada implementação de padrão deve ter em conta especificidades da plataforma tecnológica, bem como outros critérios de design. Esta seção aplica o mesmo processo de descoberta para encontrar o uso mais eficiente do canal Publish-Subscribe no contexto do servidor de dados de mercado que se comunica com o mecanismo analítico.
Os dados do mercado em tempo real originam-se com o feed de dados do mercado, um servidor C ++ que transmite dados de mercado no TIB. O feed de dados do mercado usa um canal de publicação-inscrição separado para cada vínculo para o qual é o preço de publicação. Isso pode parecer um pouco extremo, uma vez que cada nova ligação precisa do seu próprio novo canal. Mas isso não é tão grave, pois você realmente não precisa criar canais no TIBCO. Em vez disso, os canais são referenciados por um conjunto hierárquico de nomes de tópicos chamados de assuntos. O servidor TIBCO filtra um único fluxo de mensagens por assunto, enviando cada assunto exclusivo para um único canal virtual. O resultado é um canal de mensagem muito leve.
Poderíamos criar um sistema que publica em alguns canais e os assinantes poderiam ouvir apenas os preços que lhes interessam. Isso exigiria que os assinantes usassem um Filtro de Mensagens ou um Consumidor Seletivo para filtrar todo o fluxo de dados para preços de títulos interessantes, decidindo se cada mensagem deve ser processado conforme recebido. Dado que os dados de mercado são publicados em canais dedicados, os assinantes podem se inscrever para atualizações sobre uma série de títulos. Isso efetivamente permite que os assinantes "filtrar" seletivamente se inscrevendo em canais e apenas recebendo atualizações de interesse ao invés de decidir depois que a mensagem é recebida. É importante notar que o uso de múltiplos canais para evitar a filtragem é um uso não padrão de canais de mensagens. No contexto da tecnologia TIBCO, no entanto, estamos realmente decidindo se implementamos ou possuímos filtros ou utilizamos a filtragem de canais incorporada no TIBCO - em vez de usar tantos canais.
O próximo componente que precisamos projetar é o mecanismo de análise, outro servidor C ++ / TIB que modificará os dados do mercado e o retransmitirá para o TIB. Embora esteja fora do alcance do nosso desenvolvimento Java / JMS, estamos trabalhando em estreita colaboração com a equipe C ++ para projetá-lo, já que somos o principal "cliente" do motor de análise. O problema em questão é encontrar a estrutura do canal que retransmita os dados de mercado recentemente modificados.
Uma vez que já possuímos um canal de mensagens dedicado por vínculo herdado do preço de preço do mercado, seria lógico modificar os dados do mercado e retransmitir os dados de mercado modificados no canal de mensagens dedicado. Mas isso não funcionará uma vez que os analíticos que modificam os preços dos títulos são específicos do comerciante. Se nós retransmitimos os dados modificados no canal de mensagens de ligação, destruiremos a integridade dos dados, substituindo dados genéricos de mercado por dados específicos do comerciante. Por outro lado, podemos ter um tipo de mensagem diferente para os dados de mercado específicos do comerciante que publicamos no mesmo canal, permitindo que os assinantes decidam qual mensagem eles estão interessados ​​para evitar destruir a integridade dos dados. Mas então os clientes terão que implementar seus próprios filtros para separar mensagens para outros comerciantes. Além disso, haverá um aumento substancial nas mensagens recebidas pelos assinantes, colocando um encargo desnecessário sobre eles.
Existem duas opções:
Um canal por comerciante: cada comerciante tem um canal designado para os dados de mercado modificados. Desta forma, os dados de mercado originais permanecem intactos e cada aplicação de comerciante pode ouvir seus comerciantes específicos Message Channel para as atualizações de preços modificadas. Um Canal por comerciante por Obrigatório: Crie um Canal de Mensagens por comerciante por ação unicamente para os dados de mercado modificados dessa ligação. Por exemplo, os dados de mercado para a ligação ABC seriam publicados no canal "Bond ABC", enquanto os dados de mercado modificados para o comerciante A seriam publicados no Message Channel "Trader A, Bond ABC", dados de mercado modificados para o comerciante B em "Trader B , Bond ABC, "e assim por diante.
Um canal por comerciante.
Um canal por ligação por comerciante.
Existem vantagens e desvantagens para cada abordagem. A abordagem por vínculo, por exemplo, usa muito mais Message Channel. No pior caso, o número de Canal de Mensagens será o número total de títulos multiplicado pelo número de comerciantes. Podemos colocar limites superiores sobre o número de canais que serão criados, já que sabemos que existem apenas cerca de 20 comerciantes e nunca mais do que um par cento de títulos. Isso coloca o limite superior abaixo do alcance de 10.000, o que não é tão estranho em comparação com o canal de mensagens de quase 100.000 que o preço do preço de mercado está usando. Além disso, uma vez que estamos usando o TIB eo canal de mensagens são bastante baratos, o número de canais de mensagens não é um problema grave. Por outro lado, o número total de canais de mensagens pode ser um problema na perspectiva da gestão. Toda vez que um vínculo é adicionado, um canal para cada comerciante deve ser mantido. Isso pode ser severo em um sistema muito dinâmico. Nosso sistema, no entanto, é essencialmente estático. Ele também possui uma infra-estrutura para gerenciar automaticamente o canal de mensagens s. Isso combinado com a arquitetura herdada de um componente legado usando uma abordagem similar minimiza a desvantagem. Isso não quer dizer que devemos fazer um número desnecessariamente excessivo de Message Channel s. Em vez disso, podemos implementar uma abordagem arquitetônica que usa um grande número de canais de mensagens quando há um motivo.
E há um motivo neste caso que se resume à localização da lógica. Se implementarmos a abordagem por comerciante, o Analytics Engine precisa de lógica para agrupar canais de entrada e saída. Isso ocorre porque os canais de entrada do Google Analytics Engine são por ligação e o Canal de Mensagens de saída seria por comerciante, exigindo que o Engine Analytics encaminhe toda a entrada de análise de múltiplas ligações para um comerciante particular para um canal de mensagens de saída específico do comerciante. Isso efetivamente transforma o mecanismo de análise em um roteador baseado em conteúdo para implementar lógica de roteamento personalizada para nossa aplicação.
Seguindo a estrutura do Bus de mensagens, o Analytics Engine é um servidor genérico que pode ser usado por vários outros sistemas no. Portanto, não queremos nublá-lo com funcionalidades específicas do sistema. Por outro lado, a abordagem por vínculo funciona uma vez que a idéia de um comerciante possuir o resultado analítico dos preços dos títulos é uma prática aceita pela empresa. A abordagem por vínculo mantém intacta a separação do canal de mensagens do fluxo de dados do mercado, enquanto adiciona mais alguns canais de mensagens. Antes de chegar ao cliente, queremos que um roteador baseado em conteúdo combine esses vários canais em um número gerenciável de canais. Não queremos que o aplicativo cliente em execução na área de trabalho do comerciante esteja ouvindo milhares ou dezenas de milhares de canais de mensagens. Agora, a questão se torna onde colocar o Roteador baseado em conteúdo. Poderíamos simplesmente ter o Adaptador de Canal C ++ / TIB encaminhar todas as mensagens para o Gateway de Preços em um único Canal de Mensagens. Isso é ruim por dois motivos; estariamos dividindo a lógica de negócios entre C ++ e Java, e perderíamos o benefício do Canal de Mensagens separado no lado TIB, permitindo-nos evitar a filtragem mais tarde no fluxo de dados. Olhando para os nossos componentes Java, podemos colocá-lo no Pricing Gateway ou criar um componente intermediário entre o Pricing Gateway e o cliente.
Em teoria, se persistisse na separação baseada em vínculo do Message Channel s até o cliente, o Pricing Gateway retransmitiria informações de preços com a mesma estrutura de canal que o Passo de Preços e o Engine Analytics. Isso significa uma duplicação de todos os canais dedicados TIB dedicados no JMS. Mesmo que criemos um componente intermediário entre o Gateway de preços e o cliente, o Gateway de preços ainda precisará duplicar todos os canais no JMS. Por outro lado, implementar a lógica diretamente no Pricing Gateway nos permite evitar a duplicação do grande número de canais no JMS, permitindo-nos criar um número muito menor de canais na ordem de um por trader. O Pricing Gateway registra-se através do Adaptador de Canal C ++ / TIB como consumidor para cada ligação de todos os comerciantes do sistema. Em seguida, o Gateway de preços encaminhará cada cliente específico apenas as mensagens relacionadas a esse comerciante específico. Desta forma, usamos apenas um pequeno número de canais de mensagens no final do JMS, ao mesmo tempo que maximizamos o benefício da separação no final TIB.
O fluxo de dados de mercado completo para o cliente.
A discussão de layout do Canal de Mensagens é um bom exemplo de como os padrões de integração são importantes. O objetivo aqui foi descobrir como usar efetivamente o canal de mensagens s. Dizendo que você usa um padrão não é suficiente. Você precisa descobrir como implementá-lo e incorporar no seu sistema para resolver os problemas em questão. Além disso, este exemplo mostra as forças de negócios em ação. Se pudéssemos implementar lógica de negócios em qualquer um dos nossos componentes, poderíamos ter ido com a abordagem por comerciante e implementado uma abordagem global mais simples com muitos canais menos.
Selecionando um canal de mensagens?
Agora que conhecemos a mecânica da comunicação entre os componentes Java / JMS e os componentes C ++ / TIBCO, e vimos alguma estruturação do Canal de Mensagens, precisamos decidir qual tipo de Canal de Mensagens JMS os componentes Java devem usar para se comunicar. Antes que possamos escolher entre os diferentes canais de mensagens disponíveis no JMS, vejamos o fluxo de mensagens de alto nível do sistema. Temos dois gateways (Preços e Contribuição) que se comunicam com o cliente. Os fluxos de dados do mercado para o cliente do Pricing Gateway, que o envia para o Contribution Gateway. O aplicativo cliente envia mensagem para o gateway de preços para alterar a análise que está sendo aplicada a cada ligação. O Contribution Gateway também envia mensagens para o aplicativo Cliente, transmitindo o status das atualizações de preços para os diferentes locais de negociação.
O fluxo de mensagens do sistema.
A especificação JMS descreve dois tipos de Canal de Mensagens, Canal Ponto a Ponto (Fila JMS) e Canal de Publicação-Inscrição (Tópico JMS). Lembre-se de que o caso de usar o publish-subscribe é permitir que todos os consumidores interessados ​​recebam uma mensagem enquanto o caso para usar ponto a ponto é garantir que apenas um consumidor elegível receba uma mensagem específica.
Muitos sistemas simplesmente transmitiam mensagens para todos os aplicativos do cliente, deixando cada aplicativo cliente individual decidir se deve ou não processar uma mensagem específica. Isso não funcionará para o nosso aplicativo, uma vez que há uma grande quantidade de mensagens de dados de mercado enviadas para cada aplicativo de cliente. Se transmitimos atualizações de dados de mercado para o comerciante desinteressado, estaremos desperdiçando desnecessariamente os ciclos do processador do cliente, decidindo se deve ou não processar uma atualização de dados de mercado.
O canal ponto-a-ponto inicialmente parece ser uma boa escolha, pois os clientes estão enviando mensagens para servidores exclusivos e vice-versa. Mas era um requisito de negócios que os comerciantes pudessem estar logados em várias máquinas ao mesmo tempo. Se tivermos um comerciante logado em duas estações de trabalho simultaneamente e uma atualização de preço ponto a ponto for enviada, apenas uma das duas aplicações clientes receberá a mensagem. Isso ocorre porque apenas um consumidor em um canal ponto-a-ponto pode receber uma mensagem específica. Observe que apenas o primeiro de cada grupo de aplicativos cliente de um comerciante recebe a mensagem.
Mensagens ponto-a-ponto para atualizações de preços.
Podemos resolver isso usando o padrão da Lista de Destinatários, que publica mensagens para uma lista de destinatários pretendidos, garantindo que apenas clientes na lista de destinatários receberão mensagens. Usando esse padrão, o sistema poderia criar listas de destinatários com todas as instâncias de aplicativos do cliente relacionadas a cada comerciante. Enviar uma mensagem relacionada a um comerciante específico, por sua vez, enviaria a mensagem para cada aplicativo na lista de destinatários. Isso garante que todas as instâncias de aplicativos do cliente relacionadas a um comerciante específico receberiam a mensagem. A desvantagem dessa abordagem é que requer um pouco de lógica de implementação para gerenciar os destinatários e enviar mensagens.
Lista de destinatários para atualizações de preços.
Embora ponto-a-ponto possa ser feito para o trabalho, vamos ver se há uma maneira melhor. Usando Publish-Subscribe Channel s, o sistema pode transmitir mensagens em canais específicos do comerciante em vez de canais específicos de aplicativos do cliente. Desta forma, todas as mensagens de processamento de aplicativos do cliente para um comerciante único receberiam e processariam a mensagem.
Publicar-Assinar mensagens para atualizações de preços.
A desvantagem de usar o Publish-Subscribe Channel s é que o processamento de mensagens exclusivo não é garantido com os componentes do servidor. Seria possível que várias instâncias de um componente de servidor fossem instanciadas e cada instância processasse a mesma mensagem, possivelmente enviando preços inválidos.
Recordando o fluxo de mensagens do sistema, apenas uma única direção de comunicação é satisfatória com cada Canal de Mensagens. A comunicação de servidor para cliente com publicação-inscrição é satisfatória enquanto a comunicação cliente-servidor não é e a comunicação cliente-servidor com ponto-a-ponto é satisfatória enquanto o servidor-cliente não é. Como não há necessidade de usar o mesmo canal de mensagens em ambas as direções, podemos usar cada canal de mensagens apenas uma direção. A comunicação de cliente para servidor será implementada com ponto a ponto, enquanto a comunicação de servidor para cliente será implementada com publicação-assinar. Usando esta combinação de Message Channel s, o sistema se beneficia da comunicação direta com os componentes do servidor usando mensagens ponto-a-ponto e a natureza multicast de publish-subscribe sem nenhuma das desvantagens.
Fluxo de mensagens com tipos de canais.
Solução de problemas com padrões.
Os padrões são ferramentas e coleções de padrões são caixas de ferramentas. Eles ajudam a resolver problemas. Alguns pensam que os padrões só são úteis durante o projeto. Seguindo a analogia da caixa de ferramentas, isso é como dizer que as ferramentas são úteis somente quando você constrói uma casa e não quando você a conserta. O fato é que os padrões são uma ferramenta útil ao longo de um projeto quando aplicado bem. Nas seções a seguir, usaremos o mesmo processo de exploração de padrões que usamos na seção anterior para resolver problemas no nosso sistema agora trabalhando.
Flashing Market Data Updates.
Os comerciantes querem que as células da tabela piscem quando novos dados do mercado são recebidos para uma ligação, indicando claramente as mudanças. O cliente Java recebe mensagens com dados novos que desencadeiam uma atualização de cache de dados do cliente e, eventualmente, piscam na tabela. O problema é que as atualizações são bastante frequentes. A pilha de threads GUI está se tornando sobrecarregada e eventualmente congelando o cliente, uma vez que não pode responder à interação do usuário. Assumiremos que o flashing está otimizado e concentra-se no fluxo de dados das mensagens através do processo de atualização. Um exame de dados de desempenho mostra que o aplicativo cliente está recebendo várias atualizações por segundo; algumas atualizações ocorreram menos do que um milésimo de segundo. Dois padrões que parecem ajudar a abrandar o fluxo de mensagens são Aggregator e Message Filter.
Um primeiro pensamento é implementar um Filtro de Mensagens para controlar a velocidade do fluxo de mensagens jogando as atualizações recebidas uma pequena quantidade de tempo após a mensagem de referência. Por exemplo, digamos que vamos ignorar as mensagens dentro de 5 milissegundos um do outro. O Filtro de mensagens pode armazenar em cache o tempo da última mensagem aceitável e eliminar qualquer coisa recebida nos próximos 5 milissegundos. Embora outras aplicações possam não suportar a perda de dados de tal forma, isso é perfeitamente aceitável em nosso sistema devido à freqüência de atualizações de preços.
Filtro de mensagens com base no tempo.
O problema com esta abordagem é que nem todos os campos de dados são atualizados ao mesmo tempo. Cada ligação tem aproximadamente 50 campos de dados exibidos para o usuário, incluindo o preço. Nós percebemos que nem todos os campos são atualizados em todas as mensagens. Se o sistema ignora mensagens consecutivas, pode muito bem estar descartando dados importantes.
O outro padrão de interesse é o agregador. The Aggregator is used to manage the reconciliation of multiple, related messages into a single message, potentially reducing the message flow. The Aggregator could keep a copy of the bond data from the first aggregated message, then update only new or changed fields successive messages. Eventually the aggregated bond data will be passed in a message to the client. For now, lets assume that the Aggregator will send a message every 5 milliseconds like the Message Filter . Later, we'll explore another alternative.
Aggregator with partial successive updates.
The Aggregator , like any other pattern, is not a silver bullet; it has its pluses and minuses that need to be explored. One potential minus is that implementing an Aggregator would reduce the message traffic by a great amount in our case only if many messages are coming in within a relatively short time regarding the same bond. On the other hand, we would accomplish nothing if the Java client only receives updates for one field across all of the traders bonds. For example, if we receive 1000 messages in a specified timeframe with 4 bonds of interest, we would reduce the message flow from 1000 to 4 messages over that timeframe. Alternatively, if we receive 1000 messages in the same timeframe with 750 bonds of interest, we will have reduced the message flow from 1000 to 750 messages; relatively little gain for the amount of effort. A quick analysis of the message updates proves that the Java client receives many messages updating fields of the same bond, and therefore related messages. So, Aggregator is in fact a good decision.
What's left is to determine how the Aggregator will know when to send a message it has been aggregating. The pattern describes a few algorithms for the Aggregator to know when to send the message. These include algorithms to cause the aggregator to send out its contents after a certain amount of time has elapsed, after all required fields in a data set have been completed, and others. The problem with all of these approaches is that the aggregator is controlling the message flow, not the client. And the client is the major bottleneck in this case, not the message flow.
This is because the Aggregator is assuming the consumers of its purged messages (the client application in this case) are Event-Driven Consumer s, or consumers that rely on events from an external source. We need to turn the client into a Polling Consumer , or a consumer that continuously checks for messages, so the client application can control the message flow. We can do this by creating a background thread that continuously cycles through the set of bonds and updates and flashes any changes that have occurred since the last iteration. This way, the client controls when messages are received and as a result, guarantees that it will never become overloaded with messages during high update periods. We can easily implement this by sending a Command Message to the Aggregator initiating an update. The Aggregator will respond with a Document Message containing the set of updated fields that the client will process.
The choice of Aggregator over Message Filter is clearly a decision based solely on the business requirements of our system. Each could help us solve our performance problems, but using the Message Filter would solve the problem at cost of the system data integrity.
Major Production Crash.
With the performance of the flashing fixed, we are now in production. One day the entire system goes down. MQSeries crashes, bringing several components down with it. We struggle with the problem for a while and finally trace it back to the MQSeries dead letter queue (an implementation of the Dead Letter Channel ). The queue grows so large that it brings down the entire server. After exploring the messages in the dead letter queue we find they are all expired market data messages. This is caused by “slow consumers, ” or consumers that do not process messages fast enough. While messages are waiting to be processed, they time out (see the Message Expiration pattern) and are sent to the Dead Letter Channel . The excessive number of expired market data messages in the dead letter queue is a clear indication that the message flow is too great – messages expire before the target application can consume them. We need to fix the message flow and we turn to patterns for help slowing down the message flow.
A reasonable first step is to explore solving this problem with the Aggregator as we recently used this pattern to solve the similar flashing market data control rate problem. The system design relies on the client application to immediately forward market data update messages to the trading venues. This means the system cannot wait to collect messages and aggregate them. So the Aggregator must be abandoned.
There are two other patterns that deal with the problem of consuming messages concurrently: Competing Consumers and Message Dispatcher . Starting with Competing Consumers , the benefit of this pattern is the parallel processing of incoming messages. This is accomplished using several consumers on the same channel. Only one consumer processes each incoming message leaving the others to process successive messages. Competing Consumers , however, will not work for us since we are using Publish-Subscribe Channel s in server-to-client communication. Competing Consumers on a Publish-Subscribe Channel channel means that all consumers process the same incoming message. This results in more work without any gain and completely misses the goal of the pattern. This approach also has to be abandoned.
On the other hand, the Message Dispatcher describes an approach whereby you add several consumers to a вЂ˜pool’. Each consumer can run its own execution thread. One main Message Consumer listens to the Channel and delegates the message on to an unoccupied Message Consumer in the pool and immediately returns to listening on the Message Channel . This achieves the parallel processing benefit of Competing Consumers , but works on Publish-Subscribe Channel s.
The Message Dispatcher in context.
Implementing this in our system is simple. We create a single JMSListener called the Dispatcher, which contains a collection of other JMSListener s called Performers. When the onMessage method of the Dispatcher is called, it in turn picks a Performer out of the collection to actually process the message. The result of which is a Message Listener (the Dispatcher) that always returns immediately. This guarantees a steady flow of message processing regardless of the message flow rate. Additionally, this works equally well on a Publish-Subscribe Channel s as it does on a Point-to-Point Channel s. With this infrastructure, messages can be received by the client application at almost any rate. If the client application is still slow to process the message after receiving them, the client application can deal with the delayed processing and potentially outdated market data rather than the messages expiring in the JMS Message Channel .
The crash discussed in this section and the fix using the Message Dispatcher is an excellent example of the limits of applying patterns. We encountered a performance problem based on a design flaw not allowing the client to process messages in parallel. This greatly improved the problem, but did not completely fix it. This is because the real problem was the client becoming a bottleneck. This couldn’t be fixed with a thousand patterns. We later addressed this problem by refactoring the message flow architecture to route messages directly from the Pricing Gateway to the Contribution Gateway. So patterns can help design and maintain a system, but don’t necessarily make up for poor upfront design.
Throughout this chapter, we have applied patterns to several different aspects of a bond trading system including solving initial upfront design problems and fixing a nearly job threatening production crash with patterns. We also saw these patterns as they already exist in third party product, legacy components, and our JMS and TIBCO messaging systems. Most importantly, these are real problems with the same types of architectural, technical and business problems we experience as we design and maintain our own systems. Hopefully reading about applying patterns to this system helps give you a better understanding of the patterns as well as how to apply them to your own systems.
Gregor Hohpe and Bobby Woolf.
From Enterprise Integration to Enterprise Transformation:
My new book describes how architects can play a critical role in IT transformation by applying their technical, communication, and organizational skills with 37 episodes from large-scale enterprise IT.

Idee per trading system

 Per costruire un trading journal è relativamente semplice per chiunque abbia delle competenze elementari di computer creare un foglio di lavoro in Excel: le colonne conterranno le categorie, mentre le righe le trade.
Le voci basilari che un diario di trading deve necessariamente avere sono:
Data Ora apertura trade Coppia di valute Long/Short Prezzo di entrata Stop loss Target Prezzo di chiusura Guadagno/Perdita (in pips) Note.
Questo vi consentirà eventualmente di ritrovare le trade nel grafico e andarle a rivedere.
Nelle note è importante essere brevi, ma scrivere osservazioni importanti tipo le emozioni al momento dell'apertura della trade, le motivazioni di apertura chiusura, ostacoli, dubbi, ecc).
Questo esempio di diario va bene, ma risulta un po' scarno e non fornisce troppe informazioni. Suggerisco quindi di inserire altre colonne nel vostro foglio di lavoro, ecco alcuni spunti:
Timeframe utilizzato Distanza stop loss in pip Risk/Reward Guadagno/perdita (in €) Target raggiunto? (Nel caso abbia chiuso anticipatamente la trade, i prezzi sono andati fino al target alla fine?) Voto all'entrata (0=entrata sbagliata, 1=entrata anticipata, 2=entrata in ritardo, 3=entrata giusta) Voto alla chiusura (0=uscita sbagliata, 1=uscita anticipata, 2=uscita in ritardo, 3=uscita giusta) Voto complessivo alla trade News hanno influenzato la trade? Si/No? Quali? Screenshot (ottimo è salvare gli screenshot in uno dei tanti siti che permettono il salvataggio delle immagini gratuite e contrassegnarle le immagini con il numero corrispondente della trade nel diario.)
Poi per gli amanti della statistica e per i più competenti in Excel, ci si può sbizzarrire a creare delle statistiche derivate dai dati registrati. Ad esempio:
Numero di Short Numero di Long Numero Short vinti Numero Short persi Totale trade vinte % trade vinte Tabella % voti entrate/uscite/trade Distanza media stop loss Distanza media target Risk/Reward medio Numero trade vinte la mattina Numero trade vinte il pomeriggio Numero trade che hanno raggiunto il target Numero trade che hanno raggiunto lo stop loss.
Insomma si può veramente dar sfogo alla fantasia! Non è necessario avere tutte queste informazioni, ognuno deve tenere quelle di cui ha bisogno e che crede possano fornire indicazioni utili.
All'inizio è un processo un po' noioso ma dopo un po' diventa abitudine e anche piacevole riguardare le trade e riesaminarle. Nel prossimo articolo cercheremo di dare qualche spunto per l'interpretazione del diario.