Forex 80-20 strategy

80-20 trading strategy.

Introduction.

'80-20' is a name of one of the trading strategies (TS) described in the book Street Smarts: High Probability Short-Term Trading Strategies by Linda Raschke and Laurence Connors. Similar to the strategies discussed in my previous article, the authors attribute it to the stage when the price tests the range borders. It is also focused on profiting from false breakouts and roll-backs from the borders. But this time, we analyze the price movement on a significantly shorter history interval involving the previous day only. The lifetime of an obtained signal is also relatively short, since the system is meant for intraday trading.

The first objective of the article is to describe the development of the '80-20' trading strategy signal module using MQL5 language. Then, we are going to connect this module to the slightly edited version of the basic trading robot developed in the previous article of the series. Besides, we are going to use the very same module for the development of an indicator for manual trading.

As already said, the code provided in the article series is aimed mainly at slightly advanced novice programmers. Therefore, besides its main objective, the code is designed to help move from the procedural programming to the object-oriented one. The code will not feature classes. Instead, it will fully implement structures that are easier to master.

Yet another objective of the article is to develop tools allowing us to check if the strategy is still viable today, since Raschke and Connors used the market behavior at the end of the last century when creating it. A few EA tests based on the up-to-date history data are presented at the end of the article.

'80-20' trading system.

