Git & GitHub Tutorial: Undoing Changes with Checkout, Revert, and Reset

This comprehensive segment covers Git history rewriting and interactive rebase techniques. The instructor explains that while only 1-2 out of 10 companies typically ask Git questions in interviews, understanding Git is crucial because 90% of organizations use it. The segment covers the concept of history rewriting, explaining that Git rebase is the only command that performs history changes, meaning it can change commit IDs. The instructor demonstrates the 'git commit --amend' command for modifying the last commit, explaining that amend changes both the commit message and the commit ID. The segment then covers interactive rebase for modifying older commits, demonstrating the critical rule of positioning HEAD one commit before the target. The instructor covers all interactive rebase options: 'p' (pick), 'r' (reword), 'e' (edit), 's' (squash), 'd' (drop), 'm' (merge), and 'exec'. The instructor demonstrates file renaming during rebase and explains that modifying any commit in a chain affects all subsequent commits' IDs.

The git rebase command allows rewriting commit history by replaying commits on top of a new base commit. During interactive rebase, you can drop unwanted commits, effectively removing them from history. This creates new commits replacing the old ones. While powerful for cleaning up history, this permanently alters commit IDs and should be used cautiously, especially with shared repositories where others may have based work on the original history.

This section covers advanced rebase techniques for modifying commit history. Interactive rebase (-i flag) prompts for actions on each commit including 'pick' (default replay), 'squash' (fold into previous commit), and others. This enables combining related commits into single commits with unified messages. The 'rebase onto' command (git rebase --onto new_base old_base) allows moving commits between branches by specifying a new base commit. This is useful for including commits from one branch in another or changing a branch's base when you accidentally branched from the wrong parent.

This video teaches how to modify Git commits using two main methods: the `git commit --amend` command for changing the last commit's message or adding/removing files, and interactive rebase (`git rebase -i`) for editing older commits by specifying a commit hash or using HEAD~N notation; both techniques allow you to rewrite commit history locally before pushing, with the ability to abort a rebase if needed using `git rebase --abort`, and you can use `git stash` to temporarily store uncommitted changes during the process.

Interactive rebase is a powerful Git feature for editing commit history, enabling rewording, reordering, combining, and deleting commits. Before rebasing, always create a backup branch using Magit's branch panel to preserve original history. When you reword a commit, all subsequent commits receive new hash values because rebasing creates entirely new commits. If you've pushed the branch remotely, you'll need to force push afterward. This foundational understanding prepares you for advanced commit history manipulation techniques.

In Git, when you rewrite history using interactive rebase and remove commits, those commits become orphaned and may persist in forks or pull requests; force pushing to overwrite remote repositories can cause chaos among collaborators, as it destroys their local history and creates complex divergence issues, making it almost always advisable to avoid rewriting history on shared branches and instead use compensating commits to address mistakes.

Protecting your repository requires implementing peer review through pull requests to catch mistakes before they merge. Protected branches enforce rules preventing force pushes and requiring reviews. Force push should be avoided on shared history—it destroys others' work permanently. The fundamental lesson: Git is not complicated once understood as a conspiracy theory board of immutable snapshots linked by pointers. Understanding what happens under the hood makes all commands intuitive, and the best Git practices are those that prevent problems from occurring in the first place.

Interactive rebase edits commit history by replaying patches. It's powerful for cleaning up local history but dangerous for shared commits. Once pushed, never rebase - it rewrites IDs and breaks others' work. Git prevents forced pushes in these situations. The reflog provides recovery from mistakes. Understanding these constraints protects collaborative workflows.

When you modify existing commits using extend, amend, or fix up, the commit history changes and requires force pushing to the remote. Magit handles this by showing a divergence between local and remote commits. Pressing 'p' then 'f' activates force push with lease, which overwrites the remote branch with your local version. This is dangerous for shared branches because it overwrites others' work. Best practice is to only force push on private branches you created for development, never on shared branches like master.

Git force push overwrites commit history on remote repositories, which can cause significant problems when other collaborators have already pulled the branch, potentially deleting their work; however, using git push --force-with-lease instead provides a safer alternative by checking for unpushed commits before overwriting, preventing accidental data loss while still allowing necessary history modifications.

