Smoothing What the Sensor Actually Said

The Davis temperature sensor updates every 2.5 seconds. I watched it for ten minutes this afternoon: 14.2°C, 14.3°C, 14.1°C, 14.4°C, 14.2°C, then suddenly 15.1°C—a gust of body heat from walking past, or thermal noise in the ADC, or just the atmosphere being unruly. If I log the raw stream, my temperature graph looks like it’s vibrating. If I average everything, I’ve thrown away genuine change.

Robert Goodell Brown developed exponential smoothing in 1956 for inventory forecasting at Arthur D. Little. The insight was simple: recent observations matter more than old ones, and you don’t need to store history to express that preference. One number—the smoothed value—carries forward, updated with each new reading by blending a fraction of the new with a fraction of the old.

The parameter α (alpha) controls how much you trust the latest reading. At α = 1.0, you’re just passing through raw data. At α = 0.01, your smoothed value barely budges when a new reading arrives. Weather stations typically use something in the 0.1 to 0.3 range for temperature—responsive enough to track a cold front, sluggish enough to ignore a momentary sensor hiccup.

function smoother(alpha) {
  let s = null;
  return (x) => {
    s = s === null ? x : alpha * x + (1 - alpha) * s;
    return s;
  };
}

const temp = smoother(0.2);
[14.2, 14.3, 14.1, 15.1, 14.4, 14.2].forEach(t =>
  console.log(`${t}°C → ${temp(t).toFixed(2)}°C`)
);

14.2°C → 14.20°C
14.3°C → 14.22°C
14.1°C → 14.20°C
15.1°C → 14.38°C  ← spike absorbed
14.4°C → 14.38°C
14.2°C → 14.35°C

The spike at 15.1°C didn’t disappear—it nudged the smoothed value up—but it didn’t dominate either. By the time two more readings arrive, the output has settled back toward the true temperature.

Erlang makes the state explicit. Instead of a closure hiding the smoothed value, you get a process that loops forever, carrying state through recursive tail calls:

-module(smooth).
-export([start/1, read/2]).

start(Alpha) -> spawn(fun() -> loop(Alpha, none) end).
read(Pid, V) -> Pid ! {V, self()}, receive R -> R end.

loop(A, none)   -> receive {V, P} -> P ! V, loop(A, V) end;
loop(A, S)      -> receive {V, P} ->
    New = A * V + (1 - A) * S, P ! New, loop(A, New) end.

Two ways of saying the same thing: memory persists between calls, new data blends with old, the output tracks reality without chasing noise. The closure version runs in a single thread; the Erlang version could supervise a hundred sensors independently, each process dying and restarting without affecting its neighbours.

I added exponential smoothing to my weather station logging script tonight. The temperature graph looks calmer now. Whether it’s more accurate—whether it better reflects the actual thermal state of the air three metres above my deck—I won’t know until I’ve compared a few weeks of data against the METAR. But the numbers feel less frantic. Which might just mean I’ve hidden the sensor’s honesty behind a mathematical blanket.

α = 0.2, for now. Subject to revision.