The authors name George Taylor's The Taylor Trading Technique, as well as Steve Moore's works on the computer analysis of futures markets and Derek Gipson's trading experience as theoretical basis for their own work. The essence of the trading strategy can be briefly described as follows: if the previous day's Open and Close prices are located at the opposite daily range areas, then the probability of a reversal towards the previous day's opening is very high today. The previous day's Open and Close prices should locate close to the range borders. The reversal should start the current day (not before the previous day's candle is closed). The strategy rules for buying are as follows:

1. Make sure that the market opened in the upper 20% and closed in the lower 20% of the daily range yesterday.

2. Wait till today's Low breaks the previous day's one at least by 5 ticks.

3. Place a buy pending order on the lower border of the yesterday's range.

4. Once the pending order triggers, set its initial StopLoss at the day's Low.

5. Use trailing stop to protect the obtained profit.

Sell entry rules are similar, but the yesterday's bar should be bullish, a buy order should be located at the upper border of the bar, while StopLoss should be placed at the today's High.

Yet another important detail is a size of a closed daily bar. According to Linda Raschke, it should be large enough - more than the average size of daily bars. However, she does not specify how many history days should be taken into consideration when calculating the average daily range.

We should also keep in mind that the TS is designed exclusively for intraday trading — examples shown in the book use M15 charts.

The signal block and the indicator making a layout according to the strategy are described below. You can also see a few screenshots with the indicator operation results. They clearly illustrate patterns corresponding to the system rules and trading levels linked to the patterns.

The pattern analysis should result in placing a buy pending order. Appropriate trading levels are better seen on M1 timeframe:

A similar pattern with the opposite trading direction on M5 timeframe:

Its trading levels (M1 timeframe):

Signal module.

Let's add Take Profit level calculation to illustrate adding new options to a custom TS. There is no such a level in the original version as only a trailing stop is used to close a position. Let's make Take Profit dependent on the custom minimum breakout level ( TS_8020_Extremum_Break ) — we will multiply it by the TS_8020_Take_Profit_Ratio custom ratio.

We will need the following elements of the fe_Get_Entry_Signal signal module's main function: current signal status, calculated entry and exit levels (Stop Loss and Take Profit), as well as yesterday's range borders. All levels are received via links to the variables passed to the function, while the signal's return status uses the list of options from the previous article:

ENTRY_BUY, // buy signal.

ENTRY_SELL, // sell signal.

ENTRY_NONE, // no signal.

ENTRY_UNKNOWN // status not defined.

datetime t_Time, // current time.

double & d_Entry_Level, // entry level (link to the variable)

double & d_SL, // StopLoss level (link to the variable)

double & d_TP, // TakeProfit level (link to the variable)

double & d_Range_High, // High of the pattern's 1 st bar (link to the variable)

double & d_Range_Low // Low of the pattern's 1 st bar (link to the variable)

In order to detect a signal, we need to analyze the last two bars of D1 timeframe. Let's start from the first one — if it does not meet the TS criteria, there is no need to check the second bar. There are two criteria:

1. The bar size (difference between High and Low) should exceed the average value for the last XX days (set by the TS_8020_D1_Average_Period custom setting)

2. Bar Open and Close levels should be located at the opposite 20% of the bar range.

If these conditions are met, High and Low prices should be saved for further use. Since the first bar parameters do not change within the entire day, there is no point in checking them at each function call. Let's store them in static variables:

input uint TS_8020_D1_Average_Period = 20 ; // 80-20: Number of days for calculating the average daily range.

input uint TS_8020_Extremum_Break = 50 ; // 80-20: Minimum breakout of the yesterday's extremum (in points)

static ENUM_ENTRY_SIGNAL se_Possible_Signal = ENTRY_UNKNOWN; // pattern's first bar signal direction.

// variables for storing calculated levels between ticks.

sd_SL = 0 , sd_TP = 0 ,

sd_Range_High = 0 , sd_Range_Low = 0.

// check the pattern's first bar on D1:

if (se_Possible_Signal == ENTRY_UNKNOWN)

st_Last_D1_Bar = t_Curr_D1_Bar; // 1 st bar does not change this day.

double d_Average_Bar_Range = fd_Average_Bar_Range(TS_8020_D1_Average_Period, PERIOD_D1 , t_Time);

// 1 st bar is not large enough.

se_Possible_Signal = ENTRY_NONE; // means no signal today.

ma_Rates[ 0 ].open > ma_Rates[ 0 ].high — d_20_Percents // bar opened in the upper 20%

ma_Rates[ 0 ].close < ma_Rates[ 0 ].low + d_20_Percents // and closed in the lower 20%

ma_Rates[ 0 ].close > ma_Rates[ 0 ].high — d_20_Percents // bar closed in the upper 20%

ma_Rates[ 0 ].open < ma_Rates[ 0 ].low + d_20_Percents // and opened in the lower 20%

// 1 st bar corresponds to the conditions.

// define today's trading direction for the pattern's 1 st bar:

se_Possible_Signal = ma_Rates[ 0 ].open > ma_Rates[ 0 ].close ? ENTRY_BUY : ENTRY_SELL;

// market entry level:

sd_Entry_Level = d_Entry_Level = se_Possible_Signal == ENTRY_BUY ? ma_Rates[ 0 ].low : ma_Rates[ 0 ].high;

// pattern's 1 st bar range borders:

sd_Range_High = d_Range_High = ma_Rates[ 0 ].high;

sd_Range_Low = d_Range_Low = ma_Rates[ 0 ].low;

// 1 st bar open/close levels do not match conditions.

se_Possible_Signal = ENTRY_NONE; // means no signal today.

Listing of the function for defining the average bar range within the specified number of bars on the specified timeframe beginning from the specified time function:

int i_Bars_Limit, // how many bars to consider.

ENUM_TIMEFRAMES e_TF = PERIOD_CURRENT , // bars timeframe.

datetime t_Time = WRONG_VALUE // when to start calculation.

double d_Average_Range = 0 ; // variable for summing values.

if (i_Bars_Limit < 1 ) return (d_Average_Range);

if (t_Time == WRONG_VALUE ) t_Time = TimeCurrent ();

int i_Price_Bars = CopyRates ( _Symbol , e_TF, t_Time, i_Bars_Limit, ma_Rates);

if (Log_Level > LOG_LEVEL_NONE) PrintFormat ( "%s: CopyRates: error #%u" , __FUNCTION__ , _LastError );

if (Log_Level > LOG_LEVEL_NONE) PrintFormat ( "%s: CopyRates: copied %u bars of %u" , __FUNCTION__ , i_Price_Bars, i_Bars_Limit);

int i_Bar = i_Price_Bars;

d_Average_Range += ma_Rates[i_Bar].high — ma_Rates[i_Bar].low;

return (d_Average_Range / double (i_Price_Bars));

There is only one criterion for the pattern's second (current) bar — breakout of the yesterday's range border should not be less than the one specified in the settings ( TS_8020_Extremum_Break ). As soon as the level is reached, a signal for placing a pending order appears:

if (se_Possible_Signal == ENTRY_BUY)

sd_SL = d_SL = ma_Rates[ 1 ].low; // StopLoss — to the today's High.

if (TS_8020_Take_Profit_Ratio > 0 ) sd_TP = d_TP = d_Entry_Level + _Point * TS_8020_Extremum_Break * TS_8020_Take_Profit_Ratio; // TakeProfit.

// is the downward breakout clearly seen?

ma_Rates[ 1 ].close < ma_Rates[ 0 ].low — _Point * TS_8020_Extremum_Break ?

sd_SL = d_SL = ma_Rates[ 1 ].high; // StopLoss — to the today's Low.

if (TS_8020_Take_Profit_Ratio > 0 ) sd_TP = d_TP = d_Entry_Level — _Point * TS_8020_Extremum_Break * TS_8020_Take_Profit_Ratio; // TakeProfit.

// is the upward breakout clearly seen?

ma_Rates[ 1 ].close > ma_Rates[ 0 ].high + _Point * TS_8020_Extremum_Break ?

Save the two functions mentioned above ( fe_Get_Entry_Signal and fd_Average_Bar_Range ) and the custom settings related to receiving a signal to the mqh library file. The full listing is attached below. Let's name the file Signal_80-20.mqh and place it to the appropriate directory of the terminal data folder (MQL5\Include\Expert\Signal).

Indicator for manual trading.

Just like the EA, the indicator is to use the signal module described above. The indicator should inform a trader on receiving a pending order placement signal and provide the calculated levels — order placement, Take Profit and Stop Loss levels. A user can select a notification method — a standard pop-up window, alert or push notification. It is possible to choose all at once or any combination you like.

Another indicator objective is a trading history layout according to '80-20' TS. The indicator is to highlight daily bars corresponding to the system criteria and plot calculated trading levels. The level lines display how the situation evolved over time. For more clarity, let's do as follows: when the price touches the signal line, the latter is replaced with a pending order line. When the pending order is activated, its line is replaced with Take Profit and Stop Loss lines. These lines are interrupted when the price touches one of them (the order is closed). This layout makes it easier to evaluate the efficiency of the trading system rules and define what can be improved.

Let's start with declaring the buffers and their display parameters. First, we need to declare the two buffers with the vertical area filling (DRAW_FILLING). The first one is to highlight the full daily bar range of the previous day, while another one is to highlight the inner area only to separate it from the upper and lower 20% of the range used in TS. After that, declare the two buffers for the multi-colored signal line and the pending order line (DRAW_COLOR_LINE). Their color depends on the trading direction. There are other two lines (Take Proft and Stop Loss) with their color remaining the same (DRAW_LINE) — they are to use the same standard colors assigned to them in the terminal. All selected display types, except for a simple line, require two buffers each, therefore the code looks as follows:

#property indicator_buffers 10.

#property indicator_plots 6.

#property indicator_type1 DRAW_FILLING.

#property indicator_color1 clrDeepPink , clrDodgerBlue.

#property indicator_width1 1.

#property indicator_type2 DRAW_FILLING.

#property indicator_color2 clrDeepPink , clrDodgerBlue.

#property indicator_width2 1.

#property indicator_type3 DRAW_COLOR_LINE.

#property indicator_style3 STYLE_SOLID.

#property indicator_color3 clrDeepPink , clrDodgerBlue.

#property indicator_width3 2.

#property indicator_type4 DRAW_COLOR_LINE.

#property indicator_style4 STYLE_DASHDOT.

#property indicator_color4 clrDeepPink , clrDodgerBlue.

#property indicator_width4 2.

#property indicator_type5 DRAW_LINE.

#property indicator_style5 STYLE_DASHDOTDOT.

#property indicator_color5 clrCrimson.

#property indicator_width5 1.

#property indicator_type6 DRAW_LINE.

#property indicator_style6 STYLE_DASHDOTDOT.

#property indicator_color6 clrLime.

#property indicator_width6 1.

Let's provide traders with the ability to disable the filling of the daily pattern's first bar, select signal notification options and limit the history layout depth. All trading system settings from the signal module are also included here. To do this, we need to preliminarily enumerate the variables used in the module even if some of them are to be used only in the EA and are of no need in the indicator:

input bool Show_Inner = true ; // 1 st bar of the pattern: Show the inner area?

input bool Alert_Popup = true ; // Alert: Show a pop-up window?

input bool Alert_ = false ; // Alert: Send an ?

input string Alert__Subj = "" ; // Alert: subject.

input bool Alert_Push = true ; // Alert: Send a push notification?

buff_1st_Bar_Outer[], buff_1st_Bar_Outer_Zero[], // buffers for plotting the full range of the pattern's 1 st bar.

buff_1st_Bar_Inner[], buff_1st_Bar_Inner_Zero[], // buffers for plotting the internal 60% of the pattern's 1 st bar.

buff_Signal[], buff_Signal_Color[], // signal line buffers.

buff_Entry[], buff_Entry_Color[], // pending order line buffers.

buff_SL[], buff_TP[], // StopLoss and TakeProfit lines' buffers.

gd_Extremum_Break = 0 // TS_8020_Extremum_Break in symbol prices.

gi_D1_Average_Period = 1 , // correct value for TS_8020_D1_Average_Period.

gi_Min_Bars = WRONG_VALUE // minimum required number of bars for re-calculation.

// check the entered TS_8020_D1_Average_Period parameter:

gi_D1_Average_Period = int ( fmin ( 1 , TS_8020_D1_Average_Period));

// converting points to symbol prices:

gd_Extremum_Break = TS_8020_Extremum_Break * _Point ;

// minimum required number of bars for re-calculation = number of bars of the current TF within a day.

gi_Min_Bars = int ( 86400 / PeriodSeconds ());

SetIndexBuffer ( 0 , buff_1st_Bar_Outer, INDICATOR_DATA );

PlotIndexSetDouble ( 0 , PLOT_EMPTY_VALUE , 0 );

SetIndexBuffer ( 1 , buff_1st_Bar_Outer_Zero, INDICATOR_DATA );

SetIndexBuffer ( 2 , buff_1st_Bar_Inner, INDICATOR_DATA );

PlotIndexSetDouble ( 1 , PLOT_EMPTY_VALUE , 0 );

SetIndexBuffer ( 3 , buff_1st_Bar_Inner_Zero, INDICATOR_DATA );

SetIndexBuffer ( 4 , buff_Signal, INDICATOR_DATA );

PlotIndexSetDouble ( 2 , PLOT_EMPTY_VALUE , 0 );

SetIndexBuffer ( 5 , buff_Signal_Color, INDICATOR_COLOR_INDEX );

SetIndexBuffer ( 6 , buff_Entry, INDICATOR_DATA );

PlotIndexSetDouble ( 3 , PLOT_EMPTY_VALUE , 0 );

SetIndexBuffer ( 7 , buff_Entry_Color, INDICATOR_COLOR_INDEX );

SetIndexBuffer ( 8 , buff_SL, INDICATOR_DATA );

PlotIndexSetDouble ( 4 , PLOT_EMPTY_VALUE , 0 );

SetIndexBuffer ( 9 , buff_TP, INDICATOR_DATA );

PlotIndexSetDouble ( 5 , PLOT_EMPTY_VALUE , 0 );

IndicatorSetString ( INDICATOR_SHORTNAME , "80-20 TS" );

Place the main program's code to the built-in OnCalculate function — arrange the loop for iterating over the current timeframe's bars from the past to the future searching them for a signal using the function from the signal module. Declare and initialize the necessary variables using initial values. Let's define the oldest loop bar for the first calculation considering a user-defined history depth limit ( Bars_Limit ). For subsequent calls, all bars of the current day (rather than the last bar) are re-calculated, since the two-bar pattern actually belongs to D1 chart regardless of the current timeframe.

Besides, we should protect against the so-called phantoms: if we do not perform a forced indicator buffers clearing during re-initialization, then no longer relevant filled areas remain on the screen when switching timeframes or symbols. The buffer clearing should be bound to the first OnCalculate function call after the indicator initialization. However, the standard prev_calculated variable is not enough for defining if the call is the first one, since it may contain zero not only during the first function call but also "when changing the checksum". Let's spend some time to properly solve this issue by creating the structure not affected by setting the prev_calculated variable to zero. The structure is to store and process data frequently used in the indicators:

- flag of the OnCalculate function first launch;

- the counter of calculated bars that is not set to zero when changing the checksum;

- flag of changing the checksum;

- flag of the beginning of a new bar;

- current bar start time.

The structure combining all these data is to be declared at the global level. It should be able to gather or present data from/to any built-in or custom functions. Let's name this structure Brownie. It can be placed to the end of the indicator code. A single global type structure object named go_Brownie is to be declared there as well:

datetime t_Last_Bar_Time; // time of the last processed bar.

int i_Prew_Calculated; // number of calculated bars.

bool b_First_Run; // first launch flag.

bool b_History_Updated; // history update flag.

bool b_Is_New_Bar; // new bar opening flag.

b_First_Run = b_Is_New_Bar = true ;

if (b_Reset_First_Run) b_First_Run = true ; // set to zero if there is permission.

// flag of the OnCalculate built-in function first call.

if (b_First_Run && i_Prew_Calculated > 0 ) b_First_Run = false ;

datetime t_This_Bar_Time = TimeCurrent () - TimeCurrent () % PeriodSeconds ();

b_Is_New_Bar = t_Last_Bar_Time == t_This_Bar_Time;

if (b_Is_New_Bar) t_Last_Bar_Time = t_This_Bar_Time;

// are there any changes in history?

b_History_Updated = i_New_Prew_Calculated == 0 && i_Prew_Calculated > WRONG_VALUE ;

if (i_Prew_Calculated == WRONG_VALUE ) i_Prew_Calculated = i_New_Prew_Calculated;

// or if there was no history update.

else if (i_New_Prew_Calculated > 0 ) i_Prew_Calculated = i_New_Prew_Calculated;

Let's inform the Brownie of the indicator de-initialization event:

go_Brownie. f_Reset(); // inform Brownie.

If necessary, the amount of data stored by the Brownie can be expanded if custom functions or classes need prices, volumes or the current bar's spread value (Open, High, Low, Close, tick_volume, volume, spread). It is more convenient to use ready-made data from the OnCalculate function and pass them via Brownie rather than using the time series copying functions (CopyOpen, CopyHigh etc. or CopyRates) — this saves the CPU resources and eliminates the necessity to arrange processing of errors of these language functions.

Let's get back to the main indicator function. Declaring variables and preparing the arrays using the go_Brownie structure look as follows:

i_Period_Bar = 0 , // auxiliary counter.

i_Current_TF_Bar = rates_total - int (Bars_Limit) // bar index of the current TF loop start.

static datetime st_Last_D1_Bar = 0 ; // time of the last processed bar of the couple of D1 bars (pattern's 2 nd bar)

static int si_1st_Bar_of_Day = 0 ; // index of the current day's first bar.

// clear the buffers during re-initialization:

ArrayInitialize (buff_1st_Bar_Inner, 0 ); ArrayInitialize (buff_1st_Bar_Inner_Zero, 0 );

ArrayInitialize (buff_1st_Bar_Outer, 0 ); ArrayInitialize (buff_1st_Bar_Outer_Zero, 0 );

ArrayInitialize (buff_Entry, 0 ); ArrayInitialize (buff_Entry_Color, 0 );

ArrayInitialize (buff_Signal, 0 ); ArrayInitialize (buff_Signal_Color, 0 );

ArrayInitialize (buff_TP, 0 );

ArrayInitialize (buff_SL, 0 );

datetime t_Time = TimeCurrent ();

// minimum re-calculation depth - from the previous day:

i_Current_TF_Bar = rates_total - Bars ( _Symbol , PERIOD_CURRENT , t_Time - t_Time % 86400 , t_Time) - 1 ;

ENUM_ENTRY_SIGNAL e_Signal = ENTRY_UNKNOWN; // signal.

d_SL = WRONG_VALUE , // SL level.

d_TP = WRONG_VALUE , // TP level.

d_Entry_Level = WRONG_VALUE , // entry level.

d_Range_High = WRONG_VALUE , d_Range_Low = WRONG_VALUE // borders of the pattern's 1 st bar range.

t_Curr_D1_Bar = 0 , // current D1 bar time (pattern's 2 nd bar)

t_D1_Bar_To_Fill = 0 // D1 bar time to be filled (pattern's 1 st bar)

i_Current_TF_Bar = int ( fmax ( 0 , fmin (i_Current_TF_Bar, rates_total - gi_Min_Bars)));

// the main program loop is to be located here.

Check the presence of a signal when iterating over the current timeframe bars:

if (e_Signal > 1 ) continue ; // no signal during the day the bar belongs to.

If there is a signal on a new day's first bar, the range of the previous daily bar should be filled. The value of the t_D1_Bar_To_Fill variable of datetime type is used as a flag. If it is equal to WRONG_VALUE, no filling is required on this bar. The signal line should start at the same first bar, but let's extend it to the last bar of the previous day for better layout perception. Since the calculations of a signal line, as well as line and filling colors for bullish and bearish bars are different, let's make two similar blocks:

t_D1_Bar_To_Fill = Time [i_Current_TF_Bar — 1 ] — Time [i_Current_TF_Bar — 1 ] % 86400 ;

else t_D1_Bar_To_Fill = WRONG_VALUE ; // previous day bar, no new filling required.

st_Last_D1_Bar = t_Curr_D1_Bar; // remember.

// Filling the previous day's D1 bar:

if (Show_Outer) while (--i_Period_Bar > 0 )

if ( Time [i_Period_Bar] < t_D1_Bar_To_Fill) break ;

while (--i_Period_Bar > 0 )

if ( Time [i_Period_Bar] < t_D1_Bar_To_Fill) break ;

buff_1st_Bar_Inner_Zero[i_Period_Bar] = d_Range_Low + 0.2 * (d_Range_High — d_Range_Low);

buff_1st_Bar_Inner[i_Period_Bar] = d_Range_High — 0.2 * (d_Range_High — d_Range_Low);

// start of the signal line — from the previous day's last bar.

buff_Signal[i_Current_TF_Bar] = buff_Signal[i_Current_TF_Bar — 1 ] = d_Range_Low — gd_Extremum_Break;

buff_Signal_Color[i_Current_TF_Bar] = buff_Signal_Color[i_Current_TF_Bar — 1 ] = 0 ;

if (Show_Outer) while (--i_Period_Bar > 0 )

if ( Time [i_Period_Bar] < t_D1_Bar_To_Fill) break ;

while (--i_Period_Bar > 0 )

if ( Time [i_Period_Bar] < t_D1_Bar_To_Fill) break ;

buff_1st_Bar_Inner_Zero[i_Period_Bar] = d_Range_High — 0.2 * (d_Range_High — d_Range_Low);

buff_1st_Bar_Inner[i_Period_Bar] = d_Range_Low + 0.2 * (d_Range_High — d_Range_Low);

// start of the signal line — from the previous day's last bar.

buff_Signal[i_Current_TF_Bar] = buff_Signal[i_Current_TF_Bar — 1 ] = d_Range_High + gd_Extremum_Break;

buff_Signal_Color[i_Current_TF_Bar] = buff_Signal_Color[i_Current_TF_Bar — 1 ] = 1 ;

All the remaining layout lines are to be plotted inside the current timeframe's bars iteration loop. As already mentioned, the signal line should end at the bar where the price touched it. The pending order line should start at the same bar and end on the bar, at which the contact with the price occurs. Take Profit and Stop Loss lines should start at the same bar. The layout of the pattern is finished at the bar, at which the price touches one of them:

while (++i_Period_Bar < rates_total)

if ( Time [i_Period_Bar] > t_Curr_D1_Bar + 86399 ) break ;

buff_Signal[i_Period_Bar] = d_Range_Low — gd_Extremum_Break;

if (d_Range_Low — gd_Extremum_Break >= Low [i_Period_Bar]) break ;

while (++i_Period_Bar < rates_total)

if ( Time [i_Period_Bar] > t_Curr_D1_Bar + 86399 ) break ;

buff_Signal[i_Period_Bar] = d_Range_High + gd_Extremum_Break;

if (d_Range_High + gd_Extremum_Break <= High [i_Period_Bar]) break ;

while (++i_Period_Bar < rates_total)

if ( Time [i_Period_Bar] > t_Curr_D1_Bar + 86399 ) break ;

if (d_Range_Low <= High [i_Period_Bar])

if (buff_Entry[i_Period_Bar — 1 ] == 0 .)

// start and end on a single bar, extend by 1 bar to the past.

buff_Entry[i_Period_Bar — 1 ] = d_Range_Low;

buff_Entry_Color[i_Period_Bar — 1 ] = 0 ;

while (++i_Period_Bar < rates_total)

if ( Time [i_Period_Bar] > t_Curr_D1_Bar + 86399 ) break ;

if (d_Range_High >= Low [i_Period_Bar])

if (buff_Entry[i_Period_Bar — 1 ] == 0 .)

// start and end on a single bar, extend by 1 bar to the past.

buff_Entry[i_Period_Bar — 1 ] = d_Range_High;

buff_Entry_Color[i_Period_Bar — 1 ] = 1 ;

// SL is equal to the Low since the beginning of a day:

d_SL = Low [ ArrayMinimum ( Low , si_1st_Bar_of_Day, i_Period_Bar — si_1st_Bar_of_Day)];

if ( Time [i_Period_Bar] > t_Curr_D1_Bar + 86399 ) break ;

if (d_TP <= High [i_Period_Bar] || d_SL >= Low [i_Period_Bar])

if (buff_SL[i_Period_Bar — 1 ] == 0 .)

// start and end on a single bar, extend by 1 bar to the past.

buff_SL[i_Period_Bar — 1 ] = d_SL;

buff_TP[i_Period_Bar — 1 ] = d_TP;

// SL is equal to the High since the beginning of a day:

d_SL = High [ ArrayMaximum ( High , si_1st_Bar_of_Day, i_Period_Bar — si_1st_Bar_of_Day)];

if ( Time [i_Period_Bar] > t_Curr_D1_Bar + 86399 ) break ;

if (d_SL <= High [i_Period_Bar] || d_TP >= Low [i_Period_Bar])

if (buff_SL[i_Period_Bar — 1 ] == 0 .)

// start and end on a single bar, extend by 1 bar to the past.

buff_SL[i_Period_Bar — 1 ] = d_SL;

buff_TP[i_Period_Bar — 1 ] = d_TP;

Let's place the call code of the f_Do_Alert signal notification function out of the loop. In fact, it has slightly wider opportunities as compared to the ones involved in this indicator — the function is able to work with audio files meaning that this option can be added to custom settings. The same is true for the ability to select separate files for buy and sell signals. Function listing:

string s_Message, // alert message.

bool b_Alert = true , // show a pop-up window?

bool b_Sound = false , // play a sound file?

bool b_ = false , // send an ?

bool b_Notification = false , // send a push notification?

string s__Subject = "" , // subject.

string s_Sound = "alert. wav" // sound file.

static string ss_Prev_Message = "there was silence" ; // previous alert message.

static datetime st_Prev_Time; // previous alert bar time.

datetime t_This_Bar_Time = TimeCurrent () — PeriodSeconds () % PeriodSeconds (); // current bar time.

// another and/or 1 st at this bar.

s_Message = StringFormat ( "%s | %s | %s | %s" ,

TimeToString ( TimeLocal (), TIME_SECONDS ), // local time.

StringSubstr ( EnumToString ( ENUM_TIMEFRAMES ( _Period )), 7 ), // TF.

if (b_Alert) Alert (s_Message);

if (b_) SendMail (s__Subject + " " + _Symbol , s_Message);

if (b_Notification) SendNotification (s_Message);

if (b_Sound) PlaySound (s_Sound);

The code for checking the need for calling the function and forming the text for it located in the program body before completion of the OnCalculate event handler:

i_Period_Bar = rates_total — 1 ; // current bar.

if (buff_Signal[i_Period_Bar] == 0 ) return (rates_total); // nothing to catch yet (or already)

buff_Signal[i_Period_Bar] > High [i_Period_Bar]

buff_Signal[i_Period_Bar] < Low [i_Period_Bar]

) return (rates_total); // no signal line touching.

string s_Message = StringFormat ( "TS 80-20: needed %s %s, TP: %s, SL: %s" ,

buff_Signal_Color[i_Period_Bar] > 0 ? "BuyStop" : "SellStop" ,

DoubleToString (d_Entry_Level, _Digits ),

DoubleToString (d_TP, _Digits ),

DoubleToString (d_SL, _Digits )

f_Do_Alert(s_Message, Alert_Popup, false , Alert_, Alert_Push, Alert__Subj);

The entire source code of the indicator can be found in the attached files (TS_80-20.mq5). The trading layout according to the system is best seen on minute charts.

Please note that the indicator uses the bar data rather than tick sequences inside bars. This means if the price crossed several layout lines (for example, Take Profit and Stop Loss lines) on a single bar, you cannot always define which of them was crossed first. Another uncertainty stems from the fact that the start and end lines cannot coincide. Otherwise, the lines from the buffer of DRAW_LINE and DRAW_COLOR_LINE types will simply be invisible to a user. These features reduce the layout accuracy but it still remains quite clear.

Expert Advisor for testing the '80-20' trading strategy.

The basic EA for testing strategies from the book Street Smarts: High Probability Short-Term Trading Strategies was described in details in the first article. Let's insert two significant changes in it. First, the signal module is to be used in the indicator as well meaning it would be reasonable to set trading levels calculation in it. We have already done this above. Apart from the signal status, the fe_Get_Entry_Signal function returns order placement, Stop Loss and Take Profit levels. Therefore, let's remove the appropriate part of the code from the previous EA version adding the variables for accepting levels from the function and edit the function call itself. The listings of the old and new code blocks can be found in the attached file (strings 128-141).

Another significant addition to the basic EA code is due to the fact that, unlike the previous two, this TS deals with a short-term trend. It assumes that the roll-back happens once a day and is unlikely to be repeated. This means that the robot has to make only one entry ignoring the existing signal all the rest of the time until the next day. The easiest way to implement that is to use a special flag — static or global variable of bool type in the program memory. But if the EA operation is interrupted for some reason (the terminal is closed, the EA is removed from the chart, etc.), the flag value is lost as well. Thus, we should have the ability to check if today's signal was activated previously. To do this, we may analyze the history of trades for today or store the date of the last entry in the terminal global variables rather than in the program. Let us use the second option since it is much easier to implement.

Provide users with the ability to manage 'one entry per day' option and set an ID of each launched version of the robot — it is needed to use global variables of the terminal level:

input uint Magic_Number = 2016 ; // EA magic number.

Let's add the variables necessary to implement 'one entry per day' option to the program's global variables definition block. Initialize them in the OnInit function:

gs_Prefix // identifier of (super)global variables.

gs_Prefix = StringFormat ( "SSB %s %u %s" , _Symbol , Magic_Number, MQLInfoInteger ( MQL_TESTER ) ? "t " : "" );

gb_Position_Today = int ( GlobalVariableGet (gs_Prefix + "Last_Position_Date" )) == TimeCurrent () — TimeCurrent () % 86400 ;

gb_Pending_Today = int ( GlobalVariableGet (gs_Prefix + "Last_Pending_Date" )) == TimeCurrent () — TimeCurrent () % 86400 ;

Here the robot reads the values of global variables and compares the written time with the day start time, thus defining if the today's signal has already been processed. Time is written to the variables in two places — let's add the appropriate block to the pending order installation code (additions highlighted):

if (Log_Level > LOG_LEVEL_NONE) Print ( "Pending order placing error" );

// the distance from the current price is not enough :(

if (Log_Level > LOG_LEVEL_ERR)

PrintFormat ( "Pending order cannot be placed at the %s level. Bid: %s Ask: %s StopLevel: %s" ,

DoubleToString (d_Entry_Level, _Digits ),

DoubleToString (go_Tick. bid, _Digits ),

DoubleToString (go_Tick. ask, _Digits ),

DoubleToString (gd_Stop_Level, _Digits )

// to update the flag:

GlobalVariableSet ( // in the terminal global variables.

TimeCurrent () — TimeCurrent () % 86400.

gb_Pending_Today = true ; // in the program global variables.

The second block is placed after the code defining a newly opened position:

if ( PositionGetDouble ( POSITION_SL ) == 0 .)

// update the flag:

GlobalVariableSet ( // in the terminal global variables.

TimeCurrent () — TimeCurrent () % 86400.

gb_Position_Today = true ; // in the program global variables.

These are the only significant changes in the previous EA version code. The finalized source code of the new version is attached below.

Strategy backtesting.

In order to illustrate the trading system viability, its authors use patterns detected on the charts from the end of the last century. Therefore, we need to check its relevance in today's market conditions. For testing, I took the most popular Forex pair EURUSD, the most volatile pair USDJPY and one of the metals — XAUUSD. I increased the indents specified by Raschke and Connors 10 times, since four-digit quotes were used when the book was written, while I tested the EA on five-digit ones. Since there is no any guidance concerning the trailing parameters, I have selected the ones that seem to be most appropriate to daily timeframe and instrument volatility. The same applies to the Take Profit calculation algorithm added to the original rules — the ratio for its calculation was chosen arbitrarily, without deep optimization.

The balance chart when testing on the five-year EURUSD history with the original rules (no Take Profit):

The same settings and Take Profit:

The balance chart when testing the original rules on the five-year USDJPY history:

The same settings and Take Profit:

The balance chart when testing the original rules on the daily gold quotes for the last 4 years:

The full data on the robot settings used in each test can be found in the attached archive containing the complete reports.

Conclusion.

The rules programmed in the signal module match the 80-20 trading system description provided by Linda Raschke and Laurence Connors in their book "Street Smarts: High Probability Short-Term Trading Strategies". However, we have extended the original rules a bit. The tools (the robot and the indicator) are to help traders draw their own conclusions concerning the TS relevance in today's market. In my humble opinion, the TS needs a serious upgrade. In this article, I have tried to make some detailed comments on developing the code of the signal module, as well as the appropriate robot and indicator. I hope, this will help those who decide to do the upgrade. Apart from modifying the rules, it is also possible to find trading instruments that fit better to the system, as well as signal detection and tracking parameters.

Translated from Russian by MetaQuotes Software Corp.

FOREX Strategies Forex Strategy, Simple strategy, Forex Trading Strategy, Forex Scalping.

Forex Strategy 80-20.

Forex Strategy 80-20 — another very simple and quite an interesting strategy forex Linda Raschke (previously we looked at 2 of its strategy: Turtle Soup, Turtle Soup plus One), in which trade is conducted only on the daily range (D1) and trading signals are only During the 1 st trading day.

Investigating the patterns of financial markets, it was noted that if the price on the market closes at the top or bottom 10% -20% of its daily range, then there is a possibility and it is 80% -90%, the next morning, the price will continue to move in the same direction (ie towards the closing day candles), but eventually the price closes above or below this candle in only 50% of cases ! That’s a given fact (a chance to turn in the middle of the 2 nd day after the close of the 1 st day candles), and allowed 80-20 strategy exist and be popular in the financial markets.

So, let’s look at how deals are made in Forex Strategy 80-20 , an example of the transaction on the purchase .

Suppose we open a trading terminal MetaTrader 4 today and note that:

1) Yesterday’s daily candle was discovered in the upper 20% of its daily range and closed in the bottom 20% of its daily range. Ie If the daily candle divided into 5 parts, the opening price of yesterday’s daily candle is in the top 1 / 5 of a closed candle. And the closing price is at the bottom 1 / 5 of the closed day candles.

Figure 1. Dedicated bearish candle was discovered in 1 / 5 of the upper range and closed at 1 / 5 of its lower range.

2) Today’s daily candle opens and the price at the market went in the same direction as the close of the previous daily candle — ie for sale, presumably for at least 10-15 points.

3) At this moment, when the price is already below yesterday’s low and we have clearance to be placed pending order, we set the pending order to buy the type Buy Stop at yesterday’s low price!

Figure 2. This is the same candle as in Figure 1, only the hourly interval. Expose the pending order to buy at a time when the price of the 2 nd hour candle falls below yesterday’s low.

4) After the opening of trading positions in the purchase, we will establish a safety stop-loss orders below a few points (3-5) segodneshnego minimum.

5) Next, use a trailing stop (Universal trailing stop, the standard in Metatrader 4, or a trailing stop on the 1 st paragraph) to lock in profits and tightens our stop-loss at a safe distance that you define for themselves, depending on the the chosen currency pair and the volatility in the forex market.

