Timevolt

Posted on Jul 11

Understanding Moving Averages & RSI: Dodging Bullets Like Neo

#trading #finance #crypto #stocks

The Quest Begins (The "Why")

Honestly, I used to stare at candlestick charts feeling like I was trapped in a never‑ending loop of “buy high, sell low.” I’d read blog posts that threw around terms like simple moving average and relative strength index as if they were magic spells, but every time I tried to code them I ended up with jagged lines that made no sense. My portfolio was taking hits, and I felt like I was fighting a boss without knowing its attack pattern.

The turning point came when I spent a frustrating weekend trying to back‑test a strategy that kept giving me phantom profits. I realized I wasn’t just misunderstanding the indicators—I was mishandling the data itself. If I could get those calculations right, I could finally see the hidden trends the market was whispering. That’s when I decided to treat the whole thing like a quest: gather the right tools, learn the spells, and avoid the classic traps that turn a hero into a side‑kick.

The Revelation (The Insight)

Here’s the thing: moving averages and RSI aren’t mystical; they’re just math applied to price series, but the way you compute them changes everything.

Simple Moving Average (SMA) – the average of the last n closing prices. It smooths out noise so you can see the underlying direction.
Exponential Moving Average (EMA) – similar to SMA but gives more weight to recent prices, making it react faster to changes.
Relative Strength Index (RSI) – a momentum oscillator that measures the speed and magnitude of price moves on a scale of 0‑100. Values above 70 hint at overbought conditions; below 30 hint at oversold.

The real “aha!” moment was understanding that you must calculate these indicators only with data that would have been available at that point in time. Using future prices (look‑ahead bias) makes your back‑test look amazing but guarantees failure in live trading. Once I wrapped my head around that, the indicators started behaving like reliable scouts instead of deceitful mirages.

Wielding the Power (Code & Examples)

Let’s see the transformation from a naïve, bug‑ridden implementation to a clean, production‑ready one. I’ll use Python with pandas because it’s the Swiss‑army knife for time‑series work.

The Struggle: Manual Loops & Look‑Ahead

# ❌ DON'T DO THIS – naive loop with look‑ahead bias
def sma_naive(prices, window):
    result = []
    for i in range(len(prices)):
        # Oops! we include future prices when i < window-1
        window_slice = prices[i:i+window]   # looks ahead!
        result.append(window_slice.mean())
    return result

# Example usage (will give misleading early values)
prices = [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
print(sma_naive(prices, 3))

Running this, the first two SMA values are calculated from [10,11,12] and [11,12,13] but also include prices that haven’t happened yet when you’re actually at those points. In a back‑test it inflates early performance – a classic trap.

The Victory: Pandas Rolling & Proper EMA/RSI

import pandas as pd
import numpy as np

def compute_indicators(df, sma_window=20, ema_window=20, rsi_window=14):
    """
    df must have a 'close' column with chronological prices.
    Returns a copy with SMA, EMA, and RSI columns.
    """
    # ----- SMA -----
    df['SMA'] = df['close'].rolling(window=sma_window).mean()

    # ----- EMA -----
    df['EMA'] = df['close'].ewm(span=ema_window, adjust=False).mean()

    # ----- RSI -----
    delta = df['close'].diff()
    gain = delta.clip(lower=0)
    loss = -delta.clip(upper=0)

    # Use Wilder's smoothing (equivalent to ewm with alpha=1/period)
    avg_gain = gain.ewm(alpha=1/rsi_window, adjust=False).mean()
    avg_loss = loss.ewm(alpha=1/rsi_window, adjust=False).mean()

    rs = avg_gain / avg_loss
    df['RSI'] = 100 - (100 / (1 + rs))

    return df

# Example usage
data = {
    'close': [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
              21, 22, 23, 24, 25, 26, 27, 28, 29, 30]
}
df = pd.DataFrame(data)
df_with_indicators = compute_indicators(df, sma_window=5, ema_window=5, rsi_window=14)
print(df_with_indicators.tail())

What changed?

rolling().mean() automatically uses only past values – the first window-1 entries become NaN, which is correct because we don’t have enough history yet.
ewm() (exponential weighted moving average) gives the EMA without any look‑ahead.
The RSI calculation follows Wilder’s method: compute gains/losses, smooth them with an EMA, then derive the RS ratio. All steps rely solely on historical data.

Common Traps to Avoid

Using min_periods=0 in rolling – this forces the SMA to return a value even when there aren’t enough points, effectively injecting future data. Always leave the default (min_periods=None) or explicitly set it to the window size.
Confusing span and alpha in EWMA – span is more intuitive (span = window). If you use alpha, remember alpha = 2/(span+1). Mixing them up leads to overly reactive or sluggish EMAs.
Forgetting to handle division by zero in RSI – when avg_loss is zero (a strongly upward move), RS goes to infinity and RSI should be 100. The line df['RSI'] = 100 - (100 / (1 + rs)) safely handles that because 1/∞ → 0.

Why This New Power Matters

Now that you’ve got reliable SMA, EMA, and RSI lines, you can:

Spot trends faster – EMA crosses above SMA often signal bullish momentum; the opposite hints at a bearish shift.
Gauge overbought/oversold zones – RSI > 70 or < 30 can warn you when a move may be exhausting, helping you avoid buying at the top or selling at the bottom.
Build systematic strategies – combine the indicators (e.g., buy when EMA > SMA and RSI < 30) and back‑test with confidence, knowing your numbers aren’t polluted by look‑ahead bias.

Imagine you’re a trader in a bustling market bazaar. Before, you were shouting prices based on gut feeling, getting tricked by mirages. Now you have a pair of polished lenses (the indicators) that let you see the real flow of goods, letting you make decisions that feel less like gambling and more like informed hunting. That shift from chaos to clarity is why mastering these tools feels like leveling up your character in an RPG – you’re suddenly equipped to take on tougher bosses (volatile markets) with a solid strategy.

Your Turn

Grab a CSV of historical prices (Yahoo Finance, Alpha Vantage, or even a crypto exchange), drop it into a pandas DataFrame, and try the compute_indicators function above. Plot the SMA, EMA, and RSI with matplotlib or plotly and see how they react to recent news spikes or earnings reports.

Challenge: Implement a simple “buy when EMA crosses above SMA and RSI < 30, sell when EMA crosses below SMA or RSI > 70” strategy and calculate its equity curve. Does it outperform a buy‑and‑hold hold? Share your results or any tweaks you discover – I’d love to hear what you find!

Happy coding, and may your charts always be clear and your profits steady. 🚀

DEV Community