Blog
The MLP That Never Got Written: Teaching a Deterministic Compiler to See Heat
A field report on putting the first trained model inside CJC-Lang’s deterministic compiler pipeline. The §2.1 data-sanity pass killed the planned MLP before a line of training code existed: recorded thermal pressure (FP-op density) was unpredictable from the existing features by ANY model class, because every static feature counted expressions without knowing their type. A conservative float-propagation analysis (TypeMix) closed the information gap; linear regression then saturated the task (held-out R² 0.952); the trained head shipped as a content-addressed CPB0 weight bundle whose model identity flows into report hashes; and a shadow-mode gate promoted it 9× over the v1 closed form. The honest nulls are documented with mechanisms: the Ising-style energy re-ranker permutes within an already-decided pass set (zero outcome effect, architectural not trainable), cpu/memory labels carry no learnable variance, and the first energy-head attempt fails held-out so badly it earns a design constraint for part two.
Locke v0.8: A LendingClub Demo, an Honest Model, and the Three Gaps the Audit Found
|AUC| = 0.9993, Locke-filtered 0.9995, Locke + custom detector 0.7388, hand-curated domain-honest 0.7394. The custom detector closes the gap inside Locke configuration, within 0.0006 of the hand-curated baseline. Shipped as cjc-locke v0.1.11 on crates.io and cjc-locke v0.1.2 on PyPI.
A field report on building Locke’s first end-to-end demo on real production-scale data. The LendingClub 2007–2018 leakage audit’s honest-model AUC measurement (the 4-way logistic-regression comparison) revealed that Locke’s built-in |AUC|≥0.85 leakage heuristic catches the strongest signals but not all of them. That finding drove two ADRs in the same session — a custom-detector extension layer that lets analysts encode domain knowledge as first-class Locke configuration with structural determinism that survives the Python boundary, and a Str-to-Float auto-promotion fix that unblocks three detector families on numeric columns CSV readers mis-type. Five commits, two ADRs, 71 new tests, 25 Rust crates + a Python wheel published. The discovery-driven nature of the work — each step uncovering the next gap — is the secondary headline.
Validating UCI Adult with Three Tools: What Locke Catches Out-of-the-Box That Pandera and Great Expectations Don’t
Three tools, one dataset. UCI Adult (synthetic clone, 5,000 rows × 15 cols, deterministic seed) goes through Pandera, Great Expectations, and Locke with each tool’s default configuration. Locke’s report fires 32 findings without any expectation file or schema — the ‘?’ string sentinels (E9007 + E9008), the redundant education-num label encoding (E9023), heavy-tailed capital gains (E9024), edit-distance near-duplicate categories (E9082), and seven other quality signatures the other two miss on defaults. The post also walks Locke’s complete capability surface — the belief-score algebra, the lineage/audit chain, the streaming validator, the policy gate, the causal guardrail, byte-identical JSON across runs — from the new Python wrapper. Includes the full data-generation script, the Locke run, the actual finding output, and an honest critique section naming three places where the adoption story currently needs more concrete demos, richer notebook UX (Arrow/Parquet/sklearn integration), and tighter pairing of every philosophical claim with a measurable engineering capability.
Diabetes-130 Revisited: ABNG Climbs Into the Strong-Model Band — and an Honest Account of What Locke Did (and Didn’t)
?-sentinel detector gap; proposed E9064) but did not directly drive the AUC headline. The handoff’s flagship ‘Locke prune → AUC up’ hypothesis falsified itself — and that’s its own publishable finding.
Phase 0.10 returns to UCI Diabetes 130-US Hospitals with both ABNG and Locke. Tuning K_ROUTING=2 + stronger BLR prior + the full 101,766 rows lifts held-out test AUC to 0.6645 ± 0.0018 across 3 seeds — in the strong-published-model band (0.64–0.68) without any architectural change, still on the linear BLR head. The route the handoff predicted to get there (Locke surfaces leakage → drop death-discharge rows → AUC up) did not work — Locke’s E9063 detector didn’t fire on the per-level leakage, and applying the prune via domain knowledge hurt AUC by 0.0118 because it shifted MI-selected routing features. Five commits, every chain head reproducible, six section outputs, a published role-by-role assessment of where each tool actually helped.
Locke v0.1.10: An Epistemic Layer for Data Validation
Locke is a deterministic, content-addressed data-skepticism layer for CJC-Lang. v0.1.10 is live on crates.io. Every finding carries structured evidence, assumptions, and suggested next checks. Reports are content-addressed so CI runs can diff them byte-for-byte. This post positions Locke against the four adjacent tools (dbt, Pandera, Monte Carlo, Great Expectations) using a five-layer model of the data-quality stack, walks four concrete scenarios with actual JSON findings and a Mermaid lineage graph, includes adversarial side-by-side examples where ordinary tools see nothing, formalises the meet-semilattice algebra under which BeliefScores compose, and includes a 275× speedup benchmark against GX on a 7023-row synthetic churn dataset.
Gibran: Windowed CTEs and the Row-Filter Fix You Can’t See
An update to Gibran’s governed metric layer: a lazy-loaded chart layer, an ad-hoc top-N-per-group question shape (windowed CTE), and a row-level-security fix — the policy filter now composes with CTE queries (cohort retention, funnels, per-group ranking) under row-filtered roles.
Qalam: A Deterministic Arabic Morphology Engine — and a Way to Learn Arabic
Qalam is a deterministic Arabic morphological analyzer I’m building in Rust. Today it reliably normalizes, tokenizes, and frequency-counts any Arabic text, and does real morphology — clitic splitting and root extraction for strong AND weak roots, with explainable confidence — but only for the ~99 roots in its bootstrap lexicon, about a quarter of words in arbitrary text. It’s bit-identical across Linux/macOS/Windows. It is NOT finished: no large lexicon, no syntax, no dialect, no measured accuracy yet. And honestly, half the reason it exists is that building it is teaching me Arabic.
Green by Construction: Thermal Bounds Without Losing a Bit
A three-phase green-compute layer for CJC-Lang: a Runtime Policy Layer (thermal profiles, deterministic energy estimate), race-to-idle adaptive scheduling that recovers burst performance while keeping a sustained thermal bound, and fused elementwise kernels that cut memory traffic. The connective tissue is one guarantee — thread count, pool size, and schedule provably never change the answer — which is what makes an adaptive thermal scheduler safe in a deterministic language. Every number below was measured on the branch.
ABNG on Real Clinical Data — The Diabetes-130 Readmission Task
ABNG — the Adaptive Belief Network Graph — applied to UCI Diabetes 130-US Hospitals, a real, heterogeneous, class-imbalanced clinical benchmark (101,766 hospital encounters; 30-day readmission). Held-out test AUC climbed 0.550 → 0.587 → 0.611 across data scale and a validation-only hyperparameter sweep; post-hoc Platt calibration then moved Brier and log-loss from worse-than-base-rate to better, with calibration error dropping to 0.010. Crucially, none of ABNG’s core architecture changed — the gains came from a leakage-free evaluation protocol, configuration tuning, and harness-side calibration, and determinism + auditability held throughout because the core was untouched. Honest, modest, fully reproducible.
Gibran v0.1.0: Natural-Language Analytics Without an LLM
Gibran v0.1.0 ships 26 NL patterns + 25 metric primitives + 4 engine adapters + a local HTTP UI — and a structural guarantee that the natural-language layer can never fabricate metric or column references.
ABNG: Treating Belief States as First-Class Citizens
Part 1 of a three-article series on ABNG, an experimental Adaptive Belief Network Graph. This piece covers the architecture itself — what it is, how routing and Bayesian inference and structural adaptation fit together, where it sits in the modern ML landscape. The follow-ups cover the determinism / audit story (Part 2) and the empirical evidence (Part 3). ABNG is a prototype; CJC-Lang is a research compiler. Both pre-1.0.
ABNG Benchmarks Part I — Deterministic Belief Evolution, Lineage, and Explainable Inference
Part I of a two-article benchmark deep-dive on ABNG. This article covers the five benchmark categories where ABNG’s properties can be proven correct at the tested scale: determinism (replay invariance under graph mutation, 2.40x Kahan summation overhead), lineage (cryptographic audit chain detecting single-row dataset tampering, scaling cleanly to 1M events), state stability (NIG posterior converges 1/sqrt(n) to known truth), probabilistic consistency (graph-level ECE = 0.015 on synthetic Bernoulli; predictive coverage within +/-0.01 of nominal at 5 confidence levels), and explainability (10x error reduction by abstaining on high-OOD predictions). Eight experiments measured on real hardware: alpha (posterior consistency), delta (replay-under-mutation), eta (per-bin reliability), gamma (selective prediction), zeta (Kahan vs plain), kappa (predictive coverage), lambda (per-op statistical CIs), mu (audit log scaling to 1M events). The companion Part II covers adaptive graph evolution, routing behavior, and temporal state dynamics.
ABNG Benchmarks Part II — Adaptive Graph Evolution, Routing Behavior, and Temporal State Dynamics
Part II of a two-article benchmark deep-dive on ABNG. This article covers the four benchmark categories that make ABNG architecturally distinctive: routing efficiency (10K observations distribute across 8 codebook bins, peak matching input mean), memory scaling (decide_step sub-millisecond at all tested graph sizes through n_active = 256), adaptation (six structural actions firing under quality-gated conditions), and temporal dynamics (drift-trip auto-unfreeze restoring learning under distribution shift). Four experiments: beta (basis-not-in-span PINN, surprising piecewise-routing robustness), epsilon (decide_step scaling), theta (routing-flow Sankey), iota (2-D OOD heatmap separating training region from corners). The companion Part I covers determinism, lineage, state stability, probabilistic consistency, and explainability.
Deterministic and Auditable Neural Systems
Part 2 of a three-article series on ABNG. Most ML training is not replayable bit-for-bit. Two runs of ‘the same’ code on ‘the same’ data produce two different artifacts. This article walks through ABNG’s SHA-256 audit chain mechanism — every state mutation appended to a hash-chained log, replayable from a serialized snapshot, three-signal spoof detection — and is honest about what the determinism premium costs (~87% of per-training-step time is dispatch + audit overhead, not Bayesian math). For engineers in regulated ML, scientific replication, and any setting where ‘why this output?’ needs a paper trail.
ABNG — An Experimental Adaptive Belief Network Graph for CJC-Lang
ABNG (Adaptive Belief Network Graph) is an experimental cjc-abng crate exposing 75 abng_* builtins to CJC-Lang. This post walks through eleven distinct capabilities — eleven demos, six in CJC-Lang source — and what each one actually proves. Plus the honest gaps: ABNG is still experimental, the interpreter is a known bottleneck, and there’s compiler/interpreter work ahead before this becomes production-grade.
TidyView v3 and the D-HARHT Memory Engine
v0.1.7 ships TidyView v3 (twelve phases of incremental optimization to the data engine) and a new family of deterministic collections including the D-HARHT Memory profile — a sealed lookup table that matches std::HashMap’s speed while keeping byte-equal iteration order across runs. This post walks through every phase, every benchmark, and the honest gaps.
The cjcl CLI: 30 Commands for Deterministic Computing
A practical reference for every command in the cjcl CLI — from basic compilation through data pipeline tooling to deep compiler introspection. Includes flags, examples, and real workflows.
TidyView: A Database Engine in Disguise
TidyView is CJC-Lang’s data manipulation system. It uses a tidyverse-style API backed by database-engine internals — columnar storage, bitmask filtering, predicate pushdown, and zone maps — to deliver deterministic, auditable data pipelines with zero hidden mutations. Includes worked examples, audit walkthroughs, and a 38-test benchmark suite proving every architectural claim.
Chess RL in CJC-Lang: Training a Chess Agent from Scratch with Zero Dependencies
A deep technical walkthrough of building a chess-playing reinforcement learning agent entirely in CJC-Lang — a numerical programming language written in Rust — with no PyTorch, no NumPy, no Stockfish, and zero external dependencies.
Syntax Guide for CJC Version 0.1.1
The complete syntax guide for CJC-Lang v0.1.1 — covering core language constructs, 287+ builtins, the dual-engine compiler pipeline, quantum simulation extensions, and deterministic numerical computing.
CJC-Lang v0.1.0: The First Public Release
CJC-Lang v0.1.0 is live — 20 crates, 282+ builtins, two execution engines, and deterministic-by-default numerical computing. Here’s what shipped.
Neural Networks in CJC-Lang: From MLPs to Attention, Without a Framework
A walkthrough of the neural network architectures implemented and verified in CJC-Lang — MLP, REINFORCE, PINN, PIML, CNN, and attention — all running deterministically.
Introducing CJC-Lang: Why I’m Building a Deterministic Scientific Computing Language
A deep dive into CJC-Lang — a deterministic scientific computing language built from scratch in Rust.