Good luck even getting a google3-based Hello World to compile. I don't remember the exact numbers, but just #including the most basic libs resulted in a O(100M) binary.

And anything more complex than that would probably have dependencies on so many fat client libs, so much infrastructure, and so many external services, that you'll need months-years to even make sense of them, let alone mock them up.

-1: as an ex-googler, I can say it was hard enough for Google itself to get its code to run, given gonzo infrastructure assumptions, proprietary libraries/languages, etc.

That speaks volumes of the code quality @ Google.

sorry, but that's not how code works. It's true that code quality could be terrible but in fact Google is famous/notorious for extreme code review at the line-by-line granularity, plus comments, design docs and more.

The real issues are (again) in dependencies and complex tooling. You can have beautiful code and then in the middle of it, an ML inference call that assumes a crazy ML model and set of hardware to run it on.

If your core logic is so dependent on environment state that it's impossible to get subsets running within multiple weeks of fulltime work then it's bad quality code.

Even just decent quality code keeps side effects isolated to the application fringe as much as possible.

It's a tradeoff.

Google has no incentives to allow an arbitrary component run standalone. Quite the contrary.

What they do get in return for the coupling is that they can evolve the common libraries and code patterns across the board (there are even automated code refactoring tools that help you do massive code changes, automating code review sessions across hundreds and hundreds of teams, with all changes tested against all reverse dependencies etc etc). All this allows for a level of internal code quality that is hard to see elsewhere.

Unless you really care a lot about that one requirement you seem to care about. In that case, yeah, you'd choose a different tradeoff.

Assume you got source for a game written in a proprietary game engine. If you don't have access to the game engine itself, nor the API documentation, etc, how long will it take to get this game running in your manner of choosing?

The infrastructure in these companies is a huge amount of scaffolding that's non-trivial to replicate.

Arguably it's not low quality code, but low quality system. Code can be correct, clear, and documented, and still be fragile and sensitive to platform configuration changes. E.g. "how many switches do I have to change in the build system before the code no longer builds?", "how many network jacks can I move this server over before I lobotomize the system?"

You ought to be able to arrive at the same conclusion, then, with these LLMs. Without arrays of GPUs, it would take thousands of years to train one. Without a corpus of billions or trillions of words, one would produce output of very limited utility.

I think you have to consider that some things are systems, and it is the assembly of their components that imparts the true quality.

It's not poor code quality to depend upon available dependencies.

The effort to open source tensorflow was at least a person year worth of work to extract it from google3. Required reimplementing a bunch of stuff.

This is just wrong.