Clever Geek Handbook

Are there any issues with this workflow with the Git feature?

I am currently in the middle of migrating Subversions repos to Git. The problem I am facing is managing the large number of changes that take place on a particular project. Some changes can be reverted and they leave Subversion branches broken.

Given Git's flexibility in branching it, I suggest the following workflow:

Kernel diagram:

  • branch
  • master - limited to upload requests only. Senior developers sign up. branch
  • develop - Available to all developers. The features of the bleeding edge have been joined here. May not always work. branch
  • uat - Available to all developers. Testable features ready for the client to test
  • subordination is available to all developers. To be filled with ready-made, signed functions only
  • feature / * - for all work that will be completed after the launch of the project. A feature may be some text changes or significant development of site functions.

Typical working scenario:

  • Customer requested a new feature on the website
  • The developer creates a new feature branch from the master and codes the new feature. Feature is regularly merged into development
  • When a function is ready for testing, this function is merged into the uat branch
  • Any additional adjustments are done in the function and merged into the uat branch.
  • When the client is happy with the new feature, he merges into a stage, which is a replica of the master
  • Once the phase merge is complete, a pull request is generated to discuss merging the code with the staging content into a ready-made wizard for deployment to production servers.
  • Further changes requested in the pull request are made to the function and merged into stages
  • Upon completion of pull request, master merges into develop and uat
  • The function should be removed after a while

With the above, I am trying to eliminate

  • Problems with cleaning up dropped functions. In the worst case, with the above setup, the development branch can be dumped, cloned from uat or master, and has continuous functionality merged back into it.
  • Cherry collects completed features in development for input to uat or master, which is currently going on in Subversion
  • Unauthorized tampering with the production code. With the above in mind, developers can prove that the code works with a staging environment and asks for code review before merging into master. Our Subversion solution allows developers to band together in the trunk, but they cannot deploy, which can get messy when bad code is found.
+3


source to share


1 answer


This is generally a valid workflow and I don't know anything that needs to be improved (using a similar one here). If you want formal validation (I think you've looked at them already), it's pretty much covered in the Feature-Branch workflow on this page . The finishing workflow (stage -> uat-> master) is also described in the manual .

Given the flexibility of flexibility, you also don't get stuck on this workflow forever, so if you find something isn't working, you can tweak it (and due to the distributed nature, anyone can use their own micro-workflow in any case without twisting things).



So, yes, a valid workflow should eliminate what you want to eliminate and should match the workflow you describe.

The details still always depend on the situation, but as I said, this is a great start if the need arises.

+1


source






More articles:


All Articles