Conventions and practices regarding Code Review on PRs, and subsequent approval #8431

Hi folks,
Yesterday there was a casual discussion between a large group of contributors, PMC members and Committers
about Code Review, how it is currently practiced in Texera, and how that has been going so far. I would
like to serialize that discussion and bring it to the broader community because I think there were some
important insights and questions that arose. Putting on my Mentor hat for a moment, it is vital that
these kinds of development-related decisions are eventually held in an open forum.

First, let me preface some of this with some ASF-related stuff (that you can skip if you are familiar).
This is simply my understanding, if someone knows better please correct me.
There is no specified or required practice for Code Review within an ASF project. It is for each community
to decide. As far as the ASF goes, There are simply 3 roles: Contributor, Committer, and PMC member.
The latter 2 in principle have demonstrated the care and responsibility to the codebase to be entrusted to
uphold the community principles with regards to committing new code to the project, whatever they are.

1. What should the role of CR be?
   Should code review be a thorough and comprehensive check by a subject expert, or should it simply
   be a brief check by a colleague? Or somewhere between the two? Should it depend on the area or
   some other factor?

2. Under what circumstances can a PR be approved?
   Sometimes there is an ideal reviewer for a PR, but they are not available. In these circumstances,
   can someone else step in? If they do, is this something that can always be done, or only in certain
   situations?

3. How should the work of CR be distributed?
   It naturally is the case that the most experienced people in the project are often the best one to
   review a PR. However concentrating all of this work on a few members leads to a bus factor, which
   can frustrate everyone by delaying merges and overburdening senior members. So ideally there is
   at least some principle by which to parallelize, or at least time share, this task among a limited
   set of resources.

I think there are already some implicit and informal conventions. It would be good to attempt to
clarify and make these clear, so that new contributors can understand immediately rather than
having to observe and infer

I will refrain from giving my view, I am most looking forward to hearing from everyone else first.
Of course if there is a general question regarding this that someone feels I am forgetting, please
also feel free to raise it.