All calculations have a source (data type) and they need to be specified, so the code knows what to calculate with. It is absolutely worth spending some of your time on this subject, to get a good understanding of how these data types affect your scripts. It takes a while to wrap your head around them and how/when/where you apply them. FYI: I am by no means an expert in this field, so look at this as nothing more than anecdotal experience.

I will write my way through the basics of what I think will help you on your way and in this case that means plotting the OHLC candles.

There are four basic candle values: open, high, low, close. When you select one of them, it really means you select the following data: “The open/high/low/close data point of the time period you applied to the instrument.”

If we would plot these values in the simplest way, it would look like this in code (Figure 1) and on the chart (Figure 2):

Something to think about: only the open is known at the start of a period, assuming the high or low of a period is not the same as the open (which it can be). Only the close is known when a period is ended.

So, now you know how TradingView candlesticks are plotted, you can imagine the line chart, which is only plotted using the close and is therefore a lot “cleaner”.

Different timeframes

What if I want to use data from a different timeframe then the one I’m currently looking at? This requires the use of the security() function, which in Pine Script is used like this:

This function will need a symbol (including an exchange) like the following: “BINANCE:BTCUSDT”, so it will know where to pull the data from. If you want to pull data from chart you’re looking at, just use tickerid.

Then it looks at the resolution, which is the timeframe, for the 15 minute chart this is “15”, for the 4 hour chart it’s “240” and for the daily chart it’s “D”. If you want to pull data from the timeframe you’re looking at, you enter period.

The expression it needs is the data type, which I just discussed.

gaps and lookahead are more advanced parameters of this function, which are by default set to off and most of you are better off for it. If you want to play around with these settings, you should check this link.

If I’m looking at a 15 minute Bitcoin chart and i want to see the daily data, I will need to code the following:

This worked perfectly, but it would still be nice to turn this into a more dynamic piece of code, so you can edit the values through a menu. I would like a selection of resolutions and expressions to choose from.

The results from this code above is exactly the same as in Figure 5, so let’s a bit to give it more functionality. What if you don’t want to see all four plots? You should be able to switch them off. We do this by creating an option in the menu for each plot and altering the lines with plot function. You do this by using a language operator.

You should read this as following: If ‘expr1' is, it will execute ‘expr2’. If not, then it will execute ‘expr3’. Without this making much sense in a grammatical way, it does show the opportunity for using this as a switch. Let me show you how this looks in code, it makes more sense in my opinion.

You can see that I added a showPlot variable for each line, which can be set to true or false. Then, in the plot codes, I added the language operator which now reads a lot better: If showPlot is true, then show Data or else (false) do nothing (na). In the menu it looks like this:

So, now i can plot one line (by turning 3 of them off) with a lesser used data type of my selection, HLC3 in this instance, which stands for (high + low + close) / 3, on a daily timeframe.

Exotic data inputs

Experimenting with data types makes your bot more versatile and sometimes it definitely makes more sense to use one instead of the other. What would happen if you choose to use very different inputs to use in your calculations? What about using OBV as the calculations for Bollinger Bands?

Extra Dimensions

If playing with data types makes your bot more versatile, then playing with timeframes opens a door to new dimensions for your bot, by being able to give it instructions such as:

• Only buy/long when the daily close is above the SMA200 and the RSI is leaving oversold conditions on the 1 hour timeframe
• Do not sell/short when the 4 hour close is above the Ichimoku Tenkan-sen and 30 minute OBV is still rising
• Do not execute a buy/long or sell/short at all when the daily Bitcoin ATR (volatility) is below 4%.

These are just examples, but demonstrate the newfound abilities.

I hope this piece will help you in trying out a lot of combinations, i have no doubt there is winner in there, thanks for reading!

You can follow me on Twitter, where you can also find the link to my bot which shares it’s calls for free on Telegram! Im also on TradingView, where you can see and use my scripts.

Ingredients

So, what do you need for this script to work? For a simple script you only need a couple of things, but there are some basics. To get started, go to a chart in TradingView and click “Pine Editor” at the bottom of your screen.

You will now see a notepad-like editor, which we will use to create scripts. The first thing you will notice is the important line of //@version=3. This is critical and is needed to communicate that you will be using version 3 of Pine Script. Be sure to always start with this line.

There are two types of scripts within Pine Script, namely study and strategy. The main difference between them, is that you can create alerts under a study and you can backtest your script under strategy. Why TradingView split these functionalities is one of the great mystery’s of our time, but that is just the way it is.

In the example script loaded, the third line says plot(close). This means the script will plot a line of the current close data point of the instrument you apply it to. If you are used to looking at candlesticks, you know that they stand for the Open, High, Low and Close (OHLC) of a period. This means that a plot(low), would plot a line of the lows of every period that you have selected, such as the Daily, 4 Hours, 1 Hour etcetera. Selecting the data you for you script to calculate with is arguably one of the harder parts of algorithmic scripting, but I’ll be sure to dedicate one article to it in the series.

Setting up your strategy

So, let’s take a closer look at the strategy() function and replace the study() function in the editor.

