code review with git-flow and github

If you're doing code reviews, then I will assume that you have a central repository that contains the "official" code. Developers pull from and push to this central repository.

When you use Gerrit, Gerrit itself becomes the central repository (it has built-in SSH and HTTP servers that let users interact with it in basically the same way they already are). When using Gerrit, the workflow becomes:

1. Developer makes changes on whatever branch, commits locally.
2. Developer pushes those changes to Gerrit.
3. Gerrit creates review items for others to review.
4. Peers review the code, making comments and accepting or rejecting the commit.
5. When the commit is accepted, then Gerrit makes those changes available for others to pull from the branch.

When using a central repository, other developers can see the submitted changes after step 2. Gerrit introduces the code review workflow, and so other developers only see the submitted changes after step 5.

This works well with git-flow (or any other branching scheme) because Gerrit supports reviewing changes made on any branch.

We stumbled on this exact problem recently. We really like git flow, has it use a good level of semantic (using the same level that you use in team discussion : "I'll start feature A" more than "I'll create a branch, checkout it"), while git is very "implementation" level (which is good and useful also, but different).

The problem we have is with git feature finish, as it merge the branch into the develop, while we want a pull request to be sent and (this is important) merged by the reviewer, not the committer, to emphasize team ownership.

Our current solution :

1. Someone use git flow to create a feature branch
2. When done, he create a pull request (using github)
3. The review take place, with potential additional commits
4. The pull request is merged using GitHub by the reviewer.
5. There is not git flow feature finish (as the branch is already merged)

This is consistent with our practice, with the downside of requiring to delete the branch ourselves (as we do not git flow finish). Our next step will probably be to reimplement some parts of git flow (as it is mainly about chaining git commands) to take this into account (having the "cleaning" part of the finish, without the merge).

The process the team I work with uses for this is as follows:

1. Create a feature branch: git flow feature start module_1
2. The code is updated on the feature branch
3. As changes are committed they are pushed to GitHub (or once at the end if preferred)
4. When the feature is completed a pull request is opened in GitHub comparing develop and the feature branch module_1
5. The team reviews the pull request and makes comments
6. Any changes from the pull request are made to the feature branch
7. Once all changes are incorporated on the feature branch the feature branch is finished: git flow feature finish module_1
8. The develop branch is pushed to GitHub (GitHub will automatically mark the pull request as closed/merged when this happens)

Normally all of this process is done by the original author but that is not required. Anyone on our team can step in and pick up this process at any point. All they have to do is checkout the feature branch and continue on with the process. Who ever runs git flow feature finish module_1 will have the luxury of their local feature branch being deleted but anyone else who checked out the branch with have to do this manually if they want to using something like git branch -D feature/module_1.

For hotfixes we use a similiar approach and create the pull request in GitHub before we finish the hotfix.