Do you use this or a similar git
We use a similar workflow at work, but a little less complicated. It is however greatly inspired by this workflow, since I've read this article many times. I even have the pdf of the branching model printed in colors beside my desk :)
Do you consider this a productive
Productive. How do you define productivity? Well, in my mind it's most important to have high quality, at least to try and achieve better quality all the time. Constantly improving the process etc. If you can produce quality code, productivity will benefit from it. So the question is really: Does this improve the quality of the software? And my answer to that is definitely yes.
What I love the most with this type of branching model, is that it introduces branches in different layers of quality. The more to the right in the picture, the higher stability and the higher quality. The master branch is holy and all commits on it should be regarded as stabile versions of the software. The more to the left you go, the more experimental and the lower the stability you get.
As soon as you test new features and bug fixes you can gradually transfer them from left to right and thus moving in code with high quality exactly when you know that the code meets the quality requirements that you demand of the code. Well, at least in theory, since you can't test everything to 100% and know for sure that the code doesn't contain any bugs, because it will always have bugs. But it enables you to keep a high confidence.
Nothing sucks more as a programmer, than to work in a system where no one has confidence in the code, because they know it just sucks and that there are a shit load of bugs in it.
Do you see any flaws with this
approach? Any potential downside?
It's important to think through your branching model so that it fits well with the needs of your organisation. Just because this model works well for some people, doesn't necessarily mean it's optimal or desirable for another.
There are always trade offs and even in this case. One trade off is the number of branches versus complexity. By introducing a lot of different branch types, you increase the complexity of the workflow. For example it might be just wrong to always force people to create a new feature branch, when they are trying to fix a simple bug by changing a couple of lines of code.
We all know that bugs are more or less complicated to solve. So, when a trivial bug is discovered you might want to cut down on complexity and administration to get rid of extra overhead and just let people commit directly to e.g. the master or develop branch. But as the nature of your fixes turns more complicated, it's worth that extra overhead to create new branches for them. Especially if you are unsure of the size and length of it or if you want to improve collaboration between you and the other developers.
If you have a better approach, would
you mind sharing, or providing a link
to an article or discussion about it?
This is no doubt a good approach and it might fit most cases since most of us have similar developments processes, but it might not be suitable to everyone. I strongly urge you to think through how you handle your code right now, and try to create a branching model that fits the one you already have.
The most important point is to get started with git and the rest will follow naturally. Start simple and gradually improve! Be creative!