> Turns out there was zero difference, or negligible (Windows won), between compilation times.

I think there was something seriously flawed in your test. If you Google for a minute, you find multiple posts on how moving the same builds to Linux led to performance improvements in the range of 40% drops in build times.

Some anecdotes even compare doing the same builds in Ubunto with NTFS to see double-digit gains.

NTFS is notoriously awful in scenarios involving reading/writing many small projects. This is the bottleneck in Windows builds. There is a myriad of benchmarks documenting this problem.

Nowadays there are plenty of cross-platform projects to serve as benchmarks. Checking this can be as easy as checking out a project, start a full rebuild, and check how long it takes.

NTFS can be especially awful if you're used to Linux behaviour, port code over to Windows and expect the same performance.

Here's a talk on porting rustup to Windows: https://www.youtube.com/watch?v=qbKGw8MQ0i8

To begin with, it takes rustup 3m30s to install on Windows. After rejigging the code again and again away from its naive implementation which works fine on Linux, to perform sympathetically towards NTFS, it takes the same rustup 14s to install. That's quite a performance gain! But it needed a lot of changes to rustup, and to Windows itself.

Yeah you can work around the filesystem perf problems on Windows to some extend. Unity builds are not just popular because it reduces duplicated compiler work but also because it reduces filesystem access. There is a reason why Windows games tend to pack their assets into archives.

That's survivor bias. Fewer people blog about unsuccessful initiatives.

> That's survivor bias. Fewer people blog about unsuccessful initiatives.

I don't understand what point you're trying to make. Should we give equal credit to unsuccessful initiatives when their failure is due to screwing up a critical part of the project?

I mean, the successful attempts document what is possible. What do you expect to report when you couldn't even manage to get something working?

Say there are N initiatives to move to cross-compilation. Of those, there are M that deliver the hoped-for benefits, where M <= N. But practically, M < N significantly, say, M < 0.9 N.

Assume bloggers blog mainly about content that contains a positive message. I'm asserting that people blog more readily about their success than their failures.

So when you look at the blog literature, your population is not N, it is M. You don't see the failures because they don't tell the tale.

It seems possible that their pipeline just had large files, or something like that.

Java/dotnet pipelines don't have Windows penalty. Both have dependencies as compiled modules zipped into large jar/dll. While even simple node project have 10s of thousands of files inside node_modules folder.

For the most part the two are pretty equivalent in performance, it's particularly constant blocking on small file IO where Windows falls way behind. Also a bit in the "tons of cores" and "tons of networking" categories but not as nearly as bad as small file IO.

Well yeah, if you avoid the OS (syscalls) as much as possible then all operating systems will have about the same performance.

Love that your boss was open to the idea but also wanted data to back it up. (imagine a slow clap)

A single datapoint from an experiment done by only one person you call it data? What's not to love...

It was the only data point which mattered for the decision that needed to be made.

Yep, was a good experience. I'm sure with fine tuning it (Linux) could've been better, but I ate that humble pie.

You can't have windows laptop without running a ton of Antivirus and other crapware .e.g MS store, HP/Dell diagnostics and MS Teams. If you factor that in, Linux will win everytime.

If your company has windows and Linux but only guards against threats on windows, then you may have a different problem.

I believe you can lock a Linux box down tighter than a windows box, but then you're trading compile times for other costs.

Not the case unfortunately; you can. I'm not defending Windows here (bitter hatred of Microsoft here, since they started charging 2k for the compilation tools back in the 90s).

In your particular corporate environment that might be the case, but not in this case, I had free run of a fresh install and no offensive AV there, and detuned to remove the crap.

Other posters have said certain optimizations (which I'm not sure would help, it was pure compilation, no large files that I'm aware of). Just saying, always good to keep an open mind.

Were all your tests pure unit tests? Then sure—the OS isn’t getting in the way (and if your Linux distribution didn’t set the correct cpu scheduler, windows could be faster!)

If, however, your tests make any filesystem calls or fork a child process, there’s slim chances that Linux doesn’t absolutely trounce Windows.

To throw in a morsel of anecdata: same laptop with a dual boot runs the PhotoStructure core test suite (some 11,000 tests which have a pleasing melange of system and integration tests, not just unit tests) in 8m30s on Windows 11. Almost all the same tests complete in 3m30s on Linux.

Seems weird to base the argument on compiler performance alone. I'd think that developer tools will be a much bigger factor for the time difference but that depends on what you are used to.

Anecdotally though, git is unbearably slow under Windows and compiles make all filesystem operations lag while I have never seen such problems under Linux.

Yeah sorry, I left out a lot of details for a quick anecdote. It was Java compilation, so the different JDK's may've made a difference (almost certainly). But I figured the better file system handling etc etc would've gone in favour of Linux, versus Windows.

In any case it wasn't much of a fun codebase. But I think a good lesson was, always test it, always measure. Not casting shade on either OS.

Do you remember which file system you used on Linux?