Thanks for the comment Mrigendra! It's motivating

I do agree that this video was well done, but "must" is a strong word. git is a just merkle tree, like ZFS or bitcoin. You can't re-write history, but you can create an alternate one.

agree with you. the git command is kinda make me confuse for long time. Thanks god someone have made this video to explain it with illustration.

Yep, all articles out there assume we know rebase already, while they're trying to explain what rebase was. It's like teaching people to drive a car while the student even doesn't know how to turn on the car.

Every video has such a comment for sure.. no matter if 50% of viewers weren't able to understand 🤣

Can you squash a feature branch AFTER merging it in order to achieve something similar to first-parent when looking at the log graph? m | \ | * m | | ----> | \ | * | * (squashed after merge to master having taken place) | / | / m m

@@PaulSebastianM , I'm afraid, i don't get your question. I can squash feature branch before merging, but I don't see any reason for that. Your master graph will be clean on first-parent, and additionally, you will have every commit in feature branches. it is convenient, as for me

Fully agree. Rebasing feature branches are nice to make the history clean. I don't see the advantage of rebasing master at all.

@@freefallintoflames Agree. Rebasing master sounds like a horrible idea. It can cause all kinds of havoc. There are exceptions to the rules, but I've seen people accidentallied master because "git push -f" and borked the rebase. Didn't take long before we started marking master as protected.

I agree. The only time rebase made sense to me was when I needed to cut a feature out of a branch. I could not care less if my commit log is a straight line. Why not preserve the history as it is?

You can combine the 4 steps, the `git checkout master && git pull && git checkout my-branch && git rebase master` with a single command: `git pull origin master --rebase`

Thank you for this! Git is somewhat mysterious, and this is illuminating.

Yeah, if you could do one on cherry picking too, that would be great! I'm still often confused on that process. :o

And code review be damned?

@@kamok1017 nice"

I agree !!

Definitely agree too! Thanks

I agree!

AGREED

I agree with Cory. Seems like push to master this way only makes sense when you have complete trust that the changes your are introducing the master are good ones. Most development teams will want to implement a Pull Request (PR) so that peer review, CI/CD, etc. can be applied to the potential feature before its becomes part of master.

I don't understand "has potential to delete other people work". Why do you need to force push? Unless you're re-rebasing commits you already pushed before (which of course is very bad), I can't think of a scenario where you'd need to force push.

Completely agree, on a larger project this would be a shit show. Imagine going through 50 commits that you don't even know what got changed or how it worked. Keeping an untouched master branch and having your feature branch not be behind in commits will allow any merge to be light and any conflicts easy to handle.

@@shashwatmehta9733 agree with your point, rebase before pushing commits on remote

Thanks for the advice, i am new to this world i just want to add one thing here, if you are using scrum/agile development flow and creating individual branches for each of your tasks, then you will be rebasing only your commits reason for rebasing 1) squash unnecessary commits into one commit 2) remove unwanted commits from other branch if you have taken pull or created your branch from their branch, i mean your branch contain work of other branch which isn't ready for merge, you can use rebase --onto to remove all those commits 3) Clean history of course :) don't rebase master/release branch or any branch on which 2 or more developers actively working, Golden Rule 😜: 1) Rebase your branch before pushing commits on remote 2) use git merge at time of merging branch into master/release branch

How would you recommend solving this problem?

Victor Villacis thanks for taking the time to comment. I'm glad all that time spent on those animations is paying off!

super-duper easy to understand the concept with your graphics.. thank you very much

True. This help a lot

Agree, the graphics in sync with your commands was great

and the graphics, that is really whats it all about

The mess is when a feature branch has a bunch of merge commits from master. The history graph starts to look like someone was braiding some string. Then you have all of the overlapping feature branches, and soon it looks like a rope.

@@BenjaminCronce but it helps to tell features' branches apart, right? if the history is just a straight line, is it wrong if i say it will be hard to track each feature's merge time?

@@BenjaminCronce Oh, I get it now. I was assuming that feature branches were rebased on top of master when needed (to get a fix from master) but still using merge commits from feature branch to master.

No, the branch remains there until you deleted it.

You don't "lose" history

@@Philbertsroom You rewrite history - which means you lost your original history. Specifically, you lose the state before the feature branch was merged because you force it on top of the commits in master.

@@Gismo359 You're replacing the old history with functionally equivalent history...

