Take the 2-minute tour ×
Programmers Stack Exchange is a question and answer site for professional programmers interested in conceptual questions about software development. It's 100% free, no registration required.

With regular git and github I can do a code review by simply creating a pull request of the feature branch I'm working on to the master branch. How would I do code reviews with git-flow? With workflow like "git flow feature finish` I'm confused as to where the code review actually happens and how git-flow or git can facilitate that review.

share|improve this question
    
You may look into gerrit though I'm not sure how it integrates well with git-flow. Anyway, what's your team workflow? –  OnesimusUnbound Feb 20 '13 at 15:10

3 Answers 3

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.

share|improve this answer

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).

share|improve this answer

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.

share|improve this answer

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.