Predicting the Next Beat in Motion

Picture a drummer watching a zoetrope while flying—each drum beat synchronised with the spinning disc’s frames, creating an illusion where motion appears to predict itself. This is the essence of frame prediction: using patterns in sequential data to anticipate what comes next.

In video compression, frame prediction became crucial in the 1990s when engineers realised most video frames are nearly identical to their predecessors. Instead of storing every pixel, they stored movement vectors—tiny arrows pointing from where objects were to where they’re going.

Here’s Go tracking a simple flight path with velocity prediction:

type Position struct { X, Y float64 }
type Flight struct { Pos, Velocity Position }

func (f *Flight) PredictNext(deltaTime float64) Position {
    return Position{
        X: f.Pos.X + f.Velocity.X*deltaTime,
        Y: f.Pos.Y + f.Velocity.Y*deltaTime,
    }
}

// Usage: next := flight.PredictNext(1.0/60.0) // 60fps

Lua offers a more fluid approach to the same concept:

function predict_frame(history, steps)
  local dx = history[#history].x - history[#history-1].x
  local dy = history[#history].y - history[#history-1].y
  return {
    x = history[#history].x + dx * steps,
    y = history[#history].y + dy * steps
  }
end

local next_pos = predict_frame(flight_path, 3)

The beauty lies in the trade-offs: Go’s structured types make motion vectors explicit and compiler-checked, while Lua’s table flexibility lets you experiment with different prediction models—maybe accounting for acceleration or wind resistance—without rewriting type definitions.

Both approaches capture the zoetrope’s magic: from a sequence of discrete moments, we extrapolate continuous motion. Whether it’s predicting where a aircraft will be in three seconds or which drum pattern comes next in a polyrhythmic sequence, frame prediction turns the past into a crystal ball for the immediate future.