About

Based in Melbourne, Australia.

Algorithms

  • A push notification pipeline on public data: two-tower recall with a faiss index, coarse and LightGBM fine ranking, uplift models, and a delivery policy for send, time slot and copy.
  • Off-policy evaluation (IPS, DR) checked against a known answer on the Open Bandit Dataset; on the full campaign no estimator passed with the registered intervals over impressions, so the project reports no result that rests on one. Post hoc, over ten-minute blocks, the intervals of both contain the known value, and the registered verdict stands.
  • A simulator fitted on KuaiRand random exposures, with results labelled by evidence tier (A real data, B checked estimator, C simulator only). On Duolingo's randomized notification logs, the project's template bandit beats uniform choice by 0.00174 (0.00126 to 0.00221) in two-hour completion per notification (Tier A, resting on the logged template choice being uniform).
  • Comparisons registered before the simulations and reported as they came out, including a pre-registered ranking result that went the other way.
  • A pre-registered recheck of the Open Bandit benchmark: propositions, statistics and decision rules committed before any outcome of the confirmatory campaigns was computed, with one campaign to develop on and two for the verdicts.
  • On the two confirmatory campaigns the published prior is not the distribution the BTS log shows (distance 0.53 against a noise floor of 0.11 to 0.14), and the IPS estimate pooled over them is 0.974 of the on-policy click rate (0.915 to 1.036 over ten-minute blocks): no shortfall is shown, and one of up to 8.5% is not excluded.
  • Post hoc, on all three campaigns: the standard deviation of that ratio with ten-minute blocks as resampling units is 1.31 to 1.47 times the one with rows or impressions.
  • BM25 retrieval in Go, with Lucene's scoring computed from a Bleve index: on six BEIR test sets its nDCG@10 and Recall@100 equal Pyserini's published BM25 numbers to all four decimals, and the run files reproduce byte for byte from committed checksums.
  • Dense retrieval with BGE-base-en-v1.5 on ONNX Runtime and exact search: on six BEIR test sets its nDCG@10 is within 0.0006 of Pyserini's, and within 0.0004 on all but TREC-COVID. Comparing every document vector of SciFact and ArguAna with Pyserini's found 28 documents below a cosine of 0.9999, each holding Unicode format characters that Pyserini's tokenizer removes and the Go library kept.

Projects: push-lab, ope-checks, retrieval-lab.

Server-side systems

  • A recommendation serving system in Go: retrieval, features, ranking and rerank behind one HTTP API, with the user encoder and the ranker run through ONNX Runtime.
  • Item vectors split into shards on replicas over gRPC: a search goes to the next replica when one fails and to a second when the first is slow, at most one hedge per search. With one replica of every shard lost, every response equals the one with all replicas healthy; for a replica that goes silent, this holds within the hedge budget, and once five of its calls in a row have ended at the shard deadline it is left out, and tried again with one search a second, while the other replica of its shard answers in time.
  • Model bundles swapped while serving: every replica prepares the new version, activation is atomic, and a version is the digest of its files, checked by the gateway and by every replica.
  • Events through Kafka to an ingest consumer that applies them idempotently; user histories and the result cache on Valkey; while Valkey is down the gateway answers from the request's own items, and a circuit breaker stops it waiting on Valkey once at least half of 100 or more calls in a second fail.
  • Deployed in kind: replicas as a StatefulSet, gateways with an HPA, Pod Security restricted, and a NetworkPolicy whose enforcement CI checks. At 100 requests/s, through rolling restarts of the gateways and of the replicas and a bundle swap, no response failed or was degraded, with stage budgets of 100 ms on one node.
  • Users split between A/B arms by a hash of the experiment's name and the user ID, with an exposure log; rate and in-flight limits that answer 503 at once; OpenTelemetry traces from the gateway's API through each stage to the replicas' searches.
  • A logistic-regression ranker over six features, whose bundle carries golden features that the gateway recomputes at load. On 680 held-out users its recall@10 is 0.091 against 0.026 for retrieval order, measured before MMR, and its weight on the vector score is negative.
  • A CPU profile at 400 requests/s put 54% of a replica's CPU in the inner product of exact search. Rewritten in AVX2 with a fixed order of additions, it takes 4.2 to 5.4 times less time, and p99 at 400 requests/s fell from 6.90–7.79 ms to 4.27–4.64 ms; at that rate the gateway's CPU per request is not resolved on this machine.

Project: recserve.

Backend systems

  • Limit order book matching engine in Go: price-time priority, REST and WebSocket APIs, a bounded queue per symbol; new orders and cancels get 503 when it is full.
  • Durability by a write-ahead command log, fsynced every 10 ms on a background goroutine, with a crash test that kills the engine under load.
  • Price levels in a red-black tree chosen by benchmark over a skip list and a sorted slice (250 ns against 405 ns at 10,000 levels).
  • Open-loop load generation with scheduled send times, so a stalled server is charged the delay; a run counts only if every trade reaches the client once and in order, checked by sequence numbers and 64-bit hash sums.
  • CPU profiling that moved the work away from the book: a JSON key check from 5.79 µs and 79 allocations to 0.51 µs and none.

Project: matching-engine.

Earlier projects

Tools

Go, Python, TypeScript. gRPC, Kafka, Valkey, ONNX Runtime, Kubernetes, Prometheus, OpenTelemetry. React, FastAPI, Electron. SQLite, SQLCipher 4 format, DuckDB, Parquet. Web Crypto, Argon2id. LightGBM, faiss, NumPy, Bleve. GitHub Actions. This site: Astro and hand-written WebGL2 and GLSL.

Where the work sits

My work is algorithm engineering and server-side systems, with backend development next to them. On the algorithm side: recommendation models and off-policy evaluation, where comparisons are registered before the results and reported as they came out, including a ranking result that went the other way and a benchmark shortfall that the confirmatory campaigns did not show; and retrieval, where BM25, exact dense search and fusion are each accepted against a published number. On the server side: a recommendation serving system checked under load through rolling restarts and a bundle swap. Every number on this site traces back to a project repository.