For example, if the amount of daily candles 100-200 points, and trailing stop should be placed at a distance 50-70-100 points. Candle 50-70 points — tryling-stop: 25-30 points.

6) If you prefer, you can put a profit target at a distance of at least 3.2 times the initial stop-loss (as required by our Money Management Forex). Or record profits on the important Fibonacci levels , built by the first candle (38,2%, 61,8%)

7) Or you can simply rearrange the position of zero level, as soon as you see fit and leave the deal by the end of the trading day, and then look to close it or leave open. But I personally believe that it is better to use a trailing stop to lock in profits.

For transactions on sale — the rules of the opposite!

Figure 3. Vystalyaem pending order to sell Sell Stop, when the price broke yesterday makismum. Stop-loss is 10-15 points higher than this maximum, because price is not too moved away from him and turned around.

Note: The transactions in this strategy are not as common, but if you observe the laws of several currency pairs, the probability of the conditions and the entry into the market will garazdo above!

By this strategy, forex trading you can buy.

Note: if you want to receive updates Expert Advisor - LEAVE positive feedback in the store Plati. ru without specifying e-mail in the body of reviews! e-mail please indicate on the payment page — which indicates where the goods will be delivered!

Subject to strict adherence to rules of the forex strategy 80-20, we get approximately the following trading results ( test results Adviser 80-20 strategy ):

