My name is Petr Balvín. I design processor cores, write language tooling, network protocols and scientific libraries; the work runs from silicon to theory. What I claim, I measure, and what I deliver has to stay readable without me.
Four rules the rest of this site grows out of: they decide how code is
written here and how results are judged.
The scientific method as the base
The material decides, not the impression. When what is required and
what the material permits pull apart, the design starts exactly there;
that is dialectical materialism in daily practice. What has proved
itself holds until the day something better turns up.
The standard library as discipline
I cannot take someone else's code on trust, because I have not read
it and I do not answer for it. So the part I really need, I write
myself; the standard library carries most of a project meanwhile.
Measurement as the only judge
Performance, power draw and correctness are proven by measurement, whether the subject is silicon, code or a protocol. An estimate is written down as a hypothesis, together with the procedure that would refute it. When a claim has not been
measured, I do not make it.
The whole output as one artefact
Code, documentation, tests and measured numbers form one whole and
ship together. The measure is plain: in ten years the project has to
be readable, buildable and takable over without me.
Research lines
Directions I have followed for years. Every public line heads for an
artefact anyone can pick up and run: a tool, a service or a library.
Systems code in Go
Core protocols, numerics and toolchains have been written in C for so
long that nobody so much as chooses it any more. The question I am
testing is whether pure Go delivers the same reliability; an NFSv4.2
server and client without a single dependency has already stood up
against the Linux kernel.
Same input, same number, every machine. In numerics that is not a
given, but Tensor holds it in Go, without cgo. The next step is
spreading a computation across machines so the result stays
reproducible.
The Plan 9 assembler is imprisoned inside the Go toolchain and has
no tools of its own. I am pulling it out: one binary holding a
formatter, a debugger and a language server for four architectures,
its accuracy verified by differential testing against the Go
toolchain.
The modern web is written through a bundler, a transpiler and
hundreds of packages. I am testing whether the platform suffices
on its own: the proof is this site, two language editions and
zero dependencies, built with JSbox.
Reports from repairs and measurements: what failed, why, and what
came of it. Every text carries the procedure and the data, so you can
check the result yourself.