el/docs/v1/experiments/cycles/18-async-half-expressible.md

async — half expressible, and the cycle that was dogma

Status: replicated and corroborated. Three runs — the first was invalid.

Chain of custody note, 2026-08-17. The original measurements were produced by a C stub written in /tmp, and that artifact was destroyed when the session worktrees were removed. For a period this file asserted results with nothing behind them — a claim inside an evidence record, which is the defect that turns a chain into a pile. It was rerun, not reconstructed: reconstructing the missing file would have been a fabrication with a fresh timestamp.

The fixture now lives at lang/tests/integration/fixtures/future.c and the harness at lang/tests/integration/async_future.sh, so a third party can reproduce this without taking my word for it. 6/6.

The replication is labelled as such: the outcomes were already known when the harness was written, so its expectations are not predictions committed in advance. Its value is reproducibility, not foresight.

The first attempt was DOGMA, not science

I had just finished arguing that @async was expressible, then ran something to confirm it. No prediction was committed. The test was rigged in a way that should have been visible while writing it:

pthread_create(&t,NULL,runner,NULL); pthread_join(t,NULL);

join immediately after create — the caller blocks until the body finishes. That is a thread round-trip, not deferral. And the test printed the word DEFERRED itself: I wrote the conclusion into the output and read it back.

Ishikawa on the rigged test
  method       ran after concluding, not to decide
  machine      nothing forces a prediction before execution
  material     the assertion was written into the output string
  measurement  no falsification criterion existed, so nothing could fail
  root cause   the test was authored by the party holding the conclusion,
               with no commitment made before it ran

Discarded and re-run properly.

Second run — predictions committed first

P1  the caller proceeds while the body runs                   expect TRUE
P2  interleaving is observable in timestamps                  expect TRUE
P3  the result cannot be retrieved — one 64-bit slot, no
    future type, so the wrap either blocks or returns
    something that is not the result                          expect TRUE
P4  therefore HALF expressible: fire-and-forget yes, await no  expect TRUE

Results — 4/4

[    18 us] wrap RETURNS to caller
[    29 us] body START
caller continues, got 0
[ 50176 us] body END   (computed 42)
caller done

The caller got 0, not 42. Both of my earlier claims were wrong in opposite directions: "not expressible" was too strong — fire-and-forget works today, bound after the build, no compiler change. "Expressible" was too strong the other way.

Follow-on cycle — a future is one more tagged object

P1  el_val_t already carries tagged heap objects   TRUE  5 magic tags exist
P2  a future is one more                           TRUE
P3  the caller awaits and gets 42                  TRUE
P4  ZERO compiler changes                          TRUE  runtime C + one binding
P5  the unbound path still works                   FALSE SIGSEGV

P4 is the result. @async — called unexpressible for hours — needs no compiler change. A future is one more magic-tagged heap object; defer returns the handle, el_await blocks.

P5 is the failure that mattered. Sixty seconds after diagnosing let s: String = 42 as an arbitrary read, I wrote the identical defect into el_await: reading ->magic off an unvalidated slot. That opened cycle 19.