It is a logical step forward in terms of re-working the areas of obvious limitations of the past and much needed optimization of the main concept. In my own development work I very much see the same - from a complex thing to a much simpler end-product, so to speak, with better efficiency and performance. Evolution, not revolution.

I'm not a fan of it being web-based, browser updates can make life difficult sometimes, and being web-dependent is dependency, which is a draw-back in itself.

What's the trade-off of having only one entry/exit point (bar open only, as I understand)? I feel it being a step back.

Hello Footon,

Thank you for your comments!

>I'm not a fan of it being web-based, browser updates can make life difficult sometimes, and being web-dependent is dependency, which is a draw-back in itself.

I found out that web's development,  update, distribution and licensing is 10 times easier and faster. The UI is more fluid, faster and responsive.

The Windows software dependencies are heavier and the development requires third-party software.

90% of our future users will use phones and they all have a browser.
Even Microsoft consider selling Windows (or stopping the development).
Microsoft switched to Linux and make their money from Azzure.

I can upload (and I'm doing it) 20 updates per day.

With my recent framework (tested in https://coinrang.com/) the user's app is absolutely disconnected from the server.

> What's the trade-off of having only one entry/exit point (bar open only, as I understand)?

It gurantes a precise backtest.

If we have entries within a bar, we need various interpolation methods. FSB Pro provides the "Pessimistic" one, which is safe, but this is not the case in any other testing software - MT, or TradingView.

MT interpolation is a joke. They also don't provide a Close event or price.
Trading View opens only at Open and closes at Close.

If we make software for live trading or signals, what I want to do, must fetch ticks all the time in order to calculate a signal. As opposed to that, if you have 20 strategies in M5, I'l require only one ping every 5 minutes to calculate the signals. It can be a background process on a phone.

Testing new code fragments.
The current EA Studio code calculates 10 times MA on 100 000 bars for  11 milliseconds.
The new code does that for 3 milliseconds (3+ times faster)

Current code:

public static simpleMA(source: number[], period: number, shift: number): number[] {
    const length: number  = source.length
    const lastBar: number = Math.min(length, length - shift)
    const ma: number[]    = IndicatorBase.initMA(source, period, shift)

    for (let bar: number = period; bar < lastBar; bar++) {
        ma[bar + shift] = ma[bar + shift - 1] + (source[bar] - source[bar - period]) / period
    }

    return ma
}


private static initMA(source: number[], period: number, shift: number): number[] {
    const length: number  = source.length
    const lastBar: number = Math.min(length, length - shift)
    const ma: number[]    = new Array(length)

    for (let bar: number = 0; bar < period + shift - 1; bar++) {
        ma[bar] = 0.0
    }

    let sum: number = 0.0
    for (let bar: number = 0; bar < period; bar++) {
        sum += source[bar]
    }

    ma[period + shift - 1] = sum / period

    for (let bar: number = lastBar; bar < length; bar++) {
        ma[bar] = 0.0
    }

    return ma
}

New code:

/**
 * Simple Moving Average
 *
 * @param {Float64Array} source - the data source
 * @param {Float64Array} maRef  - reference to ma. maRef.length == source.length
 * @param {number}       period - period >= 1
 * @param {number}       shift  - shift  >= 0 && period + shift < source.length
 *
 * @return {void}
 */
public sma(source: Float64Array, maRef: Float64Array, period: number, shift: number): void {
    let sum = 0
    for (let bar = 0; bar < period; bar++)
        sum += source[bar]

    maRef[period + shift - 1] = sum / period

    for (let bar = period, lastBar = source.length - shift; bar < lastBar; bar++)
        maRef[bar + shift] = maRef[bar + shift - 1] + (source[bar] - source[bar - period]) / period
}

There are four differences between the code fragments.
- the first one uses a separate initMA function It is used by all other types of MAs. The necessary initialization is optimized and embedded in the second code variant.
- the first code uses generic arrays `number[]`. The second one uses typed arrays `Float64array`.
- the first code creates and returns a new MA array. It is semantically correct. However, it allocates a new array and the old one must be destroyed by the Garbage collector. On the other hand, the new code populates a given array by reference. It doesn't create garbage.
- the new code doesn't zero the start and the end of the MA because we provide it as `new Float64Array(source.length)`. It automatically initializes each element with 0.

The biggest performance improvement comes from the fact that the MA array is reused.

If I optimize the complete engine, it is feasible to have it 2 times faster or even more.

The simplest route is probably the best, you can backtrack if desired later in the project.

I prefer to see a few more indicators if that is feasible

Very nice, go for it and I am happy to hear this is coming to EA Studio too. My most requested features would be:

- Break-even option

- Exit after bars (that´s one of the most effective exits that all the other platforms seem to steadily generate when searching for strategies - sure thing because exiting if a trade does not work out is the best option indeed)

- A trailing stop with a configurable starting point and trailing distance (in pips and ATR based)

- Just as you say, being able to use indicator-based levels (the ones that return price values like Fibonacci levels, MA´s, Parabolic SAR, etc.) and ATR-based levels for SL / TP / BE / Trailing Stop would be super nice.

- Merged multi-symbol EAs, so that we can export a portfolio of different strategies on different symbols into one EA that works not just on one symbol (currently have to do this manually and it works nice but would be great to have that as a standard feature).

- More indicators, already merged into the exported code, so that we don´t have to mess around with external indicator files.

- Weighted fitness (one of my most important requests as I use that a lot in other platforms to get exactly the strategies I want without having to mess around with multiple optimizations). E.g., instead of just going for the best R-Squared or the best Ret/DD ratio, or lowest stagnation, we can weight these goals - say 70% focus on best R-Squared, 25% on Ret/DD ratio, and 5% on lowest stagnation.

Any speed improvement is always welcome as well and it´s amazing to see that you can make this even faster - holy moly EA Studio, on a single thread, is already ~x20 faster than another platform I am using that runs on 32 threads. Amazing work Mr. Popov!

Thanks for all your efforts - it´s so much appreciated.

Great news! Hope to see another cutting-edge software for traders soon! TradingView is very popular between traders in Brazil too! Hope you the best

The new software version looks very good. I'm a bit worried about what will happen to the FSB Pro software, whether it will be supported or retired?