Live data from Hacker News

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

engineercodex.substack.com

111–120 of 302 posts

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

#111
post #30

Earlier quoted context omitted.

"Readable" and "misleading" are subjective, and depend on the person's "preconceptions". I disagree that the reviewer comes "without as many preconceptions" - they just come with different preconceptions, the ones they're used to. Programming language is a language like any other, and each person has their own style of writing it, and they'd prefer the rest of the world to use their own style because it's "more reada…

Are you saying there is no such thing as clearer or less clear writing in natural languages or programming languages? It's 100% subjective and depends entirely on the reader?

I believe overtly verbose, enterprise Java names make code _less_ clear in modern times with proper development tools.

Entire group of people has to think otherwise due to proliferation of that style.

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

#112

Earlier quoted context omitted.

This kind of greedy optimization approach is fine if all you’re just trying to maximize velocity, but it starts showing cracks on a long enough timeline in sufficiently large or complex projects. Speed without alignment on direction leads to ugly, tangled messes. As with most quality issues, the key is to try and surface quality problems as early as possible. Finding a bug in prod is worse than finding it in PR is wo…

MRs are bad place to align things at scale.

They should be a last resort for that sort of alignment, but it's still important to pull that last resort if it's necessary, so you don't end up like Cloudflare and let your own standards slip so badly that you end up with a 100% preventable multi-day outage.

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

#113

I generally like the tool. When your code review tool is really nice one unexpected negative is that it can create a culture of nitpicking. Sometimes it’s not worth arguing over small details like variable naming but the tool makes it really easy for things to head in that direction. Sometimes variable naming isn’t a small detail. But sometimes it is and it’s a waste of everyone’s time to argue about it.

Excessive subjective feedback can be soul-crushing.

Unlike excessive objective feedback?

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

#114

critique is a worst tool I have ever used. example 1: - a engineer caused multi-million dollar loss in ad revenue due to change which passed review with flying colors. and he is the only engineer whose name ever put in a post mortem document. - same engineer few months before this incident forced a junior engineer to waste 2 months by making him to stupid nit picks. after a month of addressing nit picks, the junior e…

I don't see how examples 1 and 2 are related to Critique. Then example 3 exhibits a tenuous link to the topic but it's unclear how exactly this problem is specific to Critique.

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

#115

Google could easily release a GitHub competitor. But they don't. Similar to how they invented and failed to popularize the LLM. It's like the company is run by both geniuses and clowns.

