Mastering Git Branches: Switch, Delete, Rename, and Merge like a Pro!

This video comprehensively explains the concept of Git branches, their creation, management, merging, conflict resolution, and related commands, using accessible analogies and practical demonstrations to clarify core Git workflows for parallel development.

1. Understanding Git Branches and Their Purpose

Git branches enable independent parallel development lines by creating copies of the codebase at specific commit points. These allow developers to work separately on features or fixes without affecting the main codebase.

A branch is a lightweight, movable pointer to a commit.
Creating a branch is essentially copying your current codebase at a specific commit.
The default branch created on Git initialization is called master (or now often main on platforms like GitHub).
Multiple branches can be created from any branch, forming a tree of development lines.
Example given: working on an "About" page in one branch and a "Logout" page in another, developing independently and merging later.

Key Insight:

Branches isolate development within the same repository, enabling safe, parallel code changes.

2. Branch Creation, Switching, and Management Commands

Practical Git commands and operations demonstrated for branch handling include:

Creating a branch:
BASH
```
git branch <branch-name>
```
Listing branches:
BASH
```
git branch
```
Switching branches:
BASH
```
git switch <branch-name>
```

Creating and switching to a branch simultaneously:

BASH

git switch -c <new-branch-name>    # or equivalently: git checkout -b <new-branch-name>

Deleting a branch:

BASH

git branch -d <branch-name>        # safe delete, only if merged
git branch -D <branch-name>        # force delete, even if unmerged

Renaming a branch:
BASH
```
git branch -m <old-name> <new-name>
```

Important Notes:

You cannot delete a branch that is currently checked out.
Force deletion (-D) is required if the branch is not fully merged.
git switch and git checkout can both be used to switch branches; switch is preferred in newer versions.

3. Commit Tracking and Branch Pointer Mechanics

The branch name is a pointer to the latest commit in that branch.
The pointer moves forward with each commit made on that branch.
HEAD is a special pointer indicating the current branch's latest commit.
When switching branches, HEAD changes to point to the new branch’s latest commit.
Branch pointers and HEAD simplify history navigation and ensure Git knows which commit is currently checked out.

4. Workflow Example: Independent Development, Merge, and Conflict Resolution

The video walked through multiple branch workflows to explain branching behavior:

Created branches: master, logout, not-found, support.
Changed files in each branch independently, committed the changes.
Switched branches to review changes, ensuring segregated workspaces.

Merging Branches to Master:

Merging logout branch into master showed a fast-forward merge, where master pointer simply moved forward because the changes were linear and did not conflict.
Merging not-found branch resulted in conflict due to changes on the same lines/files in master and not-found.
The conflict was manually resolved by:
- Editing files to select desired changes.
- Adding resolved files.
- Committing the merge to create a new merge commit.
Merging support branch was conflict-free, operating on separate files, resulting in an automatic merge commit.

Merge Types Explained:

Merge Type	Description
Fast-forward	`master` pointer moves directly forward to match the merged branch, no additional commit.
Merge commit	New merge commit created when histories have diverged, requires manual conflict resolution.

5. Handling Unmerged Paths and Conflicts

During conflicts, Git reports unmerged paths and prompts manual resolution.
Commands to resolve conflicts involve:
- Editing conflicting files.
- Running:
  BASH
```
git add <resolved-files>
git commit -m "Resolved merge conflicts"
```
Alternatively, you can abort merges with:
BASH
```
git merge --abort
```

6. Managing Uncommitted Changes and Branch Switching

Switching branches with uncommitted changes that affect files in the target branch can result in errors to prevent data loss.
Commands to manage changes before switching branches:
- Stash changes (Not specified in video) or
- Discard changes using:
  BASH
```
git restore <file>
git restore .
```
Aborting branch switches or checking status with:
BASH
```
git status
```

7. Viewing and Comparing Changes

Commands for inspecting work and history:

Check repository status:
BASH
```
git status
```
View diff for all unstaged changes:
BASH
```
git diff
```
View diff for specific file:
BASH
```
git diff <file>
```
View commit logs (compact and one-line format):
BASH
```
git log --oneline
```
Compare differences between two commits:
BASH
```
git diff <commit1> <commit2>
```
Observe how order of commits affects the diff output.

8. HEAD and Branch Pointers: Internal Git Structure

.git/refs/heads/ directory contains files named after branches holding commit hashes.
HEAD points to the current branch ref, facilitating quick switching.
This internal structure explains command behaviors and branch manipulation efficiency.

9. Best Practices and General Advice

Commit messages:
- Meaningful messages are recommended but no strict rule on tense or style.
- Good commit messages assist in collaboration and project history maintenance.
Always ensure branches are updated regularly from master to minimize conflicts.
Clean up merged or obsolete branches to maintain clarity.
Practical usage over memorization—active practice leads to familiarity with commands like switch, checkout, and branch.

Summary Table: Core Git Commands Covered

Command	Purpose
`git branch`	List branches or create a new branch
`git switch <branch>`	Switch to another branch
`git switch -c <branch>`	Create and switch to new branch
`git checkout <branch>`	(Alternative) Switch branch
`git checkout -b <branch>`	(Alternative) Create and switch
`git branch -d <branch>`	Delete a merged branch
`git branch -D <branch>`	Force delete a branch
`git branch -m <old> <new>`	Rename a branch
`git commit -m "message"`	Commit staged changes with a message
`git add <file>`	Stage changes
`git merge <branch>`	Merge specified branch into current branch
`git merge --abort`	Abort a merge in case of conflicts
`git diff`	Show changes between working directory and index
`git log --oneline`	Show commit history in compact form
`git restore <file>`	Discard changes from working directory

Key Takeaways

Branches encapsulate independent development streams, enabling multiple features or fixes concurrently.
Branch management commands are essential for effective Git workflow.
Merging involves either fast-forward or merge commits, with conflicts requiring manual resolution.
Understanding branch pointers and HEAD demystifies Git’s underlying version handling.
Regularly updating branches and cleaning obsolete branches helps maintain a streamlined repository.
Learning through practical operations enhances command retention and reduces confusion between similar commands (switch vs checkout, etc.).

This foundational knowledge empowers developers to manage Git workflows confidently, optimize collaboration, and handle complex version control scenarios efficiently.