Backend engineer. Go in production for about three years, at Ozon and at MTS Web Services, where I work on the pricing and offer platform. Before that, C++ at Yandex: multithreaded gRPC handlers and stackless coroutines in the infrastructure that tracks smart devices and delivers notifications to them. Mathematics degree from MIPT.
Now in Grenoble, finishing an M.Sc. in the MOSIG programme at Grenoble INP–Ensimag, graduating July 2027. What holds my attention is the part of a system where the cost is measured rather than argued about: latency, contention, where the data actually sits. I am looking at low-latency and trading infrastructure in Europe.
Almost everything I have written professionally lives in private repositories. These three are the part I can show.
splitr — a split-tunnel manager for macOS whose
kill-switch is fail-closed by construction. The daemon is not the interesting part. macOS
pf resolves a packet by the last matching rule when quick is absent, so splitr installs
a blocking rule in an anchor that sits above sshuttle's own; while the tunnel is up
sshuttle's pass out route-to lo0 sits lower and wins, and the moment the tunnel is gone
its anchor is gone with it and nothing overrides the block. There is no interval during
startup, teardown or a daemon crash where protection has not caught up yet, because the
guarantee is a property of the rule order in the kernel rather than of the daemon's
reaction time. Go, nothing in go.mod but yaml.v3, fuzz tests over the config and rule
builders, and two end-to-end suites that run against real pf.
gitfame — attributes every line of a repository
to whoever last touched it. The cost is one git blame process per file and process
start-up dominates, so files are blamed on a worker pool while the fold stays on one
goroutine and needs no lock. The output is identical for any worker count, which is a test
rather than a claim. It began as an exercise from a Go course; the README says which half
was the exercise.
computational_complexity_project — NP-completeness of the Rural Postman Problem, a restriction on the graph that makes it polynomial, and a C++ solver benchmarked against both.