Looks messy, but setting this up the right way will help making your backtest results a lot more reliable. Once you have your strategy running, you can find most of these settings in the configuration menu of your strategy.

And this is how that looks as code

And this is what that means:

• Sets title and shorttitle to “A Simple Start - Strategy [CP]”
• Sets overlay to ‘true’, so that the script will be layed over the price, instead of seperate pane. Usefull for Moving Averages, not so much for a RSI or OBV script.
• Sets starting capital to test with to 50.000 USD. You want this to be a high number. If you are testing your script on Bitcoin for example, it will have trouble testing it at the time $BTC was at $20.000 a piece. You can always see what trouble that causes by setting this lower.
• Pyramiding gives you the ability to layer buy orders with a designated percentage of your stash. Not needed in Moving Averages crossovers, so 0.
• Sets commission type to percentage and value at 0.075%. Specifically for trading on Binance. If you have a bag of $BNB, the commission/trading fees are 0.075% (discount of 0.025%).
• Disables intrabar strategy and order calculation. These are two settings that are best turned off, as they will mess with your backtest results greatly.
• Sets the quantity value to 100%. So you will be trading with your entire stash from long to short, which is a great way to see the effectiveness of your strategy, specifically on Moving Averages crossovers.

This might seem like a lot take in, but don’t underestimate the importance of setting the scope of your strategy.

Now that we’ve defined the scope, we can continue creating two Moving Averages, a fast one and a slow one. For this script we will use the Simple Moving Average. So let’s take a look at how Pine Script calculates the SMA.

To calculate we need a source and a length. The source is data that the calculation uses and for this example we will use the close data point. The length is the number of periods (bars) the calculation uses. The higher the length, the slower the Moving Average responds. So we will be using a small number for the Fast MA and a greater length for the Slow MA. After defining that MA’s we will use the plot function to draw them on your screen.

This is how that looks as code in your editor:

As you can see, i gave the plot function some extra details, such as the color of the MA, the width of the line and a title. So now the Fast and Slow MA is set in stone with 5 and 25 periods, but I would like this to be easily changed. Actually, I want to do the same thing with the source of my data. So we can create a menu setting to change this with the input() function. That looks like this

So, now the inputs of my SMA’s are dynamic and that makes testing a lot easier. To zoom in on the input() function, you can see that in the case of lengthFastMA, we set the default value to 5, the type to integer, which means it is a whole number and gave it a title so we can recognize it easily in the menu later on.

As you can see i also added some commentary to different parts of the code. This makes it easier to read if you want to share your code with others or for yourself when your scripts run into the hundreds of lines.

Now that we’ve got dynamic SMA’s, there are just two steps left.

• Defining the conditions that would signal a long/buy or short/sell signal.
• Excuting that strategy

Defining conditions

Conditions are basically rules. X is a bigger than Y for example, which in code would become x > y . These mechanisms to compare values to eachother are called operators and i’ll also zoom in on them in a different article.

Fortunately Pine Script has an built-in function to detect crossovers, crossunders or just crosses. Let’s take a look at what information they need.

It looks like it needs to check two variables, ‘x’ and ‘y’, which we will replace with the Fast MA and the Slow MA. If it detects that this happened it will return a signal to us, namely a boolean, which is a datatype that can only consist of ‘true’ or ‘false’. So what we want to define is the following:

• Long/Buy signal: The Fast MA crosses over the Slow MA
• Short/Sell signal: The Fast MA crosses under the Slow MA

This is how that looks as code:

Now we are left with the final part of the script.

Strategy execution

Based on the conditions we just set with the crossover() and crossunder() function we need the last bit of code to execute the strategy when the conditions are met. This is done with the strategy.entry() function. Let’s take a closer look.

Once again, a lot of options and when you want to continue building scripts and they become more complex, you will definitely need to go down that rabbit hole. For our purpose, we only need to give it a name and trigger it when the conditions we set earlier, are met. We do this with the following code:

If you look at the latest addition of code it reads as following:

• If the Fast MA crosses over the Slow MA, enter a Long position with the ID “MA Cross - Long”
• If the Fast MA crosses under the Slow MA, enter a Short position with the ID “MA Cross - Short”

The last thing that you need to do is hit the Save button, and when it’s done compiling you can hit “Add to Chart” and you’ll see the SMA’s appearing on your screen. You can now hit the cogwheel button to change the periods of your SMA’s and under “Strategy Tester” you’ll see the results of your strategy change instantly!

This was the start of the series and I hope you this has made starting with scripting easier. If you have any feedback, do let me know!

You can follow me on Twitter, where you can also find the link to my bot which shares it’s calls for free on Telegram! Im also on TradingView, where you can see and use my scripts.

It also wouldn’t hurt to study the Pine Script Language Reference Manual, so you can get up to date on al the functions, variables and operators used by Pine Script.

FYI: I have an advanced script with multiple MA’s and other filters you can use for free, you can find it here!

Yesterday, I introduced myself on Crypto Twitter and I wanted to follow up with an article about algorithmic scripting.

Ｃｏｉｎｐｏｃａｌｙｐｓｅ on Twitter