1) Test strategies forex 80-20 — EURUSD (D1) with Expert Advisor 80-20 strategy.

2) Test strategies forex 80-20 — EURJPY (D1) with Expert Advisor 80-20 strategy.

3) test strategies forex 80-20 — USDCAD (D1) with Expert Advisor 80-20 strategy.

If you liked this Forex strategy - You can subscribe to receive new materials on the site Strategy4forex by RSS or by e-mail:

Leave a Reply.

Write something about yourself. No need to be fancy, just an overview.

How The 80/20 Rule Applies To Forex Trading.

Have you ever noticed that most of the money in the world is held by a relatively small minority of people? Or, how about that most people tend to work in short spurts of intense productivity followed by larger periods where they are less productive? There’s an underlying principle that can be used to describe such occurrences, it’s known as the Pareto principle , or the ’80/20 Rule’.

Some of you might be familiar with the ‘80/20 Rule’, some of you might not be. For those of you who haven’t heard of it before or need a refresher, according to Wikipedia , “it is named after Italian economist Vilfredo Pareto, who observed in 1906 that 80% of the land in Italy was owned by 20% of the population; he developed the principle by observing that 20% of the pea pods in his garden contained 80% of the peas”

The 80/20 rule is popular in business studies, sales, economics and many other fields. However, today we are going to discuss how the 80/20 rule applies to trading and the significant positive impact the “80/20 mentality” can have on your trading performance.

