I write Rust and C++, mostly low level systems where correctness and latency pull against each other. I like measuring exactly what that costs.

C++ EVM log parser at a DeFi terminal. Multi chain, real time. Single producer WebSocket ingestion, tx level worker parallelism, SPMC queue.

Quant research and the Rust execution stack under it, on Polymarket. Sub 100ms market-state detection, isolated failure domains, kill switch.

crackeddb: embedded OLTP engine. Serializable; SSI specified in TLA+ and machine checked; every source of nondeterminism behind one trait, so a bug from a seed reproduces byte for byte. The only backend in its own benchmark that detects write skew. The mature engines are faster and commit the anomaly.

gavel: single threaded exchange matching engine in C++23. The sequenced input stream determines every output byte; the output hash comes back bit identical across O0, O2 and O3. Checked against a real NASDAQ trading day, about 91,700 executions, zero displayed price priority violations. p50 around 83 ns.

caliper: tick to trade latency lab measured two ways that bracket the path. AF_XDP kernel bypass isolates the userspace reaction at 70 ns across decode, book, decide and encode. Real NIC hardware timestamps over two hosts, an Intel i210 PHC on each side of a vSwitch, give a true wire to wire of 28.6 us at the median, and the gap between the two is the kernel and NIC tax that AF_XDP exists to skip. Every percentile corrected for coordinated omission against a paced grid, hardware tx stamp yield 100 percent over 2.08M real NASDAQ orders.

vincr: the propagation algorithm under Jane Street's Incremental, modeled in Lean 4 and proved consistent with zero sorry, then differential tested against janestreet/incremental. Verified work in this space proves the update functions and leaves the engine, where the bugs actually live, outside the proof. These proofs are engine level.

deja: record, replay and statistically compare LLM agent trajectories. rr for agents, with error bars. On a 26 task Claude Code benchmark, eyeballing the mean delta calls a false winner 60% of the time comparing an agent against itself; a correct paired test holds it to 2.8%. Replays a session with the network dead and localizes any divergence to the exact field that moved.

apex: minimum lap time simulator and racing line optimiser, every number checkable against closed form physics. Calibrated to Verstappen's 2023 Austrian pole lap it predicts 64.69 s against a real 64.39 s. The solver is differentiable in JAX, so it rediscovers real F1 setup practice on its own: minimum wing at Monza, maximum at the Hungaroring.

stopwatch: recovering a sub nanosecond duration from a 24 MHz clock that cannot see one.

binding-ladder: measuring what it costs to push an invariant from a comment down to "wont compile." Compile time grows roughly quadratically; runtime stays at zero.

Also: urduclang (write C in Urdu script), c-os (RISC-V kernel), rust-file-sync.

dune

ocaml/dune#15017. cram's path tokenizer split at the first space, so a project path containing one left the absolute prefix unsanitized; fix matches the build path prefix map sources literally.

ocaml/dune#15016. under --error-reporting=twice the deterministic error list ran into build output with nothing marking its start; added a separator before it, suppressed when there are no errors.

mistral.rs

EricLBuehler/mistral.rs#2170. traced an engine panic to an unwrap on a best effort send that fired when a client disconnected mid request.

yahyaehsan.dev · yahyaehsan137@gmail.com · Amsterdam