Enhancements to an EA as a preliminary to regular job requirements.

Here are the details of the new Project that you will be required to deliver.

As described below, the code for a live system already exists, but has been built in an ad hoc form by an inexperienced coder. The job is to enhance this code to provide a more professional product.

Part 1: Enhance existing code for Limit order strategy

There are a couple of repeating errors that could certainly be ironed out with an experienced MT4 programmer. In addition we think that it is likely the code could be written with better attention to threading and speed of operation.

Part 2: Minor redesign in order to become more modular.

It is our goal to allow multiple signal strategies to drop into the same execution framework. But this would require a more explicit separation between Signal and Execution Processes in the code. We want an environment that would become a generic Execution environment for multiple Signal strategies (not necessarily simultaneously).

Part 3: Add a ‘Main’ screen to accommodate live reporting for multiple symbols simultaneously.

This is an additional component which is able to bring together up to 20 simultaneous symbols and visualize their risk and margin requirements as well as other details.

Part 4: Accommodate the possibility of Partial Fills and multiple trades.

The current system has an assumption of a single lot size and complete fills at all times. But this may not always be the case. We will need extra logic to allow for these possibilities.

And here is the brief specification of the existing system that will give you an idea of the underlying system, describing each element of the existing code base.

Ultra-simple random Buy/Sell strategy, which places and modifies limit orders based upon a simple assessment of volatility and spread.

Introduction

Here we are simply generating a random Binary +1/-1 signal which drives Buy and Sell trades to our new trading venues via FIX connections. The purpose of this exercise is purely to test the trading environment with very small and consistent sizes, in particular testing a variety of Order types – Market Orders and Limit, Pending Orders – as well as the ability to rapidly modify the Order details according to a simple set of market conditions.

The Market Conditions that we monitor are:

1.       Recent Market Spreads: as measured by average prevailing spreads once per second during the last x seconds.

2.       Recent Market Volatility: as measured by the absolute recent distance travelled by the Market mid during the last y seconds.

3.       Recent Market Move: as measured by the net distance travelled in the last z seconds, either in the direction of the Order being attempted or against the Order

Finally there is a simple function which combines these measures to determine exactly where we should place the Limit orders and when we should use a Market order. In general we would prefer to use Limit orders since they should provide cheaper execution costs, but we are happy to use a Market order if the market has started to move a long way in one direction.

Explanation

There are 10 elements to the Random Strategy, labelled as such in the MT4 code:

Element 1: Computes a couple of elements of live on tick data.

Very simple.

Element 2: Computes Order accounting and logging ... what orders do we have open at the moment?

We need to know whether we have any open orders at the moment, since if we have a signal, it will determine our next actions. Also, if there has been a live Order recently closed, it gives us an opportunity to log the details of the last trade. In addition, this code determines whether the order is still ‘In-bounds’ for a Limit style or should be sent to the market as a Market order.

Element 3: Check for Orders to Close; this is only triggered in the non-standard situation since normally orders close by TP/SL which are modifying all the time.

Since this signal is very simple it only allows for a single order to be open, in a particular symbol, at any one time. If for any reason this is not true, we just exit all orders and start again from zero. So this is a safety step.

Element 4: Modifying or closing expired Working Orders.

This segment of code is always working with Working, market orders that are live in the market. In the current, very simple strategy, we simply let the orders sit in the market for a period. Then after a while, say 30 seconds, they Expire. At this point, if they are within a certain distance of the market at expiry, we add a limit order and constantly modify to try to exit with a limit strategy. However, if they move ‘out-of-bounds’, we hit the market with a Market order.

Element 5: Random Trading Signal: Generates the random Buy or Sell signal at a consistent time interval

On each tick we first check whether there is a Signal already live. If there is no live signal, we trigger a short routine to ‘toss a coin’ and generate a +1 or 0 outcome, dependant upon whether MathRand() gives an odd or even outcome.

Within the routine we also monitor the nextSignalCalcTime, which is the trigger to hunt for a new random outcome.  Finally we also report the current state of the signal, with reference to the live order information. Hence a signal is “IN_PENDING”, “IN_WORKING” or “OUT_PENDING”.

Element 6: Computes the Number of Lots that we want to place in this Order

Simply finds the Lot size from the Input menu and ensures that we have enough margin in place.

Element 7: Opening  orders, if we have a Signal but no Order out there yet

If there is a Signal available, but no Trade, this element creates the Order details for a new limit order trade. It uses the function “makeReplacementRates” to calculate the point where we would like to place the order.

Element 8: Modifying  orders , if we already have a Pending Order out there

Having first placed the order we are likely to Modify it very slightly on almost every new incoming tick while it is IN_BOUNDS, that is within the limit of the initial starting state. This is done with the “makeReplacementRates” function and is crucial to the use of pending limit orders.  If the order moves out-of-bounds, we will exit it through a Market Order.

Element 9: Finds details of the most recent closed order...

This is just a tiny function to provide last Trade details for reporting.

Element 10: Variable update

Records the values of some variables to the global environment.

Element 11: Reports a few details as comments to the screen

This is just a tiny element for reporting.

Element 12: Make the market environment assessment, Volatility (mileage) and Spread Liquidity.

This is an On.Timer function that runs in the background to make our ongoing assessment of the volatility and spread environment. It updates two global variables, namely spreadAvg and mileage. This is just a call to the makeReplaceRates function described in element 14.

Element 13: Function which finds the mileage and average spread values, using arrays  

We populate various arrays at 1 sec intervals to build up a recent picture of the market environment. In particular these arrays cover the recent spreads and the movements in market mid. We then average and sum these vectors respectively to get our estimates of avgSpread and mileage.

Element 14: Function which Creates the updating replace rates

This function is called at each tick by other elements within the OnTick function. It first collects the current market environment from the On.Timer function. These inputs are the avgSpread, mileage and the recent market move. Having sourced these inputs it combines them in a simple x order function to compute the ‘correct’ level to replace the next bid and ask in the market. This function is currently immensely simple but will nevertheless serve to set-up systems to demonstrate our ability to make and take orders over a FIX connection.

Element 15: Finds details of the most recent closed order...