EMBEDDED RUST · no_std → WASM

Correct, and On Time

Build an eased proportional loop and understand why no garbage collector means a constant-time tick, the property behind reproducible control that the Institute's determinism work depends on.

01Challenge

A control loop that is late is a control loop that is wrong. Build an eased proportional drive that runs the same work every tick and settles cleanly into a tighter pad, and read why the absence of a garbage collector is what makes that timing dependable.

Predict firstTwo control loops run identical math — one in a garbage-collected language, one in Rust (no GC). Which holds a rock-steady loop time?

02Model

Correct and timely are not the same thing. A controller that computes the right command but arrives late has still failed, and languages that pause to collect garbage arrive late at moments you cannot predict. Rust has no garbage collector. control() allocates nothing on a hidden heap and runs the same handful of instructions every tick, so the control period is bounded and repeatable. That determinism is not a nicety here; it is what lets a recorded run replay identically and what the Institute's digital-twin work builds on. Build the eased loop, and the reason it settles cleanly is the same reason it settles predictably: every tick is the same tick.

03Guided practice

1. Ease the forward. Replace the zero with let forward = (0.9 * dist).min(0.6); so effort shrinks as distance falls. 2. Keep steering. let turn = 1.2 * p.goal.bearing(); then p.motors.set(forward - turn, forward + turn); 3. Why it is on time. No allocation, no GC pause: the same instructions every tick, a bounded period. 4. Settle. Land inside the tighter 0.15 m pad without a late overshoot.

04Feedback

PASS WHEN The rover settles within 0.15 m using an eased proportional drive that does the same bounded work every tick.

If your run fails, check:

Rover sits still: `forward` is still 0.0. Make it `(0.9 * dist).min(0.6)`.
Overshoots past 0.15 m: a constant forward slams through the pad. Keep it proportional so effort eases to zero as you arrive.
Crawls and times out: gain too low or cap too small. Move the gain toward 0.9 and the cap toward 0.6.

05Retrieve & space

What is the difference between a control loop being correct and being on time, and why does lateness matter on a robot?
Why does the absence of a garbage collector make the control period bounded and repeatable?
How does a constant-time, allocation-free tick connect to a run being able to replay identically? (determinism).

06Mastery & project

Write an eased proportional loop whose per-tick cost is bounded and repeatable because nothing is collected at runtime: correct and on time.

The determinism thesis in code, linking the course to the digital-twin and deterministic Physical AI research.

← One Source, Two Targets Capstone: The Portable, Deterministic Controller →

EMBEDDED RUST · no_std → WASM

Correct, and On Time

Build an eased proportional loop with a bounded, repeatable per-tick cost. Land inside the tighter pad.

You read

You change

the firmware you write in the control loop

Fixed

the emulated chip, its peripherals, and the wiring