How the 80/20 rule applies to your trading.

Quick note: These are my personal observations over my 10+ years in the market. The 80/20 rule is not an ‘exact’ science, but it does give you a very effective way to make sense of many aspects of trading and how they all fit together. Also, all ‘80/20’ ratios discussed below should be thought of as “approximate” ratios, meaning they could actually be 75/25 or 90/10, etc.

“By the numbers it means that 80 percent of your outcomes come from 20 percent of your inputs. As Pareto demonstrated with his research this “rule” holds true, in a very rough sense, to an 80/20 ratio, however in many cases the ratio can be a lot higher – 99/1 may be closer to reality.”

I wanted to start off with the above quote by Yaro Starak because in trading, the 80/20 rule is more like 90/10 or sometimes even 99/1 as he says.

How often have you heard “90% of traders fail while only about 10% make consistent money”? Often, I am willing to bet. Whilst the exact ratio of traders who make money vs. those who lose money is obviously almost impossible to pinpoint, it probably is somewhere between 80/20 and 95/5. Have you ever thought to yourself “why is trading apparently so difficult that 80 or 90% of people fail at it?” I’m willing to bet you have, and here is my answer to this pervasive question:

Trading is the ultimate “less is more” profession, but it’s also extremely difficult for most people to come to grips with this fact by accepting the following:

80% of trading should be simple and almost effortless, 20% is more difficult 80% of profits come from 20% of trades 80% of the time the market is not worth trading, 20% it is 80% of the time you should not be in a trade, 20% you can be 80% of trades should be on the daily chart time frame, 20% can be other time frames 80% of trading success is a direct result of trading psychology and money management, 20% is from strategy / system.

Let’s delve into each of the above points a little deeper and see how you can start applying them to your trading, and hopefully start improving it, significantly.

80% Simple, 20% Difficult.

This one is easy. Most of what we do as traders is sit in front of our computers and look at prices going up or down or sideways. This is not by anyone’s standards “hard” to do. Hell, you can put a 5 year old in front of a chart and ask them which direction they think it will go next and they will probably get it right more often than not. The point is this; determining market direction and finding trades is not hard, people make it hard.

I teach price action as you probably know (honestly, if you don’t know that by now you need to checkout this article right now: price action trading introduction), and it’s not simply some strange coincidence that I teach this particular form of trading, I also personally trade with price action…because it is simple (and effective). The trading strategy you use doesn’t need to involve complex computer algorithms, counting ‘waves’ or interpreting heaps of indicators. In fact, most traders get bogged down with trying every trading method under the sun until they either give up or figure out that they were simply over-complicating what should be a very simple process.

