Evidence

Conventional JavaScript rebuild — the same domain with no type checker at all

The identical requirement set built a third time in JavaScript, to see what changes when the language offers no static checking whatsoever.

What this was

Status: Complete
Repository: kemiller2002/time-entry-state-machine
Branch: main
Ending commit: 73a63f1ac319
Executed by: The same session and persona protocol as the conventional C# rebuild.

Objective

Separate what the architecture contributes from what the language contributes, by removing static checking entirely.

Hypothesis

The mechanism that catches a mistake matters more than the number of mistakes, and it should be visible when the language contributes nothing.

Method

Same persona, same no-look-ahead rule, same requirement order as the C# rebuild.

Recorded metrics

Rework-driving mistakes in the JavaScript rebuild

Self-reported

Measures: Substantive mistakes across the 1,540-line JavaScript rebuild of the same requirement set.
Collected by: Recorded live per requirement under the same rules as the C# rebuild.
Does not show: Read naively this beats the C# rebuild's six, which is the opposite of what the same trial's other findings predict. The log attributes it to having already built the identical requirement set once, and names the two places where that hindsight prevented a repeat of an earlier failure.

Sourcekemiller2002/time-entry-state-machine / effort-experiment/EFFORT-LOG.md — Totals — the complete hodgepodge JavaScript buildprivate repository

Mistakes caught by the language

Instrumented

Measures: Mistakes in the conventional JavaScript rebuild caught by the language or its tooling rather than by a test or a person.
Collected by: Classified per mistake as it was found. A property rename across two production files produced zero errors, zero warnings and zero crashes.
Does not show: A property of JavaScript with no type checker configured, not a claim about JavaScript projects that use one.

Sourcekemiller2002/time-entry-state-machine / effort-experiment/EFFORT-LOG.md at 73a63f1ac319 — Totals — the complete hodgepodge JavaScript buildprivate repository

0 of ~22

Call sites the JavaScript language reported on the same change

Self-reported

Measures: Sites the language or its tooling named when the identical unit change was applied to the JavaScript rebuild.
Collected by: Counted during the change. The property rename produced zero errors, zero warnings and zero crashes.
Does not show: A property of JavaScript with no type checker configured, not a claim about JavaScript projects that use one.

Sourcekemiller2002/time-entry-state-machine / effort-experiment/EFFORT-LOG.md — F1 — exact-minute recording + derived billing (JavaScript trial)private repository

8, from one root cause

JavaScript test failures that caught the change instead

Self-reported

Measures: Test failures produced by the unit change in the JavaScript rebuild, all tracing to unfixed duration literals.
Collected by: Counted on the first run after the production rename, before any test literal was touched.
Does not show: These caught the change because the assertions compare numbers, not because anything referenced a renamed property that no longer existed — that class of bug stays invisible. A real safety net, and the only one available.

Sourcekemiller2002/time-entry-state-machine / effort-experiment/EFFORT-LOG.md — F1 — exact-minute recording + derived billing (JavaScript trial)private repository

1 of 2

JavaScript mistakes caught only by a person

Self-reported

Measures: Mistakes in the JavaScript rebuild caught by a suspicion-driven search rather than by any mechanism.
Collected by: C9's five dead `.error` references, one root cause, found by a grep run on suspicion after the identical failure shape had already been documented once.
Does not show: Found because the same failure had been seen before in this trial series. That is hindsight, not a repeatable mechanism.

Sourcekemiller2002/time-entry-state-machine / effort-experiment/EFFORT-LOG.md — Totals — the complete hodgepodge JavaScript buildprivate repository

1 of 2

JavaScript mistakes caught by no mechanism at all

Self-reported

Measures: Mistakes in the JavaScript rebuild that neither the language, the test suite, nor a deliberate review caught.
Collected by: C6's look-ahead violation, found only because the next requirement's author happened to reopen the file it lived in.
Does not show: Found by luck. Under the trial's own rules it would otherwise have shipped, and it is recorded that way.

Sourcekemiller2002/time-entry-state-machine / effort-experiment/EFFORT-LOG.md — Totals — the complete hodgepodge JavaScript buildprivate repository

1,540 lines

Conventional JavaScript rebuild size

Self-reported

Measures: Final size of the conventional JavaScript rebuild across five files, with 60 passing tests.
Collected by: Counted at the end of the build.
Does not show: Within 7% of the C# rebuild, which is why the two mistake counts are comparable at all.

Sourcekemiller2002/time-entry-state-machine / effort-experiment/EFFORT-LOG.md — Totals — the complete hodgepodge JavaScript buildprivate repository

Findings

Nothing was caught by the language, at any point, for any reason. Renaming a property across two production files produced zero errors, zero warnings and zero crashes. The program ran.
Every defect that did not ship was caught by a test asserting a concrete value, or by a person deliberately re-reading code — never once by the tool doing the running.
Eight of twenty-one existing tests did fail after the unit-of-measure change, all from one root cause, which is a real safety net and is recorded as one.
One defect — five dead references left from an earlier requirement — was found only by a suspicion-driven search, after the identical failure shape had already been documented once.

What this refuted

Read on raw count this trial wins: two rework-driving mistakes against the C# rebuild's six, at comparable size. The log refuses that reading and explains why — this trial had already built the identical requirement set once, and the advantage shows up precisely in the two places where a failure mode from the earlier trial was consciously checked for and avoided.
Adding those two hindsight-avoided near-misses back brings the counts close to even, which is why the count is not the result.

Anomalies, failures and confounders

Two mistakes were avoided by hindsight rather than by tooling, and are recorded as non-events rather than counted as successes.
Every one of nineteen run attempts was clean on the first try — because there is no build step or type checker for a configuration or signature error to fail against before the tests run.

Limitations

Third build of the same requirements by the same session: the strongest ordering confound in the series.
A single configuration. Zero language-caught mistakes is a property of JavaScript without a type checker, not a claim about JavaScript projects that use one.
One person, one domain, one session.

Source artifacts

Sourcekemiller2002/time-entry-state-machine / effort-experiment/EFFORT-LOG.md at 73a63f1ac319 — Totals — the complete hodgepodge JavaScript buildprivate repository
Sourcekemiller2002/time-entry-state-machine / effort-experiment/JavaScript/README.md at 73a63f1ac319private repository
Sourcekemiller2002/time-entry-state-machine / research/experiments/EX-TE-2026-0003--hodgepodge-javascript-full-rebuild.md at 73a63f1ac319private repository