The speaker explains why merge commits create problems for reverting changes. When using merge, reverting a feature requires extracting changes from multiple merge commits, which becomes increasingly difficult as more merges accumulate. In contrast, rebase creates a linear history where reverting is straightforward—a single revert commit can undo the entire feature. The speaker emphasizes programming with the philosophy of always expecting to screw up, which is why they write unit tests and keep commits clean and linear, making reverting manageable when bugs are discovered.

Complete rebase workflow: 1) Switch to feature branch, 2) Fetch latest changes from main, 3) Rebase onto main ('git rebase main'), 4) Resolve conflicts as they arise, 5) Continue rebase after each resolution, 6) Push with force-with-lease ('git push --force-with-lease'). When conflicts arise, Git pauses and shows conflicting files. To resolve: open the file, choose to accept your changes or base branch changes, stage the resolved file using 'git add', and continue rebase using 'git rebase --continue'. If conflicts are too complex, abort using 'git rebase --abort'. After successful rebase, push changes using force-with-lease to safely update the remote branch.

This comprehensive workflow covers handling Git merge conflicts from start to finish. First, abort a problematic merge using 'git merge abort' to reset to the pre-merge state. Then, use 'git status' to identify conflicted files. Understand that Git inserts conflict markers (angle brackets and equal signs) into files when automatic merging fails—these are actual file content, not just editor displays. Learn to interpret the three sections: changes from your current branch (HEAD), changes from the other branch, and the conflict marker boundaries. Resolve conflicts by either using editor buttons (accept current change, accept incoming change, or keep both) or manually combining necessary changes from both versions. Note that automated options may fail when changes involve different modifications like variable renames versus log message changes. Always consider asking the original author for help with complex merges rather than struggling alone.

The 'git revert' command creates a new commit that undoes changes from a specific commit. Use 'git revert [commit-hash]' to revert changes. Conflicts may occur when reverted commits modified files that have also been changed since then. When conflicts occur, you can abort the operation using 'git revert --abort' to return to your previous state. The instructor demonstrates resolving conflicts by manually editing files to combine changes appropriately.

When a merge was cancelled and you need to re-merge a feature branch, rebasing the feature branch onto the current master branch resolves conflicts. The rebase command identifies commits that exist in the feature branch but not in master (commits after the last common ancestor) and replays them onto master. This creates new commits that don't conflict with master, allowing the merge to proceed without previous merge conflict issues. The rebase syntax 'git rebase master' rebases the current branch onto master, while 'git rebase --onto' provides more control over which commits are moved.

Git cherry-pick is a command that allows developers to selectively apply specific commits from one branch to another, creating new commits with identical changes rather than merging entire branches; this technique is useful when you need to incorporate isolated bug fixes or features without bringing in unrelated changes, and it can be combined with the --no-commit option to stage changes before finalizing them with a custom commit message.

The 'git cherry-pick' command allows you to apply specific commits from one branch to another without merging the entire branch. This is useful when you want to bring individual changes into your current branch while keeping the rest of the branch's history separate. To use cherry-pick, first identify the commit hash using 'git log', then run 'git cherry-pick' followed by the commit hash. Cherry-pick is particularly useful for applying small, isolated changes without the complexity of full branch merges.

The git cherry-pick command allows developers to selectively apply changes from specific commits (single or multiple) from one branch to another, rather than merging entire branches. To use it, first checkout the target branch, then specify the commit hash or hashes you want to apply. By default, a new commit is created with the same message as the source commit, but you can modify the message using the -m flag. For non-destructive application, use the -n flag to stage changes without committing. If conflicts arise during cherry-picking, resolve them manually by editing the affected files, staging the resolved changes with git add, and then completing the process with git cherry-pick --continue.

The 'git cherry-pick' command allows you to apply a specific commit from one branch to another branch. Unlike 'git merge' which combines all changes between branches, 'git cherry-pick' only applies individual commits. To use it, first identify the commit hash using 'git log', then run 'git cherry-pick <commit-hash>'. This is useful when you want to apply a specific fix or feature without bringing in all the other changes from the source branch. The commit hash is a unique identifier for each commit, typically a long string of characters.

Cherry-pick applies a specific commit from one branch to another without bringing in all other commits. Unlike merge, which applies all commits, cherry-pick only applies the selected commit. To use: switch to the target branch, run 'git cherry-pick [commit-hash]', and the commit will be applied to the end of your branch. The commit hash can be found using 'git log' (first 7 characters suffice). This is useful for quickly applying single changes between branches.