Hello Crypto Twitter, Let me introduce myself. I'm not new here, but I am using a new account to promote and be critical about all matters concerning automated trading.

This is my first article and I’ve given some thought on the subject. There is a ton to choose from and a lot of choices would have been a nice and easy start, but I wanted to show you what the goal of the coming series is.

So for this article, I will be telling you all about one of my favourite indicators, ADX &DI, which shows strength and directional movement, how i made it my own and is now one of the pillars of my automated trading style.

I will start off with some basic info about this indicator and focus on the usability. You can expect more technical articles with code examples in the future, so hopefully you can make your own!

ADX & DI

The ADX is a combination of two other indicators developed by J. Welles Wilder, the positive directional indicator (abbreviated +DI) and negative directional indicator (-DI).

The Average Directional Index (ADX) line shows the strength of the trend. The higher the ADX value, the stronger the trend. According to Wilder, a trend is present when the ADX is above the value of 25. DI values range between zero and 100.

The +DI generally moves in sync with price, which means the +DI rises when price rises, and it falls when price falls. It is important to note that the -DI behaves in the opposite manner and moves counter-directional to price.
The -DI rises when price falls, and it falls when the price rises. This takes a little getting used to. Just remember that the strength of a price move up or down is always recorded by a peak in the respective DMI line.

Reading directional signals is easy. When the +DI is dominant and rising, price direction is up. When the -DI is dominant and rising, price direction is down. But the strength of price must also be considered.
DI strength ranges from a low of 0 to a high of 100. The higher the DI value, the stronger the prices swing. DI values over 25 mean price is directionally strong. DI values under 25 mean price is directionally weak.

So, how does it look?

Just by looking at the picture above, you can see the 3 dynamic lines moving all over the place. Without even knowing what any of these lines mean, you could observe the following:

• The ADX can be higher than both the +DI and the -DI
• The -DI can be higher than both the ADX and the +DI
• The +DI can be between the ADX and the -DI
• The +DI can be moving down and the -DI can move up at the same time
• The space between the +DI and the -DI can be smaller or bigger if you compare it to the previous period(s)
• And so on and so on…

This is just to illustrate we can define an insane amount of combinations that can give us a lot of information. Wilder himself had a few simple standard rules for this indicator:

• ADX above 25 equals a strong price trend
• Strong trend and+DI crosses up the -DI should signal a long entry
• Strong trend and -DI crosses up the +DI should signal a short entry

If you code those rules into pine script, it paints the following picture.

I don’t need to zoom in to see that besides these signals being mostly right, they are also a bit late. Not ideal for maximizing your profits, especially when you zoom in on the lower timeframes as in the picture below.

So why is this one of my favourite indicators? Because by now I can finally make my own rules and turn this lagging indicator into a leading one.

Make your own rules

I first came across this indicator in the public library of TradingView and at that point it was in version 2, which wasn’t the greatest because it handles price data in an awful way.

At that time I didn’t know how to port it to version 3, so i left it alone for a while untill I could code better. This took longer than I care to admit, but when I was finally porting it, I noticed that some of the code was off and did some more research into the math behind the indicator.

I then changed the code and it finally gave the right values. At this point it looks like it does in the pictures above, very rough. The next step is smoothing out the data to eliminate false positives and bad signals as much as possible. To do this, you use filters.

Filters

Filters come in many forms, the most known is probably the SMA, or Simple Moving Average, it smooths out the price data over a specified period. Turns out, you can smooth prety much everything. However, filters have their own problems as they introduce lag. So looking for the right mix between smoothing data and reducing lag as much as possible seems to be one of the holy grails of algorithmic trading.

As you do your research you come across the most intricate filters of which some of the code will make you go cry in a corner of the room. After a while they grow on you and personally I’ve been very impressed by the filters of John Ehler, who has a background in engineering and talks about Spectral Dilation, Cycle Analytics and Digital Signal Processing.

I incorporated his SuperSmoother and Laguerre filters into my scripts and it made a big difference. If you want to know more about that, he has written a book, Rocket Science for Traders, which I recommend if you want to go down that rabbit hole.

So, how does the ADX & DI look with those filters on it. Take a look.

You don’t have to look very hard to see the difference it makes. By coding my own rules it makes better trades, all because of smooth data baby. In this case it gave the following result in a short period.

I joke a bit about the result off course, the sample size is way too small. Here is another one on the M5 chart of $XRPUSD

This is the kind of result I’m working for and it took me a while to get here for sure. After reading this, I hope you’re motivated to start coding yourself. Don’t worry, you can make these scripts as complicated as you are able to, but some of the easiest codes can make all the difference in a good way. This was an opening article to show you where it lead me and maybe can lead you too.

FYI: I just published the ADX & DI script to TradingView and you can use it if you want to! I’m also running a bot on Telegram for free so you can check out the results live! You can find the link to the ADX & DI script and the free bot on twitter.com/coinpocalypse. If you enjoyed reading this, do give me a follow for future updates or shoot me a DM.

Thanks for reading and hope to see you next time!