The difficult part of trading is controlling yourself via not over-trading, not risking too much per trade, not jumping back into the market on emotion after a big win or a loss, etc. In short, controlling your own behavior and mindset, as well as properly managing your money are the hardest parts of trading, and traders tend to spend less of their time & focus on these more difficult aspects of trading, probably about 20%, when they should be spending about 80% of their time on them.

80% of profits come from 20% of trades.

If you have followed my blog for a while, you know that I am strong proponent of “sniper trading” and waiting patiently for high-probability trade setups, rather than the high-frequency trading style that tends to put so many traders ‘out of business’, so to speak.

It’s absolutely true that most of my trading profits come from a small percentage of my trades. I like to keep all my losing trades contained below a certain 1R dollar value that I am comfortable with, and if I see what I consider an “obvious” price action signal with a lot of confluence behind it, I will go in strong and make a nice chunk of change on the trade if it goes in my favor. Because I trade with such patience and precision, the winning trades I have typically double or triple the 1R risk I gave up on any of my losers. This way, even if I lose more trades than I win, I can still make a very nice return at year’s end.

80% of the time I am not trading, 20% of the time I ‘might’ be.

I might trade 4 times per month on average, quite simply because I am a very picky trader. I don’t like to risk money on a setup that isn’t ‘screaming’ at me or what I like to say is “damn obvious”. Most traders like to trade a higher-frequency trading style, and it’s not a coincidence that somewhere around 80 to 90% of them lose money. They are losing money because they are trading way too much and not being patient or disciplined enough to wait for their strategy to really come together and give them a high-probability entry signal.

Do you see the connection between the fact that most traders lose money (around 80%) and about the same amount of time the market is really not worth trading? Markets chop around a lot, and a lot of the time the price action is simply meaningless. As a price action trader, our job is to analyze the price action and have the discipline to not trade during the choppy (meaningless) price action and wait for the 20% or so market conditions that are worth trading.

This point is the most important in this whole article: I get a lot of s from beginning and struggling traders and I know for a fact that the main thing that separates the professionals from the amateurs in this business is patience and not over-trading. Traders tend to negate their trading edge by trading during the 80% of the time when the market is not worth trading. Instead of waiting for the 20% of the time when it is worth trading, they simply trade 80% to 100% of the time with very little discretion or self-control, like a drunk guy at a casino. Don’t let this be you, remember the 80/20 rule ESPECIALLY as it pertains to trading vs. not trading. If you think you are trading about 80% of the time, you need to evaluate your trading habits and make it more in-line with trading only 20% of the time and 80% of the time should be spent observing and keeping your hands in your pockets (not trading).

80% daily chart trades, 20% other time frames.

The daily chart time frame is my “weapon of choice” as far as chart time frames are concerned. I would say it’s pretty accurate that just about 80% of my trades are taken on the daily chart time frame. I won’t get into all the reasons about why focusing on the daily charts is so much better than lower time frames, but you can click the link above to find out more.

However, I would like to point out that there is also a direct connection between the fact that most traders get caught up trading lower time frame charts and most of them lose money. This fits well with the 80/20 rule in that probably only about 20% of traders really focus on higher time frame charts like the daily chart and somewhere around 20% to 10% of traders actually make consistent money. People tend to be drawn to the “play by play” action on the lower time frame charts, almost like they are mesmerized by the moving numbers and flashing colors…unfortunately, this turns into somewhat of a trading addiction for many traders, that quickly destroys their trading accounts.

80% of trading success is psychology and money management, 20% is strategy.

In the article I wrote that detailed a case study of random entry and risk reward, I showed how it is possible to make money simply through the power of money management and risk reward. To be clear, I was not and am not saying that you can make a full-time living as a trader without an effective trading strategy. I am simply saying that money management and controlling your mindset is far more important than finding some “perfect, Holy-Grail” trading system that simply does not exist.

You should be focusing about 80% of your trading efforts on money management and controlling yourself / being disciplined (psychology), and about 20% on actually analyzing the charts and trading. If you do this consistently, I can guarantee you that you will see a very positive change in your trading profits, or lack thereof.

Using an effective trading method that is also easy to understand and implement will give you the mental clarity and time to focus 80% on money management and discipline whilst only needing about 20% of your mental energy for analyzing the markets and finding trades. A lot of traders never even get to this point because they are still trying to figure out how the heck to make sense of their trading system.

Where to go from here with the 80/20 rule…

If you look back over your trading account history from January 1 st until now, ask yourself how many of the trades you lost money on where actually valid occurrences of your trading strategy (edge) versus random gambling-type trades that you entered out of emotion or impulse. I’m willing to be that the ratio of emotional trading losses to losses that were the result of a normal statistical losing trade, is about 80/20…surprise, surprise.

