Why binary distribution is broken
Why installing one tool on every laptop and CI runner is still harder than it should be, and what a registry can do about it.
Duration ·
- Intro · 0:00
- Cold open · 0:36
- Thesis · 1:32
- Arc 1 · 2:04
- Pinned packages · 2:46
- Arc 2 · 3:30
- Drift · 4:13
- Arc 3 · 4:52
- False fixes · 5:41
- The turn · 6:29
- Close · 7:15
- Outro · 8:06
Transcript
How many machines did you put the same tool on this year?
A Mac, a Windows laptop, a Linux runner: three ways to install one tool.
This is the OCX Podcast for engineers who install tools on laptops and in pipelines. I'm Vera.
And I'd push back on that word, Vera.
That's episode zero, why it's still true, and where the fix has been sitting all along.
Monday morning, new hire, new Mac.
The setup doc was written years ago for Windows.
Step one is a Windows installer.
That step doesn't exist on a Mac, so they follow the tool's own docs instead.
A package manager, whatever version it ships today.
Same name, different version, different place on disk.
Half the doc's commands and configs land somewhere else.
Rewrote the doc for my machine. Next hire got a Linux laptop.
The runner takes it from the distribution's packages.
Two years behind, the release freezes versions.
That's the distribution doing its job.
One tool, three machines, three versions.
Everyone did what their platform said.
So why does one tool need three ways in?
The honest answer isn't a bug report.
Getting one tool onto every machine that needs it isn't a hard problem.
And it comes back with every version bump, every machine, every platform again.
So people stop bumping, and if you're the platform team, you can't easily move the version everyone else's projects require.
Every team pays that separately and pays again for the next tool.
Where does it actually get paid then? Installing a tool is one line in a doc.
Every operating system on the team has its own idea of where a binary lives and how it lands on your path.
On Windows, the terminal you already had open never hears about the path change.
You restart both, and by then, it looks like the install failed.
Linux, at least, is one platform.
Linux is where one build stops being one build.
Two C libraries are in common use, glibc and musl, and a binary linked against one won't start under the other.
Two builds then for one operating system.
A team that's been at this a while doesn't live like that, though.
In their own packages with the version baked in, installed the way the distribution installs everything else.
That sounds like the grown-up answer.
It works for whoever then owns it.
Every distribution the runners use needs its own packaging.
None of it reaches the laptops, and installing it needs root.
And it holds one version per machine.
So moving between two projects means reinstalling the other version and hoping nothing else leaned on the one you removed.
That's where dev containers come in, a whole environment per project.
Which helps where teams adopt them.
Plenty haven't, so the laptop still needs the tool.
And a team that pins nothing just takes whatever the CI runner ships.
In early two thousand twenty-five, a hosted CI provider moved its default Linux runner to the next release of the distribution.
The new image shipped fewer pre-installed tools.
So a tool you never installed because it was always just there is gone.
The meaning of latest changed.
For some projects, that runner is also where the release gets built.
The release is built against the runner's GLC, so the runner decides the oldest Linux it runs on.
And less than two years later, that default moved again.
A laptop does the same thing, just without a red pipeline to tell you.
Its package manager keeps its own copy of a language interpreter, and the tools you install through it share that copy.
Because something else wanted a newer one.
Tools you haven't touched in months break.
People love that package manager because its versions are current.
Current and unpinned are one thing.
You find out which one you wanted after the upgrade.
Then pinning through the system's packages is too stiff, and not pinning moves under you.
The project has to pin its own tools.
For a small team, at one version, that means four places, the CI runners, a couple of laptops, and the image the service gets built into.
Each with its own mechanism, a package list, a formula, an archive per platform.
And an image pinned to something slightly different.
None of the four knows the other three exist.
Most teams end up with the honest incumbent, one install script, and all four pointed at it.
Platforms and download links edited by hand at every version bump.
A column for the operating system, a column for the architecture.
And nothing for the C library.
Not which one and not how old.
On an older Linux host, the script says everything's installed, exits clean, and leaves a tool that fails on its first run.
Why is anyone still handwriting that table? There are whole categories of tools for installing things.
Each one's good at its own job, and none of those jobs is this one.
The distributions packages manage an operating system.
A language package manager serves one ecosystem.
And the releases page doesn't install anything.
Build systems have the same problem.
One that needs a tool at a specific version carries its own downloader for every platform it runs on.
What about the version managers that fetch the release file for you?
The ones that pick it by filename break when a project renames its files.
And a publisher that ships through many channels finds each one works for some users and none for all.
So everyone's maintaining the same table.
Why does one tool need three ways in?
Add up what we've been asking for, every platform the team uses, the right build for each host, versions that stay put.
That's the one that narrows it.
Your team runs a system that stores multi-platform artifacts, authenticated, access controlled over TLS. It's the container registry.
One name, a different image for each operating system and architecture.
The industry standardized the box and the port, and the tools inside still travel the old way.
That's not us running our tools in containers.
You already have the infrastructure.
The registry your team already runs is what OCX is built on.
It's a package manager that moves tools through that registry.
A file committed next to the code says which tools this project needs.
You clone it, pull, and the tools are on your path in that project.
The new hire from Monday opens the repo instead of the setup doc.
And gets the version the project chose, built for their machine.
CI reads the same file and the same lock, the same toolchain on the laptop and in CI.
A version bump is one change, reviewed like any other.
Which family, glibc or musl, each host now picks for itself from one index per tool.
How old a glibc the build needs is still set where it's built.
A registry was built to hand images to container runtimes, not a command line tool to a Mac, a Windows laptop, and a Linux runner.
Your registry is already a package backend.