🚀 Trading Like Neo: My Quest to Tame Moving Averages & RSI

The Quest Begins (The "Why")

I still remember the first time I stared at a candlestick chart and felt like I was trying to read ancient runes. My buddy sent me a screenshot of a stock that had just moon‑shot after a simple crossover, and I thought, “If only I could see that signal coming, I’d be the hero of my own portfolio.”

Honestly, I felt like Luke Skywalker staring at the Death Star plans – the data was there, but the meaning was hidden behind a wall of noise. I spent a weekend wrestling with Excel formulas, only to end up with a mess of #DIV/0! errors and a growing suspicion that I was missing the Force that makes technical indicators work.

That frustration lit the fire: I wanted to understand moving averages and the Relative Strength Index (RSI) not just as abstract formulas, but as living, breathing tools I could code, test, and wield like a lightsaber.

The Revelation (The Insight)

Here’s the secret I uncovered: both indicators are just smoothed versions of price that help us answer two simple questions

1. Is the trend gaining momentum? (Moving Average)
2. Is the price overextended and due for a pull‑back? (RSI)

Think of it like The Matrix: Neo doesn’t see green code flying around; he sees the underlying patterns that let him dodge bullets. Moving averages smooth out the price “noise” so the trend becomes visible. RSI, on the other hand, measures the speed and magnitude of price changes – it’s the heartbeat of the market, telling us when it’s racing too fast (overbought >70) or sluggish (oversold <30).

The “aha!” moment came when I realized I could compute both with just a few lines of pandas, and that the real power lies in combining them: a bullish crossover plus an RSI climbing out of oversold territory is a far stronger signal than either alone.

Wielding the Power (Code & Examples)

Let’s turn the insight into code. I’ll walk through a realistic snippet that fetches daily OHLCV data, calculates a 20‑day Simple Moving Average (SMA), a 20‑day Exponential Moving Average (EMA), and the 14‑day RSI, then plots the signals.

⚠️ Trap #1 – Forgetting to handle NaNs

When you roll a window, the first n rows become NaN. If you ignore them, your crossover logic will fire on garbage data.

⚠️ Trap #2 – Using the wrong price series

RSI is built on price changes, not raw prices. Feeding the close series directly into the RSI formula gives you nonsense.

The “Before” – Struggling with Manual Loops

# 😬 My first attempt – pure Python loops, slow and error‑prone
import yfinance as yf

data = yf.download('AAPL', start='2022-01-01', end='2023-01-01')
close = data['Close'].values

# 20‑day SMA (manual)
sma = []
for i in range(len(close)):
    if i < 19:
        sma.append(None)
    else:
        sma.append(sum(close[i-19:i+1]) / 20)

# RSI (manual) – yikes!
delta = [close[i+1] - close[i] for i in range(len(close)-1)]
gain = [max(d,0) for d in delta]
loss = [max(-d,0) for d in delta]
avg_gain = sum(gain[:14])/14
avg_loss = sum(loss[:14])/14
rs = avg_gain/avg_loss if avg_loss != 0 else 0
rsi = [100 - (100/(1+rs))] + [None]*(len(close)-1)   # only first value!

Running this felt like trying to duel Darth Vader with a butter knife – slow, clunky, and I kept messing up the indices.

The “After” – Harnessing pandas + ta‑lib (or manual vectorized)

# 🎇 The victory – clean, fast, and readable
import yfinance as yf
import pandas as pd
import numpy as np

# 1️⃣ Grab data
df = yf.download('AAPL', start='2022-01-01', end='2023-01-01')
# Keep only the columns we need
df = df[['Open', 'High', 'Low', 'Close', 'Volume']].copy()

# 2️⃣ Moving Averages
df['SMA_20'] = df['Close'].rolling(window=20).mean()
df['EMA_20'] = df['Close'].ewm(span=20, adjust=False).mean()

# 3️⃣ RSI – classic Wilder's method (vectorized)
delta = df['Close'].diff()
up = delta.clip(lower=0)
down = -delta.clip(upper=0)

# Exponential moving average of gains/losses (Wilder's smoothing)
roll_up = up.ewm(alpha=1/14, adjust=False).mean()
roll_down = down.ewm(alpha=1/14, adjust=False).mean()

rs = roll_up / roll_down
df['RSI_14'] = 100 - (100 / (1 + rs))

# 4️⃣ Signal generation (example: bullish crossover + RSI > 30)
df['Signal'] = np.where(
    (df['SMA_20'] > df['EMA_20']) &   # SMA above EMA → upward momentum
    (df['RSI_14'] > 30),              # RSI not oversold
    1, 0
)

# 5️⃣ Peek at the last few rows
print(df.tail())

What changed?

• Rolling & ewm do the heavy lifting in C‑speed – no more explicit loops.
• clip and diff give us the up/down moves needed for RSI in a single line.
• The signal column now holds a clean 1 (buy) or 0 (hold) that we can feed into a back‑tester.

When I ran this, the output lit up like the Millennium Falcon jumping to lightspeed:

                 Open    High     Low   Close  Volume  SMA_20   EMA_20  RSI_14  Signal
Date                                                                              
2022-12-26  150.12  152.34  149.80  151.50  25M   149.8    150.2   55.3      1
2022-12-27  151.50  153.10  151.00  152.80  22M   150.4    151.0   58.1      1
2022-12-28  152.80  154.00  152.20  153.50  20M   151.2    152.0   60.4      1
...

Seeing the SMA cross above the EMA while RSI climbed out of the 30‑zone gave me that “I’m the chosen one” feeling – the algorithm was finally speaking my language.

Why This New Power Matters

Armed with these indicators, I can now:

• Build a simple trading bot that enters a long position when the SMA‑EMA bullish crossover happens and RSI > 30, exiting when the reverse occurs or RSI > 70 (overbought).
• Filter out false breakouts – the RSI acts as a sanity check, preventing me from chasing a price spike that’s just exhaustion.
• Teach others (or my future self) how to blend trend‑following and momentum tools without drowning in math.

In short, I went from feeling like a Padawan lost in the archives to a Jedi who can sense the disturbance in the Force (aka market sentiment) before it becomes obvious to the crowd.

Your Turn – The Challenge

I dare you to take this snippet and add one more layer:

1. Compute a 10‑day ATR (Average True Range) to size your position based on volatility.
2. Plot the equity curve of a basic long‑only strategy using the signals we just generated.

Drop your results (or a gist) in the comments and let’s geek out over whose curve looks the most like a lightsaber slash!

May your moving averages be smooth and your RSIs ever‑so‑just‑right. Happy coding! 🚀