A study of Google's code review tooling (Critique)

Now, finding somebody with authority to approve is a constraint of code review. But that would be true of any code review tool. So it's not really fair to complain about.

With the crazy interview process, the copious static analysis and formatting tools and style guides + style enforcement tools, and with OWNERS and team members reviewing things... what is even the point? What are they actually checking for?

Back when I started there, I got my C++ readability quite easily with just a month wait or so. Then I briefly worked with a bit of Go, and encountered my first taste of the incremental process, and it.. sucked. When they rolled out incremental readability, I never bothered with any other languages.

Luckily, later, I ended up working in the Chromium tree which required no such readability status.

If someone has legitimate concerns about the design decisions made, then they should voice them. However if they are refusing to adhere to guidelines, simply because they dislike the approach then that's being overly problematic.

The reality is that this kind of survey is a) self-selecting for the people who adapted well to Google's process, and b) not really measuring for productivity, just satisfaction with tools and some aspects of the (assumed given) process.

What I personally found is that Google is the kind of place where you can only truly be productive if you have the kind of brain that can fork off N work tasks at once and then fork/join on all of them.

If you're the kind of person that does better when going down the whole mineshaft on one problem at a time, you'll be screwed. Because you'll be constantly spending the bulk of your time sitting waiting for review approvals, or getting your account added into some ACL somewhere, or getting sign-off on a PRD or design doc, launch / security approval, or some other form of coworker approval. The only way to make progress is to do a bunch of those kinds of things at once and juggle between them.

After 10 years of battling it, I realized it's not for me, no matter the $$.

(There are some other things that Google does exceptionally smartly, though. The monorepo and the way they handle third party deps [check them in and only allow 1 version for whole company]) I think is one. Both of these things seem crazy at first, but they are amazing at minimizing whole classes of complexity around versioning and dependencies that add mostly needless overhead to the job of engineers)