Reviewable Blog

I'm surprised Reviewable[0] hasn't come up in this discussion. It does a great job of allowing stacked code reviews and even handles rebases nicely; the reviewer sees the diff between commit #1 and commit #1' (prime = after rebase). CockroachDB[1] has been using it since very early in the project. [0] https://reviewable.io/ [1] https://github.com/cockroachdb/cockroach

My 2 cents: I run Reviewable (https://reviewable.io), a reasonably successful app for GitHub. It precedes Marketplace so I handle billing directly with Stripe, but when Marketplace recently reduced their fees to 5% I looked into migrating there. The lack of developer control over subscriptions and the painfully long turnaround times with support to get some straightforward questions answered (3+ months!) convinced me that they're not serious about it. Anecdotally, I also heard that the discoverability boost from being listed on Marketplace isn't that big either. Based on my research I wouldn't recommend using GitHub Marketplace in its current state.

What y'all really want is Google Critique. You just don't know it yet, because you haven't experienced it, as it's internal to Google. The closest public product that I could find is http://reviewable.io (no affiliation) which, while it looks weird/amateurish, nails most of the points which make Critique so amazing. There's also Gerritt, but it's too invasive in terms of workflow, whereas Reviewable integrates with GitHub in a more lightweight fashion.

My favorite tool is a Microsoft internal tool called CodeFlow. If you don't want to work for them just to have a great code review experience, I recommend https://reviewable.io . Very nice!

This is one of the features I love about https://reviewable.io.

Since we're talking about GitHub pull requests, my favorite tool for this is https://reviewable.io/. It fixes basically everything about GitHub pull requests.

in that case, you add https://reviewable.io into the mix. now you have GitHub issues managed via a kanban like board, and peer review with everything going through pull requests. the pull request is blocked until review is complete, and tickets are automatically closed with pull requests. it's a pretty great workflow

Yep, I agree! I work at, and use, Reviewable (https://reviewable.io) and we're the best way to review code on GitHub because we've focused on making the whole process better at every step. We've improved diffing, not only for large files (we support larger files than GitHub does) but also for understanding that diff. Have you ever reviewed a PR twice, but the second time around all your comments are gone and you have no idea what happened to the code since the last time you saw it? Unlike GitHub, Reviewable tracks PR's based on revisions, so you can see the diff between the previous revision and the current one, no matter what the author did to the branch to get here. We've also improved commenting. The OP mentions putting a discussion in the sidebar because commenting on the main thread gets drowned out by GitHub's audit trail. With Reviewable, we separate the audit information from the main discussion, so you can discuss the PR, an individual file, or a part of a diff without losing track of or getting distracted away from any of those discussions. We also support pre-approval of PR's that satisfy business requirements at a technical level. This is often taken advantage of by teams that have bots that make certain, software-checkable changes (such as whitespace-only changes), or monorepo organizations with an `experimental/$USER` folder structure.

Reviewable | Bay Area, CA, USA or Remote | Full Time | Generalist / Backend Developer | Typescript | https://reviewable.io/ https://github.com/Reviewable/Reviewable/tree/master/careers Reviewable is a very small, bootstrapped business that sells our code review software to some of the largest companies around. We've been around long enough to be much more stable than your average startup, yet stayed small enough to avoid crippling bureaucracy — everybody reports directly to the founder/CEO. We're engineer-centric and fully remote. However, we prefer hiring US residents and offer the usual benefits: health and dental insurance, 401(k) plans with company contributions, unlimited vacation, etc. We've built a company and a codebase where we enjoy working day-to-day and hope that you will too! We're looking for a backend generalist with a love for problem-solving with algorithms and data structures! Apply at https://github.com/Reviewable/Reviewable/tree/master/careers

I created CodeApprove (https://codeapprove.com) because of my own frustrations with GitHub's code review UI and my experience with far superior tooling inside Google. In the last ~5 years there has been a huge increase in the number of alternative code review tools for GitHub. Some of my favorites (besides CodeApprove, of course): - Graphite (https://graphite.dev) - Reviewable (https://reviewable.io) - CodePeer (https://codepeer.com/) - Codelantis (https://www.codelantis.com/) All of them have many of the things you are looking for!

https://reviewable.io is the earliest full-powered Critique alternative for GitHub. It supports some cool things Critique doesn't/didn't, such as reviewing multi-commit branches (also across history-rewriting force-push cleanups), and indicating exactly the nature of your comment (just FYI, or you want this to be changed before you'll give your approval). (I was an intern in the initial making of Critique, and subsequently got interested in finding an out-of-Google alternative. I contributed a bit to other review tools such as ReviewBoard, and actively used Gerrit, Crucible, Phabricator, and GitLab reviews.) When looking for a Critique alternative for my startup, reviewable.io had just appeared and ticked all the boxes, and we use it successfully for many years. The drawbacks are that it's GitHub-only and isn't free software.

Trunk-based development is still in use at large companies. Usually they use something like Gerrit or Phabricator. You could try tools like https://graphite.dev/ or https://reviewable.io/, or Meta's Sapling + ReviewStack.

https://reviewable.io handles the rebases in PRs pretty well, and is a tool that works with GitHub PRs.

Honestly what i want is for github to purchase https://reviewable.io/ and make it native. Maybe gate sone of the more advanced features behind an opt-in so beginners are not too overwhelmed (and because you probably don’t need them on smaller projects), but the current state of things is just appalling, and more importantly has not at all kept up with workflows on large projects or long / complicated PRs. The complete lack of support for reviewing over force pushes is insane.

Reviewable is another similar review improvement tool for GitHub: https://reviewable.io ...or just use Gerrit[1], which can do everything these do out of the box, and has a much nicer workflow than GitHub once you got over the learning curve. [1]: https://www.gerritcodereview.com

According to the CEO's twitter account [0] they are release better support for dependent PRs this year, track progress of that feature here [1]. The crucial problem with code review on GitHub is that it's 100% dependent on Git to store the history of a PR. This too closely couples what a developer does locally on their machine to the code review process. This in turn means that force pushing drops the history of their "Checks" system, which annotate the PR with CI job an lint/test results. It also means junk commits on PRs make the whole review process more difficult. The app Reviewable [2] works with GitHub and fixes some of these issues if you want to give it a try. 0 - https://twitter.com/natfriedman/status/1170804894241972224 1 - https://github.com/isaacs/github/issues/959 2 - https://reviewable.io

Thanks! GitHub actually does some of these things already. Do these solutions help/suffice? - Batching all comments in a single send: This is a core GitHub code review feature. You can send immediately by pressing the "Add single comment" button, but if you "Start a review", your comments are batched. - Built-in fixes and lints on the PR "Files changed" tab: GitHub Checks offer this, although not many teams have adopted it (that I'm aware of). - Changing indentation: The "Diff settings" menu has a "Hide whitespace changes" option, although it's not (afaik) possible to persist this. - Auto-submit if tests pass: The Refined GitHub browser extension offers this (https://github.com/sindresorhus/refined-github), kind of. You need to keep the page open in your browser while it finishes. Also, have you seen https://reviewable.io/ (made by an Xoogler) and does that appeal to you?

I like https://reviewable.io, low friction github integration but gerrit-like multi-patchsets and generally a sane flow when you have multiple rounds of comments

https://reviewable.io is a good upgrade from regular GitHub reviews

With Servo we use https://reviewable.io/ on github. We don't enforce its use. If a newcomer makes a pull request, we'll just use the GH review interface. In general simple PRs go through the GH review interface, regardless of who they're from. We break out Reviewable when a PR actually needs it (this is usually the choice of the reviewer). This means that Servo continues to have a lower bar to contribution, without hampering maintainers on PRs that need more than GHs set of review features. This has worked out well for us.

i've personally found using Reviewable[0] to be a delight, automatically plugs in your github workflow in that it modifies the comments in your original PR with comments left on reviewable itself. one killer feature is their batch comment mode, the ability to draft up a whole set of comments and publish in one go all the while tracking the resolution/conversation of each point brought up. an example of this is here[1], batched comments with the multiple threads of discussions across various revisions and tracked to resolution. [0]: https://reviewable.io [1]: https://github.com/cockroachdb/cockroach/pull/10618

If you can't reduce PR size, then at the very least you can make the process less painful by splitting the work up with a tool such as https://reviewable.io/

The linux kernel, which is open source and does want contributors, is doing more-or-less just fine with an email-based PR and review flow. If it's an open source project, it should be using an open source review platform that allows improvements and specialization of the code hosting too. Using github, where the review tools are bad and can't be improved by an outsider, is a slap in the face to open source. Frankly, I'm tired of people using github. The fact that it still doesn't have any idea of patchsets and diffs between them is cripplingly bad (i.e. you force push a new version of your change, there's no easy way to review the diff between the old and new version of your change). Having to use yet more third party tools, like https://reviewable.io, isn't an answer to this, it's just a sign that github should be open source so these could be forks or first-party tools. It's also just insulting for an open source project to force people to use a proprietary platform owned by microsoft.

>See reviewer presence so that you can see if someone is already reviewing and avoid unnecessary pings. >Visibly values privacy and security above all else These two things seem squarely at odds. Personally, I don't want my code review tool announcing to developers when I'm looking at their PR. The fact that it's a Chrome extension would also be a big blocker for me. I run a dev team, and I wouldn't ask any of my teammates to install a browser extension to participate in code reviews, especially one that's only available for Chrome. I care a lot about code reviews [0], but the features here don't really resonate with me. - Blocking vs. non-blocking: This is useful, but the default should be that a comment is blocking. Otherwise, it makes the default that all the reviewer's notes are optional unless they go out of their way to mark them as important. - Thread status history: I think the status history is much less important than the status right now. In other words, I'd like to know if a review is blocked on the author or reviewer. I'm not that interested in what the status was yesterday. - Metrics: I worry that these focus on the wrong thing. I'm trying to maximize usefulness of my review rather than speedrun through them to improve my PR time. One of the huge gaps in Github's tool is the ability to do multi-round reviews (e.g., "show me what's changed since my last round of notes"). You can kind of bend Github to show you the right diff, but then it can't show the…

Github's code review capabilities are a huge weak point for team projects, and I've seen several services spring up to attempt to capitalize on this. Mozilla's Servo project is currently trialing one called Reviewable, here's a demonstration: https://reviewable.io/reviews/servo/servo/6456

Anything where we can't host the tool and point it at git repositories on a server we control is a complete non-starter for us, unfortunately. This is mostly because our development and test environments are not connected to the Internet. Other than that, I took a quick look at your product and it's feature-wise close to something I would want to use. Only comments I would make would be that non GitHub projects generally want the review tool to handle the branch management (a.k.a storing pull requests, flagging their status, etc.): of course only focusing on GitHub lets you not worry about that and get a product running much sooner... You should spend some serious time looking at your page load times as well - I'm 10msec away from your server and the demo code review at https://reviewable.io/reviews/Reviewable/demo/1 took nearly three full seconds to load, even with most static assets already cached since I didn't timeline it on the first attempt.