TruthInTheFlip: Six Commits Toward a Better Shape

I just pushed a substantial refactor to TruthInTheFlip.

It took six commits, and while part of it began with practical needs around drift and telemetry, the deeper result is architectural: the project now has a better shape for composing strategies and their parameters.

On the surface, this may look like command-line cleanup. It is more than that.

As a tool grows, hardcoded option handling starts to become friction. Every new feature wants its own parsing rules, defaults, validation, help text, and eventually its own relationships to other options. That works for a while, but after a certain point the code starts reflecting the accidents of growth instead of the real structure of the system.

This refactor was about correcting that.

At the center of the change is DelegateMethodRegistry. Instead of treating strategies as scattered parsing cases, the registry gives them a common form: a method, a name, help text, typed parameters, default values, and version metadata. Parsing now produces an explicit parse result rather than leaving the registry in a vague “last configured” state. That makes configuration something the program can reason about directly, not just a side effect of option handling

The more interesting part is that registries can cooperate.

A parameter type can now have its own handler. That means one strategy can accept another structured strategy as an argument, and the parser can resolve it recursively. In practical terms, the command line is no longer just a flat list of switches. It has become a composable configuration surface, with structured parsing and structured reporting behind it

This is no longer just used in one place.

The new structure now carries the upgraded layout for -window, -rsource, and -anticipate. That is what makes this refactor satisfying to me: the new abstraction did not just reduce duplication, it proved itself immediately by supporting multiple feature paths under the same model.

Part of this work grew out of the need to deal with scale honestly. When you start thinking in terms of very large runs, lifetime aggregates can smooth over behavior that is still worth seeing. The view window work was one answer to that. But once that was in motion, it became clear that the surrounding option model needed the same kind of clarity.

Window strategies, random source strategies, and anticipation strategies are all examples of the same deeper pattern: named, described, version-aware methods with typed arguments and defaults.

That pattern deserved its own home.

So this refactor was really about extracting the right home for it — and then proving the result by carrying the next features over to it as well.

I like refactors like this because they do more than tidy code. They improve the honesty of the system. A thing that is really a registry should be a registry. A parse result that has meaning should exist as its own object. A typed strategy should not have to masquerade as an unstructured string until the very last moment.

That is the direction here.

TruthInTheFlip is still about putting randomness under scrutiny. But now the tooling around that scrutiny has a better internal structure — one that is easier to extend, easier to reason about, and more faithful to what the program is actually doing.

The bit drought is over.
The quest for truth in the flip continues.

A line I especially like for this version is:

Good systems do not just grow. At some point, they clarify.