Basic Pine Script Syntax for Absolute Beginners

Lessons 36-37 covered what Pine Script is and the indicator-vs-strategy distinction, without showing a single line of actual code. This lesson finally looks at a genuinely minimal example - just four lines - explained one at a time, in plain English. This is a taste, not a programming course.

A Genuinely Minimal Example

Here’s a deliberately simple example of what a first Pine Script indicator might look like:

//@version=5
indicator("My First Script")
length = 20
plot(ta.sma(close, length))

That’s the entire script. Four lines. Let’s walk through what each one is doing, in plain English, without worrying about memorizing exact syntax rules.

Line 1: The Version Declaration

//@version=5

This line tells TradingView which version of the Pine Script language the rest of the script is written for. Pine Script has evolved over time, and this declaration ensures the script is interpreted using the correct rules for that specific version - a bit like specifying which edition of a rulebook you’re playing by, before the actual game begins.

Line 2: The Script Declaration

indicator("My First Script")

This line does two things at once: it declares that this script is an indicator (recall Lesson 37’s distinction - purely visual, no simulated trades), and it gives the script a name, “My First Script,” which is what would appear on the chart and in TradingView’s indicator list once applied.

Line 3: A Simple Variable

length = 20

This line stores the number 20 under a name, length. Rather than typing the number 20 repeatedly throughout a script, a variable like this lets you refer to it by name - and, importantly, lets you change it in one place later (say, to 50) if you want to adjust the calculation without hunting through the entire script for every occurrence of the number.

In this example, length is intended to represent the number of periods used in a moving average calculation - a common building block from Module 5’s indicator lessons.

Line 4: The Plot Statement

plot(ta.sma(close, length))

This is where something finally becomes visible on the chart. In plain English, this line says: “calculate a simple moving average (sma) of the closing price (close), using the period length stored in length, and plot that calculation as a line on the chart.” Without this final line, the calculation would simply happen invisibly - plot(...) is what actually draws it where you can see it.

Line 1:  //@version=5              → "Use these language rules"
Line 2:  indicator("My First       → "This is an indicator,
          Script")                    call it this name"
Line 3:  length = 20                → "Remember the number 20
                                        as 'length'"
Line 4:  plot(ta.sma(close,         → "Calculate a moving average
          length))                     and draw it on the chart"

What This Example Deliberately Leaves Out

This lesson is not attempting to teach Pine Script comprehensively - there’s no coverage here of conditional logic, alert triggering from within a script, colors and styling options, or strategy-specific syntax (entry/exit rules from Lesson 37). All of that exists, and genuinely learning it takes continued practice well beyond this course. The goal here was narrower: showing that four understandable lines can produce a real, working result, demystifying Pine Script’s basic shape.

Real-Life Example: Adjusting One Number

Suppose a trader using a script similar to this example finds the 20-period moving average line reacts a little too quickly to short-term price noise for their taste. Because the length is stored as a variable (length = 20), adjusting it to length = 50 in that single spot changes the entire calculation to use a longer historical window - producing a smoother, slower-reacting line - without needing to touch any other part of the script.

Analogy: A Labeled Storage Box

Think of a variable like length = 20 as a labeled storage box: instead of scattering loose scraps of paper reading “20” throughout a workshop, you put the number 20 in one box labeled “length,” and everywhere else in the workshop, you just refer to “the length box.” Need to change it to 50 later? Just update what’s inside that one box - everything that references it automatically uses the new value.

Bridging Into Module 11: Where Alerts Come From

Recall Module 8’s alert lessons: alerts fire when a chart condition is met. A Pine Script - particularly a strategy script (Lesson 37) with defined entry and exit conditions - is commonly exactly what generates those very conditions. A trader’s custom strategy script, once running on a chart, can be configured to trigger an alert whenever its own internal buy or sell condition fires - connecting everything from this module directly into Module 8’s alert system.

Module 11, starting with the next lesson, explains what happens when an alert like that is connected to a webhook - turning a chart-based condition into an automated message sent to another system.

Common Beginner Mistakes

• Trying to memorize this example instead of understanding what each line type does. The goal is recognizing the PURPOSE of a version line, a declaration line, a variable, and a plot statement - not this exact example verbatim.
• Expecting this lesson to teach comprehensive syntax rules. This module offers a first taste; genuine fluency takes continued practice well beyond this course’s scope.
• Assuming a script needs to be complex to be valid. A working script can be genuinely simple, as this four-line example shows.
• Confusing this indicator-type example with a strategy script. This example only plots visually - Lesson 37’s distinction still applies, and this script does not simulate any trades.

Practical Tips

• If curious, type this exact four-line example into TradingView’s Pine Editor and apply it to a chart, just to see a moving average line appear - a small, satisfying way to connect this lesson’s explanation to a real result.
• Try changing just the length variable’s number and observe how the plotted line’s smoothness changes - a low-risk way to build intuition without touching anything else in the script.
• Carry the “codify your own idea” mindset from Lesson 36 forward into Module 11 - the webhook and automation lessons ahead build directly on the idea that a script’s conditions (however simple or elaborate) are what ultimately triggers an alert.

Conclusion

Four lines - a version declaration, a script declaration, a variable, and a plot statement - are enough to see what Pine Script actually looks like and to demystify its basic shape, even without becoming fluent in it. This closes Module 10. Module 11 picks up directly from here: the alert conditions that scripts like this one (or considerably more elaborate versions of it) commonly generate are exactly what gets turned into a webhook message, starting with Lesson 39.