Tell typists apart

The plan, in everyday terms

Imagine learning to recognise 50 people by their knock. First you listen to each person knock four times and remember their usual rhythm. Then someone knocks and you ask: whose usual rhythm is this closest to? That is the whole method.

The practice data

typing_samples() from the practice world gives you attempts at typing the set phrase keep it private. Each attempt is a dict:

{"typist": "T07",
 "dwell":  [96, 104, 88, ...],    # 15 numbers, one per key, in milliseconds
 "flight": [151, 130, 202, ...]}  # 14 numbers, one per gap between keys

The typists are invented by a seeded generator, loosely shaped like ordinary typing. So the accuracy you measure says how well you separate these typists. Real studies report a wide range of results depending on the people, keyboards and text; we make no claim about real-world accuracy.

Measuring "how close"

To compare two lists of timings, add up how far apart they are at each position, ignoring whether the gap is positive or negative. Python's abs() drops the sign: abs(-7) is 7. Python's zip(a, b) walks two lists side by side:

for x, y in zip([100, 150], [90, 170]):
    print(x, y, abs(x - y))    # 100 90 10, then 150 170 20

So the distance here is 10 + 20 = 30. A smaller distance means "more alike".

The defence: noise

The noise option adds random jitter of about that many milliseconds to every timing, the way a privacy tool might delay key events by small random amounts before the page sees them. Watch what it does to your accuracy, and think about what it would do to the person typing: 150 milliseconds of random lag on each key would feel sluggish.

const distance = (a, b) => a.reduce((t, x, i) => t + Math.abs(x - b[i]), 0);

function identify(features, profiles) {
  let best = null, bestDist = Infinity;
  for (const [name, p] of Object.entries(profiles)) {
    const d = distance(features, p);
    if (d < bestDist) { best = name; bestDist = d; }
  }
  return best;
}

fn distance(a: &[f64], b: &[f64]) -> f64 {
    a.iter().zip(b).map(|(x, y)| (x - y).abs()).sum()
}

What you should see

With no noise, nearly every attempt is matched to the right typist. Moderate noise (50 ms) costs some accuracy, but most attempts are still matched; heavy noise (150 ms) brings accuracy down sharply. That is the honest trade-off: timing noise helps, but enough noise to hide you also makes typing feel worse. The final lesson of this module looks at defences that do not cost you comfort.