@@Philbertsroom It is not equivalent - you cannot navigate the old feature branch in the same way that you could before rebasing. It causes headaches if there are multiple people working on the same feature branch, or if something not related to your branch changes before the rebase.

@@Gismo359 Just have a naming convention for commits or add which feature the commit is related to in the commit message. These "issues" can be fixed with a slight change of workflow

You can rebase and squash feature branches into one commit describing the feature. This lets you have a clean, linear history, with each commit describing one feature. Squash is missing in this tutorial.

I do not agree completely! When you are on your FEATURE BRANCH, you should ALWAYS REBASE against remote target branch. Because you want to want to fix conflicts on your local branch, and not have to merge remote branch to your local branch to do this. Then when your code is ready to be put on REMOTE BRANCH, ALWAYS MERGE by making a pull request first for review. ALWAYS activate Squash option of your pull request tool to not merge all the single commits. This workflow is clean and entreprise approved in big companies with huge projects (i work for one)

@@alfredomoreira6761 isn't this what the video author is already doing? He's rebasing the feature branch to the remote master branch by pulling the remote changes and then rebasing the feature branch on it, and taking care of conflicts there while still on the feature branch (he just doesn't have conflicts in the example but mentions taking care of them if they arise).

@@kmr_tl4509 With squashing you will lose every single commit from your developers that may contain valuable information on WHY a line of code was changed. This is very important when dealing with problems from customers later on.

@@alfredomoreira6761 I assume you mean that you have to rebase your local master onto the origin/master when pulling, that is correct. With squashing you lose valuable information from the development. But that is - of course - up to you and your company.

I was thinking exactly the same thing, merge commits look messy if you try to lay them out visually on a timeline but that's not the point at all. If anything putting it all in a straight line makes it harder to understand because you lose all of the important information from the branches and merges.

There is nothing about being visually pleasing. It's all about being able to track properly every commit. To see which feature were implemented at what specific point in time. To see what commit caused which bug. And, mostly, to revert properly.

why? genuinely curious.

Agreed. I've done worse while I was learning, but not now. The golden rule of rebasing: "If it's a remote branch you never rebase... ever. If it's a local one do whatever you want before you push it for the first time.". It took me two weeks of attempting to resolve the mess I created by doing just that, and it took a lot of reading to get to a semi-competent level where I could establish rules for my team to follow, without leaving the possibility of messing up in the process. Today we only use rebase once in a blue moon, and even then, only if absolutely necessary. It's a nice 'tool' but you have to be careful with it.

Updated video that addresses some of these rebase shortcomings in more detail: ukposts.info/have/v-deo/sn-fq52voHlhsHU.html

​@@vwwvwwwvwwwvwwvvwwvwThe illustrations are very misleading. A "branch" in git is a bookmark somewhere on the commit graph that points out the lastest commit. When you first switch -c (or checkout -b but checkout is stinky, it's missing modern safety features and is much more likely to eat your uncommitted work) or branch my-new-feature you add a new bookmark at the current location. There's no half-completed edge. Most importantly commits are not sorted into branches. There's no requirement to choose "this commit is on main vs new-feature" We actually say "main contains this commit" which means that the commit is the current tip of main or it's somewhere in the history of main. To classify commits into boxes we actually need ranges. Like "main.." means "part of this timeline but not part of main" -- that's very common because it's commits that you're thinking about but haven't released as main-level stable. The opposite "..main" is commits that are in main, published or integrated, but the code here hasn't been affected by them yet.

​@@vwwvwwwvwwwvwwvvwwvw5:19 Also he shows rebase as a shift. But it's not a shift you can't move commits. You can only make new commits or forget old ones (which takes a long time). Rebase copy-pastes changes. It interprets your work as a series of patches and re-applies them somewhere else. Then it changes the branch bookmark to the end of the new commits. This means the old commits are abandoned. It's really important to understand the entire picture here. The abandoned commits might still exist in another branch - which is both a good and bad thing. Good because it means I can't accidentally modify an inactive branch. Bad because if you try to merge both branches, the merge can become more confusing.

Glad to hear that. Check out my other recent git videos and let me know what you think: ukposts.info/have/v-deo/qWVkqaOMbKx-zJ8.html. I'm trying to ramp back up

Heck yeah, thanks for the kind words. I'm working on a web application for learning Git concepts that will feature tons of videos, animations, graphics and other good stuff . I've been sending out monthly newsletters with progress updates and feature previews, it would be awesome to have you on the email list. Check it out: waitlist.learngit.io/