They had Google Code. I think it might have first been deprecated before Critique was popular (the prior code review tools at Google weren't quite as beloved). Also since then, buganizer was made partially public facing. It sounds silly, but they could relaunch a software forge suite and it would almost definitely be better than GitHub, and they could cross sell cloud and probably not even have a free tier.

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

#116
I don't really see anything miraculous here, other than "GitHub PR review UX sucks in comparison". Things like AI help and extra linters etc. are something that a each project has to figure out on their own, and e.g. I maintain projects that use Nix dev shells to optimize and streamline the dev experience by a lot, even before things hits the change review stage.

Github's PR review flow just breaks down for anything non-trivial. People have been complaining about it for years and suggesting a lot of relatively low hanging fruit improvements.

The rest is about the culture of CRs some of which could benefit from built-in support, but some doesn't need it.

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

#117
post #60

Earlier quoted context omitted.

But "another team is relying on not to move" is an objective point, right? Things like "I find this code very hard to follow, and I think it could be made easier" is also objective, and even "I don't understand what this variable name means, and I think it could be clearer". I once names a function mkdir(). This created a directory tree. In the review it was called "obscure" so it became createDir(). Then someone poi…

I'd wonder what the rest of that API surface looked like. If the rest of the functions were longDescriptiveCamelCase() and then you tried to slip in mkdir(), then I'd say yes, "stylistic consistency" was gained during that unnecessarily difficult back-and-forth. If the other functions were chdir(), remove(), rmdir() and so on, and somehow the reviewers picked your code change as the time to change it all, then yea, w…

It was a mix of short and long and there wasn't really much "style". The company had taken over the maintainership from someone else at some point (before I joined) and it was all fairly inconsistent. I don't really mind the inconsistencies as such, it's just the argueing over nothing that I mind.

This kind of stuff was typical. At some point there was a lengthy discussion which prevented rolling out a rather important hotfix over:

  while (true) {
    if (someCond()) break;
    if (otherCond()) break;
    [..]
  }
It wasn't even about whether someCond() and otherCond() should be in that while(..) condition, it was allegedly "dangerous" because it "could loop infinitely". Well, ehh, that's the case with any lop innit? That's kind of how they work? There was a bunch of instances of code like this, "but it's still dangerous". Hmkay...

Oh, and then there was the great "evil incident". I had rewritten much of the frontend to this newfangled thing called "jQuery" that was all the rage. That was all fine and worked pretty well, but suddenly there was a bug hubhub about the jslint comment; the keyword to allow eval() was "evil" (one of those not-too-funny Crockford jokes), so at the top of /static/js/app.minified.js?v=12311 in prodiction there was something like:

  /*! jslint: keyword1 evil keyword2 */
  /*! MIT license blah blah */
  minified_js()...
And people were up in arms and there was a big panic deploy during lunchtime for this "because customers might see this, and it's highly unprofessional, and it's a big problem we need to fix ASAP" etc. etc. etc. This was in the Netherlands with regular people, not some highly conservative part of the world. It was downright surreal and bizarre.

What I'm trying to say is that these people were rather obsessed with minor details to a point I've never seen before or since. Hell, there was a Company Blessed IDE™ that you had to use. Nothing else allowed. It was a complete piece of shit (IMHO) and after a few weeks I just used Vim. It worked. I got stuff done. No one was bothered by it. Still got comments I shouldn't be doing that...

While I didn't formulate "is this really objectively better yes/no?" clearly at that time, I'm sure it's been a pretty big influence.

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

#118

> Developers need to make progress; overly difficult reviews can discourage future improvements. This, to me, is the most important aspect of code review: get out of the way . If you are putting in nit picks, asking for changes that aren't related to a bug or bad architecture choice, etc, then get out of the way. If you are holding up the approval because you want someone to rewrite the code the way you would have wr…

This kind of greedy optimization approach is fine if all you’re just trying to maximize velocity, but it starts showing cracks on a long enough timeline in sufficiently large or complex projects. Speed without alignment on direction leads to ugly, tangled messes. As with most quality issues, the key is to try and surface quality problems as early as possible. Finding a bug in prod is worse than finding it in PR is wo…

Long-term project health rests on bigger things like API design, database choices, or service layout.

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

#119
post #9

Satisfaction with Critique among Xooglers is undoubtedly driven by dissatisfaction with GitHub PR reviews. GitHub reviews are astonishingly bad. The tool is utterly useless for actual reviews. After the first round of comments it becomes total chaos. Nobody can tell what's been said, done, changed, or resolved. It is impossible to believe that the people who write and maintain the GitHub PR tools have themselves ever…

I get the same feeling when switching between Gitlab and Github. The latter is a joke of usability and discoverability. Tiny details like thread filtering, thread replies not appearing as separate comments, "show changed lines" when a new commit modifies the subject of a comment, etc. Those add up to make gitlab much more usable.

It's funny, because GitLab feels pretty bad. It's slow, there are weird places where things require a full page reload, and it's extremely aggressive about hiding files that have significant changes (yes, small changes are better, but I still need to review big ones some of the time).

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

#120
post #18

Are there any examples of successful organizations, maybe even with SOC2 compliance, that don't have code reviews? From my research, I think Netflix might not have them, but I'm not sure.

Instead of gating at review time, an org could gate at deployment time to achieve that SOC2 compliance.

It appears that Netflix does do CR: "Netflix uses a feature branch workflow, where developers create new branches for each feature they're working on. These branches are then reviewed through a pull request process, where other developers can review the code and provide feedback" [1]

[1] https://medium.com/@seyhunak/learning-best-practices-from-ne...

Post reply on HN