Discussion of article "Automata-Based Programming as a New Approach to Creating Automated Trading Systems" - page 3

[Mykola Demko]

Rorschach:

"3. I was curious and wanted to hear the white noise of real ticks, and was able to do so using WaveLab 6.0 software."

Hee. It turns out I am not the only nutter like this))))) Here's what I got. I did it through Adobe Audience.

How did you normalise the price?

As usual, by cutting off long tails, everything that goes beyond 3*sko is brought to this value.

[Rustamzhan Salidzhanov]

A carload of emotions

1) A lot of bukaf nothing...

2) Looking at this you begin to realise why Americans are on Mars now and not us.

3) I'd rather keep silent about the rest (for only emotions).

[Гребенев Вячеслав]

I liked the article, especially about modern practice of programme development and documentation. That is how it is.

Of course, the article should have shown at least the simplest Expert Advisor based on the method of automata. Or is it planned for the next article?

And one big problem of the automata method in my opinion. For real Expert Advisors it is impossible to define the State unambiguously. The state of the Expert Advisor is determined by some internal variables on the user's computer and the State of positions (current rate, equity, execution of orders) on the server. The internal state is determined unambiguously, but the state of positions on the server can be unknown, known with a delay, be in an unclear state (some orders and requests are executed, and some are not, and hell knows why).

And since the current state of the advisor is not known, orders and requests are not executed, it is impossible to build a clear logic of automata. In reality, we get this algorithm:

comp: Buy me a couple of hundred eurobucks, server.

server: Fuck you, comp, your stops in the request are wrong.

comp: Why are they wrong?

server: so the price jumped.

comp: well, then buy without stops.

server is silent

comp: well, what did you buy?

server is silent

comp: well, fuck you. Let's take a nap for eight minutes.

Comp in eight minutes: how's it going?

server: I bought eurobucks, but while buying the price went somewhere else.

comp: Fuck it. Let's take another hour's nap.

And so on.

[Valerii Mazurenko]

evolution goes in circles - it is time to return to (un)finite automata, then we will build Turing machines.

[Andrey F. Zelinsky]

Virty:

...

And one big problem of the automata method, in my opinion. For real Expert Advisors it is impossible to unambiguously define the State. The state of the Expert Advisor is determined by some internal variables on the user's computer and the state of positions (current rate, equity, execution of orders) on the server. The internal state is determined unambiguously, but the state of positions on the server can be not known, known with a delay, be in an unclear state (some orders and requests are executed, and some are not, and hell knows why).

Well, since the current state of the EA is not known, orders and requests are not executed, it is impossible to build a clear logic of automata.

...

This is something new. Just ANY (without exception) TS is based on analysis and clear understanding of TS states. The simplest states: processing of signals for opening/closing/modifying an order, etc. etc.

If "the current state of the EA is not clearly known", then it is definitely not an EA, and definitely not a programme, and the word "algorithm" in relation to an EA should be crossed out and forgotten forever.

[Vasiliy Sokolov]

A lot of emotion.

O.K., I propose to turn the discussion into a practical direction. Let's analyse a concrete algorithm based on the theory of finite automata. Let's discuss its strengths and weaknesses. I don't write by this method myself, but I am a little bit familiar with the question and algorithms, so now I will sketch the general principle of this control:

//СХЕМА + ПСВЕДОКОД
enum eTradeState {NoTradeRegim, BuyRegim, SellRegim, WaitRegim};
eTradeState TradeState = eTradeState.NoTradeRegim;
int Trade()
{
   switch (TradeState)
   {
       case eTradeState.NoTradeRegim:
          NoTradeRegim();
          break;
       case eTradeState.WaitRegim:
          WaitRegim();
          break;
       case eTradeState.SellRegim:
          SellRegim();
          break;
       case eTradeState.BuyRegim:
          BuyRegim();
          break;
   }
}
//Here we describe the conditions under which the Expert Advisor will start trading. For example
void NoTradeRgim()
{
   //Further pseudocode follows. 
   if(CurrentDay == WorksDays && Market.Enable = true)
      TradeState = eTradeState.WaitRegim;
}
//Here we catch signals to enter a long or short position.
void WaitRegim()
{
   if(CheckForNoTrade() == true)
   {
      TradeState = eTradeState.NoTradeRegim;
   }
   if(CheckForBuy() == true)
   {
      BuyAtStop(...)
      TradeState = eTradeState.BuyRegim;
   }
   if(CheckForSell() == true)
   {
      SellAtStop(...);
      TradeState = eTradeState.SellRegim;
   }
}
//In this function we accompany a long deal
void BuyRegim()
{
   //Write here the conditions under which the deal is closed, or its stop loss or other parameters are changed, etc.
   if(StopLossChanged() == true)
      NewStop = ...;
   if(profit >= takeprofit)
   {
      CloseDeal(...);
      TradeState = eTradeState.WaitRegim;
   }

}
//In this function we accompany a short trade
void SellRegim()
{
   //Write here the conditions under which the deal is closed, or its stop loss is moved, etc.
   if(StopLossChanged() == true)
      NewStop = ...;
   if(profit >= takeprofit)
   {
      CloseDeal(...);
      TradeState = eTradeState.WaitRegim;
   }

}

Described schematically, but I think the basic idea is clear. At each moment of time the Expert Advisor has only one state (non-market mode, signal waiting mode, buying mode, selling mode). In each state there is a certain set of actions and conditions under which the transition from the current state to another one will occur. The idea is that we clearly control each of the states and therefore the internal logic is strictly localised and such logical errors as closing a non-existent or already closed transaction simply cannot occur.

I do not write with this technique myself, I think that it is not suitable for all algorithms. But still it solves some tasks better than the classical approach.

What do experts think about it?

[Mykola Demko]

C-4:
...

I don't write with this technique myself, I think that it is not suitable for all algorithms. But still it solves some problems better than the classical approach.

What do experts think about it?

And may I ask what you mean by the phrase "classical approach"?

Because everyone has their own reflection of reality.

[Vasiliy Sokolov]

Urain:

Can I ask you what you mean by "classical approach"?

Because everyone has their own reflection of reality.

I must have misspoken. Of course, everyone writes in his own way. I meant most approaches when the state of the system at each step is not clearly defined. It needs to be determined not only during the execution of the Expert Advisor. The simplest example is the code written in one block OnTick(). No modes are analysed. The choice of a solution is made on the basis of block branching if(...).

[Andrey F. Zelinsky]

C-4:
I was referring to most approaches when the system state at each step is not clearly defined. It needs to be determined at the time of EA execution.

If the state is "not clearly defined", how can you define what is "not clearly defined"? In the case of working with orders/position, is it not necessary for the EA to understand at each tick what state it is in? Or is the EA on every tick in an "undefined state". What kind of EA is it that doesn't know what to do on every tick?

[Dmitry Fedoseev]

The article does not cover the topic at all, except that there is a switch. It doesn't matter whether it exists or not, it can be switched by if's.

Once I was writing an EA, there was a very complex system with orders. I had to analyse it seriously and make a list of states: no orders, one pending, one market order, two pending orders, one pending and one market order, etc. Only in this way I managed to overcome it. But it turned out to be such a universal, quickly reprogrammable thing. Quite a topic for an article.