The implication here is clearly that you can eliminate about 80% of your trading losses by avoiding emotional or impulsive trading . The first step to trading with an ‘80/20 mindset’ is to master a simple trading strategy like the price action strategies I teach in my trading courses. As I said earlier, if you do this it will give you the foundation you need to focus more of your time on the real “money makers” in trading, which are money management and your own mental state. Thus, the 80/20 rule in trading is best applied by combining a simple trading strategy and a strong focus on money management and psychology, the synergy of this combination is a very potent force for making money in the market.

About Nial Fuller.

The Minimalist Guide To Forex Trading & Life.

Low-Frequency Vs High-Frequency Forex Trading.

Profitable Traders Do Nothing 99% Of the Time.

Why Having A Trading Routine Is Vital To Your Success.

52 Comments Leave a Comment.

Really good article. Many thanks.

I read many books on trading. Honestly it goes over my head….

As like your trading strategy and training, your articles are a very simple and simple to follow .

Thanks again and all the time Mr Nial. God bless you.

Thax for sharing Mr. Fuller. Excellent insight from you. Success for you.

thanks sir for these great articles….you have completely changed my way of looking at the market..now I slowly but steadily following your system and seeing great improvement in my trading results….thank you once again….respect for you always……..))

Absolutely true. Since paying most attention on 1D and 4H charts I managed to improve my trading.

Wow. Amazing. I wish I had known all of this before I blew up my account. Thank you so much.

Thank you very much Nial. keep your good work up.

Like always, your articles are inspiring and helpful. Thank you.

Thank for your informative articles here. You will surely broaden our horizon in Fx Traing.

The lesson is very useful thank you.

Damn good obvious article !

Great job you are doing, In real it is virtue.. Allah Bless You…

Been interested in forex and this article will certainly be of help. Thanks!

Looking at 100% of your trades, don’t you have to go through the 80% to get to the 20% not matter how many or few trades you make?

Good day Mr Fuller. Keep up the ace information! I’m about to enter the Nigerian market. I also want to get into the FX market but I can’t get a hang of the demo platform you directed us to. I read Francesca Taylor’s Mastering Derivatives Markets and apparently algorithms are the big thing in FX trading. Do direct me accordingly so I build a healthy portfolio that includes FX on a recognized platform. I will be looking into buying your Price Action Course as soon as I set up in the FX market.

Nial sir, I analyzed my trades since 01st January. 80% of the trades were impulse/emotional trades and 20% of the trades matched with my edge. I am unknowing doing these mistakes.

Great article as I have been reading The 80/20 Principle by Edward Koch. As I read it I thought how I could apply it to my trading and then I came across this post. Great stuff.

hi Nail, yous articles really are helpful to my trading, thank you.

Thanks for explaining all this.

I really got so many things clear by reading this article.

Nice article Nial, very helpful for me.

One of the Great Article.

Dear Nial sir, For the past one year I am sticking with your webside and learned lot of things. One of my daily routine is “reading your lesson one per day”. Now, I am closely monitoring my habits. Thank you once again for the excellent article.

Very good article Nial! You have very good insight. I am inspired to get back into trading again.

Nial Mate, you always amaze me with the article’s you write. How do you find the time to write such great article’s. I’m glad I’m a part of your community.

your mate in Vancouver, Canada.

Once again a great article for developing solid trading habits…Thanks a lot..80% of what you write is perfect and 20% are exceptional…

Thanks Nial. Wonderful post.

Wonderful article. Thanks very much !

Our friend Mr. Nial Fuller is not only reading the very close aspects of the MARKET WHEELS, but he is reading as well the very close aspects of the TRADER MINDSET WHEELS.

Self-Control is the key to success.

i couldn’t help but say it all true.

May Almighty God continue to bless you for being a blessing to my life and my trading career.

Just reading your news letters have turned me around in trading.

Thanks Nial, a briliant lesson as always.

Another brilliant article, and good advice within it. Excellent and encouraging Article. Trade less, observe more and with patience you can improve ur Trading.

Once agian Great Artical.

I like this article very much, inspire me a lot. Thanks Nial.

This is like the “Geeta” The Hindu Greatest Book……

I just spent 330.00$ on your course. After reading this i realize i have spent my money wisely. Not only have you got your stuff together when you talk about forex, you are on top of your game when it comes to life.

I will be following you for some time to come. I’m glad to have found your presents.

Thanks Nial. I almost always ”overtrade”. My demo acct is just below the $5000 I started with. I always seem to jump in when there ”seems” to be a ”possibility” of a trade. I’m a trading junkie. I constantly need to hear the ”truth” that I’m undisciplined and am not ” sniper trading” and need to get back on track, like right now! Even though I’m still chasing after, not so good trades, I have been getting a little better at ”sniper trading” thanks to your constant articles, and one day, I’m sure, it will sink in and I will be trading a live acct successfully. That , I am sure. I love trading. Have been doing it for 13 yrs now, [I’m ashamed to say], but, I have learned so much and since I found you my knowledge of successful trading has increased tremendously and been reinforced and I am again excited about the possibility of making money , if I get disciplined. Your an inspiration Nial.

Thanks Nial. Today’s lesson reinforces my 80% of being in control of what I do with analysing and managing my money through patience and discipline. I have found overtime I actually trade less but my routine is daily. 20% is when I do trade an obvious price action strategy as learnt through your course with the daily chart being instrumental to my process. Thank you for your continued inspiration and support.

Wonderful Article, Sir.

I had never heard of this 80/20 rule, but will surely accept and appreciate todays lesson.

In simple words quality should be better than quantity.

Very good article! I ordered the book. Actually had heard of the principle but never got to any in depth study. I will fix that immediately!

Have a good weekend!

thanx once again. the 80/20 rule is wonderful.

Another brilliant article, and good advice within it. The 80/20 principle can be applied to most areas of life, both business/trading and personal.

“You should be focusing about 80% of your trading efforts on money management and controlling yourself / being disciplined (psychology), and about 20% on actually analyzing the charts and trading. If you do this consistently, I can guarantee you that you will see a very positive change in your trading profits, or lack thereof.

THIS HAS REALLY BEEN MY SAVING PRINCIPLE IN FOREX TRADING, MY TRADING IS NOW FAR BETTER THAN BEFORE.

Thank you Nial ! Fully agree with you.

Excellent and encouraging Article. Trade less, observe more, Patience.

Your blog posts are nothing short of Awesome! Thank you for taking the time to put this post together. I’m sure it takes a good amount of time to think through and present quality content on a blog post.

Thanks Nial for these reminders. When I found a trading strategy that works, I make money, but only for a time. I trade using the lower time frames, earn some money, and lose much more, so I have to return to the daily time frame. I realize I need to receive your teachings again and follow them religiously. Now I’m a staunch believer of your doctrines. Thanks. I know my trading, and my life, will never be the same again. May God bless you more.

Online Trading option Kiribati

Поиск по этому блогу

Forex 80-20 strategy

Комментарии

Отправить комментарий