I feel... weird...Every time I work on something, no matter how minor, I create a new branch.
The development model for the one project was to publish that branch so other can code inspect it. Blasphemy! git branch -a is now a deluge of mindless crap.
For my own project, we do code inspection on the side, with diffs. The main git has only a few branches and they each correspond to a product release.
In either case, I don't bother with git -D. I just wipe out the entire partition when I'm done. Or when we upgrade our servers. I think I have a backup harddrive from 2005 in a box somewhere...
Hah so true.
Rebasing a feature onto dev is exactly how you maintain a sane, comprehensible commit history for other people to know what the hell is going on. Makai is doing what pretty much any other large project does.
Honestly, unless you are on *nix or have to run a weird-ass command, there is no reason to use terminal over it.
Why not just open a PR with a merge of the feature branch into dev? Why do your commits *have* to always come after everything on the current dev branch? Re-writing Git history all the time seems silly to me. That's way less sane and comprehensible for a team than just creating branches and merging them back in.
![]()
Gitar hero
Possible to find the origin of bugs caused by the interaction between two merges (nothing wrong with either individually) if the tree is a straight line.You base your dev process on what a visual representation of your commit graph looks like?
Everything should be merging back into the same single branch so that isn't even a good example image.
edit: for example, http://nvie.com/posts/a-successful-git-branching-model/ is quite popular
You base your dev process on what a visual representation of your commit graph looks like?
Everything should be merging back into the same single branch so that isn't even a good example image.
edit: for example, http://nvie.com/posts/a-successful-git-branching-model/ is quite popular
git merge spaghetti is bad in my opinion as well. Much harder to revert and bisect a large weave of merge commits. PR model makes sense for large distributed teams and open source stuff, but not for your normal 2 - 10 engineer project.
Reverting on your master branch should be a rare occurrence, unless your code reviews are rushed and/or you don't have good test suites.
I don't think 2 layers of branching off and merging back is really spaghetti, but that's subjective I suppose.
Also I would think that a 2-10 engineer project is in the minority, not the norm. Open source + larger teams are more common, right? 2-10 is startup size. I worked at a company that over the years ranged from 2 devs to 8, and PRs worked well for us still, but YMMV.
I am always interested in seeing the different variations of Git workflows that other people come up with and use, though.
Just a casual fuck up.
I've had coworkers just up and delete 2000+ products from a estore for a few hours.
These things happen. If they happen often it's a problem. Usually it's not.
Providing a sane history is one of the primary motivations for using version control in the first place.Why not just open a PR with a merge of the feature branch into dev? Why do your commits *have* to always come after everything on the current dev branch? Re-writing Git history all the time seems silly to me. That's way less sane and comprehensible for a team than just creating branches and merging them back in.
Providing a sane history is one of the primary motivations for using version control in the first place.
If you have 50+ feature branches per release and support multiple releases in parallel your ability to make sense of commit history is an important issue.
A single line is as clear as it gets.Right. And a drawing like that isn't a good way of getting an overview of commit history, regardless of what your team's Git strategy is. It's not like a single line (the output if you're rebasing everything before merging back) is any better, lol.
edit: for example, http://nvie.com/posts/a-successful-git-branching-model/ is quite popular
A single line is as clear as it gets.
I've always felt like the git-flow model based on this article was adding an unnecessary extra branch. If you tag your releases with git tag, then you can keep master and dev as the same branch. You get all the benefits of being able to hotfix, etc, without having to maintain a new workflow that requires new devs to know that master is not canonical.
Hm? The issue is figuring out who broke what when and how many branches it affects. Once it's merged it doesn't really matter what branch it came from (in our workflow).Except when trying to split the timeline up by feature. And all of the commits are out of order chronologically. And you lose any idea of where/when a branch was started. You only know when it was completed.
It's nice to have one branch that reflects prod exactly (master is still canonical in that sense), and another that's for dev that matches what's on your staging server, but yes you can duplicate much of that using a single branch and tags. Some companies don't have a staging server, there's also continuous release vs scheduled releases, etc. There's no one-size fits all solution.
I'll echo the others because I'm curious, what source control tools do you find easier? I've only used git/svn/clearcase/perforce.p.s.
Personally, the less amount of time I need to spend in learning shit like source control the better. And there are waaaaaaaaaaaaaaaaaay easier source control tools out there, and personally, I never thought what git add in capabilities is worth it (and it's not like it's not missing some things too).
Hm? The issue is figuring out who broke what when and how many branches it affects. Once it's merged it doesn't really matter what branch it came from (in our workflow).
Don't worry. It happens to cops with their bodycam footage all the time.
Yeah, that would make sense in a saner org but we always end up having a bunch of unrelated shit go in a "feature branch" because of political/organizational reasons. It's pretty much a giant mess, which is not gits fault per se, but it helps to enable the clusterfuck.I find it easier to just jump from merge commit to merge commit than to parse through and figure out where the boundaries are between features on a single timeline of commits. Branches keep commits for each feature grouped together in an easily parsible format.
Do you guys not ever review what work was done over a given time period (sprint, quarter, etc)? That's where I find having branch history to be particularly useful. You can see the full chunk of time a feature was worked on, what features were worked on in parallel, etc. An issue tracker can help with some of that, but won't give the full, granular picture.
Yeah, that would make sense in a saner org but we always end up having a bunch of unrelated shit go in a "feature branch" because of political/organizational reasons. It's pretty much a giant mess, which is not gits fault per se, but it helps to enable the clusterfuck.