A Woolly Lesson in Knowing Your Limits

The sheep’s left ear is almost right. A few shallow needle strokes tighten the surface; deeper strokes would carry fibres farther into the shape. Unfortunately, my imaginary wool simulator has fewer subtleties than the sheep. It knows only a packing score between 0 and 100.

That limitation gives it one useful lesson: when a value reaches its ceiling, further additions should leave it there. They should neither escape the allowed range nor wrap around to a small number.

This is saturating arithmetic. Ordinary addition asks for the sum. Saturating addition asks for the sum constrained to the representable interval.

const clamp = (value: number): number =>
  Math.max(0, Math.min(100, value));
const strokes = [9, 14, 12, 6];
let packing = 72;
for (const amount of strokes) {
  packing = clamp(packing + amount);
  console.log(packing);
}

The result is 81, 95, 100, 100, one value per line. The third stroke would produce 107; saturation keeps 100. The fourth stroke changes nothing.

OCaml can give the same little workshop demonstration:

let clamp value = max 0 (min 100 value)
let strokes = [9; 14; 12; 6]
let () =
  let packing = ref 72 in
  List.iter
    (fun amount ->
      packing := clamp (!packing + amount);
      Printf.printf "%d\n" !packing)
    strokes

Both versions add first and clamp afterwards. These small inputs make that safe; with machine-sized integers near their limits, the intermediate addition itself can overflow. A general implementation needs a wider intermediate type or a check before adding.

The appealing property is also the cost: saturation discards excess. Once 107 becomes 100, subtracting seven produces 93, not the earlier 100. Information has gone missing.

Real wool makes the analogy pleasantly imperfect. Extra stabbing can still distort an ear or damage fibres. Needle direction matters, and joining the ear requires loose fibres that can interlock with the head. Our bounded score models a software limit, not a material law. Still, it teaches a useful habit: decide explicitly what arithmetic should do at the edge.