Mastering Git: A Comprehensive Guide

Git is the backbone of modern software development. Whether you’re working solo or collaborating with a team, understanding Git is essential. This guide will take you from the basics to advanced concepts.

What is Git?

Git is a distributed version control system created by Linus Torvalds in 2005. Unlike centralized systems, every developer has a complete copy of the repository, including its full history. This makes Git fast, flexible, and resilient.

Why Git Matters

• Version Control: Track every change to your codebase
• Collaboration: Work with teams without conflicts
• Branching: Experiment without breaking production code
• History: Time-travel through your code’s evolution
• Backup: Distributed nature means multiple backups

Core Concepts

The Three States

Git has three main states that your files can be in:

1. Modified: You’ve changed the file but haven’t committed it yet
2. Staged: You’ve marked a modified file to go into your next commit
3. Committed: The data is safely stored in your local database

# Working Directory → Staging Area → Repository
git add file.txt    # Move to staging
git commit -m "msg" # Move to repository

The Git Workflow

# 1. Make changes in working directory
echo "Hello" > README.md

# 2. Stage changes
git add README.md

# 3. Commit changes
git commit -m "Add README"

# 4. Push to remote
git push origin main

Getting Started

Initial Setup

Configure Git with your identity:

# Set your name and email
git config --global user.name "Your Name"
git config --global user.email "your.email@example.com"

# Check your settings
git config --list

# Set default branch name
git config --global init.defaultBranch main

# Enable helpful colors
git config --global color.ui auto

Creating a Repository

# Initialize a new repository
git init

# Clone an existing repository
git clone https://github.com/user/repo.git

# Clone with a different name
git clone https://github.com/user/repo.git my-project

Essential Commands

Checking Status

# See what's changed
git status

# Short version
git status -s

# See differences
git diff              # Unstaged changes
git diff --staged     # Staged changes
git diff HEAD         # All changes

Adding and Committing

# Stage specific files
git add file1.txt file2.txt

# Stage all changes
git add .

# Stage all tracked files
git add -u

# Interactive staging
git add -p

# Commit with message
git commit -m "Fix bug in login"

# Commit and stage all tracked files
git commit -am "Quick fix"

# Amend the last commit
git commit --amend

Viewing History

# View commit history
git log

# Compact one-line format
git log --oneline

# With graph
git log --oneline --graph --all

# Last N commits
git log -5

# Search commits
git log --grep="bug fix"

# Show changes in commits
git log -p

# See who changed what
git blame file.txt

Branching and Merging

Branch Basics

Branches let you diverge from the main line of development without affecting it.

# List branches
git branch

# Create new branch
git branch feature-login

# Switch to branch
git checkout feature-login

# Create and switch (shortcut)
git checkout -b feature-login

# Modern way (Git 2.23+)
git switch feature-login
git switch -c feature-login  # Create and switch

Merging

# Merge a branch into current branch
git merge feature-login

# Merge with no fast-forward (creates merge commit)
git merge --no-ff feature-login

# Abort a merge
git merge --abort

Handling Merge Conflicts

When Git can’t automatically merge:

# 1. Conflict occurs during merge
git merge feature-branch
# CONFLICT (content): Merge conflict in file.txt

# 2. Open conflicted files and look for markers
# <<<<<<< HEAD
# Your changes
# =======
# Their changes
# >>>>>>> feature-branch

# 3. Edit file to resolve conflict

# 4. Mark as resolved
git add file.txt

# 5. Complete the merge
git commit

Remote Repositories

Working with Remotes

# List remotes
git remote -v

# Add a remote
git remote add origin https://github.com/user/repo.git

# Remove a remote
git remote remove origin

# Rename a remote
git remote rename origin upstream

# Change remote URL
git remote set-url origin https://new-url.git

Pushing and Pulling

# Push to remote
git push origin main

# Push and set upstream
git push -u origin main

# Push all branches
git push --all

# Force push (dangerous!)
git push --force

# Safer force push
git push --force-with-lease

# Pull changes
git pull origin main

# Pull with rebase
git pull --rebase

Fetching

# Download objects and refs from remote
git fetch origin

# Fetch all remotes
git fetch --all

# Fetch and prune deleted branches
git fetch --prune

Advanced Techniques

Rebasing

Rebase rewrites history to create a linear project history:

# Rebase current branch onto main
git rebase main

# Interactive rebase (last 3 commits)
git rebase -i HEAD~3

# Continue after resolving conflicts
git rebase --continue

# Abort rebase
git rebase --abort

Interactive Rebase Commands:

• pick: Keep commit as is
• reword: Change commit message
• edit: Stop for amending
• squash: Combine with previous commit
• drop: Remove commit

Cherry-Picking

Apply specific commits to current branch:

# Apply commit from another branch
git cherry-pick abc1234

# Apply multiple commits
git cherry-pick abc1234 def5678

# Apply without committing
git cherry-pick --no-commit abc1234

Stashing

Save work temporarily without committing:

# Stash changes
git stash

# Stash with message
git stash save "Work in progress on feature"

# List stashes
git stash list

# Apply most recent stash
git stash apply

# Apply and remove stash
git stash pop

# Apply specific stash
git stash apply stash@{2}

# Drop a stash
git stash drop stash@{0}

# Clear all stashes
git stash clear

# Stash including untracked files
git stash -u

Resetting and Reverting

# Soft reset (keep changes staged)
git reset --soft HEAD~1

# Mixed reset (keep changes unstaged) - default
git reset HEAD~1

# Hard reset (discard changes)
git reset --hard HEAD~1

# Reset specific file
git reset HEAD file.txt

# Revert a commit (creates new commit)
git revert abc1234

# Revert without committing
git revert --no-commit abc1234

Best Practices

Commit Messages

Write clear, meaningful commit messages:

# Good commit message structure:
# <type>: <subject>
# 
# <body>
# 
# <footer>

# Examples:
git commit -m "feat: Add user authentication"
git commit -m "fix: Resolve null pointer in login"
git commit -m "docs: Update API documentation"
git commit -m "refactor: Simplify database queries"

Commit Types:

• feat: New feature
• fix: Bug fix
• docs: Documentation changes
• style: Code style changes (formatting)
• refactor: Code refactoring
• test: Adding tests
• chore: Maintenance tasks

Branching Strategy

Common branching models:

Git Flow:

main          # Production-ready code
develop       # Integration branch
feature/*     # New features
release/*     # Release preparation
hotfix/*      # Production fixes

GitHub Flow (simpler):

main          # Always deployable
feature/*     # Feature branches

Workflow Tips

1. Commit often: Small, focused commits are better than large ones
2. Pull before push: Avoid conflicts by staying up to date
3. Use branches: Keep main branch stable
4. Review changes: Check git diff before committing
5. Write good messages: Future you will thank you
6. Don’t commit secrets: Use .gitignore for sensitive files

.gitignore Patterns

# Ignore node_modules
node_modules/

# Ignore all .log files
*.log

# Ignore all files in temp directory
temp/

# Ignore .env files
.env
.env.local

# Ignore OS files
.DS_Store
Thumbs.db

# Ignore IDE files
.vscode/
.idea/
*.swp

# But don't ignore specific file
!important.log

Troubleshooting

Common Issues

Accidentally committed to wrong branch:

# Move commit to new branch
git branch feature-branch
git reset --hard HEAD~1
git checkout feature-branch

Need to undo last commit:

# Keep changes
git reset --soft HEAD~1

# Discard changes
git reset --hard HEAD~1

Want to change last commit message:

git commit --amend -m "New message"

Accidentally deleted a file:

git checkout HEAD file.txt

Need to find when a bug was introduced:

# Binary search through commits
git bisect start
git bisect bad                 # Current version is bad
git bisect good v1.0          # v1.0 was good
# Git checks out middle commit, you test it
git bisect good               # or bad
# Repeat until found
git bisect reset              # When done

Advanced Git

Git Hooks

Automate tasks with Git hooks:

# Located in .git/hooks/
# Example: pre-commit hook
#!/bin/sh
npm run lint
npm run test

Git Aliases

Create shortcuts for common commands:

# Add aliases
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.ci commit
git config --global alias.st status
git config --global alias.unstage 'reset HEAD --'
git config --global alias.last 'log -1 HEAD'
git config --global alias.lg 'log --oneline --graph --all'

# Use them
git co main
git st
git lg

Submodules

Include other Git repositories in your project:

# Add submodule
git submodule add https://github.com/user/lib.git lib

# Clone repo with submodules
git clone --recursive https://github.com/user/repo.git

# Initialize submodules after clone
git submodule init
git submodule update

# Update submodules
git submodule update --remote

Git Under the Hood

Git stores data as snapshots, not differences. Each commit is a snapshot of all files at that moment.

Object Types

1. Blob: File contents
2. Tree: Directory structure
3. Commit: Snapshot with metadata
4. Tag: Named reference to commit

# Explore Git objects
git cat-file -p HEAD        # Show commit
git cat-file -p HEAD^{tree} # Show tree
git ls-tree HEAD            # List files in commit

Resources

• Pro Git Book - Free, comprehensive
• Git Documentation - Official docs
• GitHub Skills - Interactive learning
• Oh Shit, Git!?! - Fix common mistakes

Conclusion

Git is powerful but requires practice. Start with the basics (add, commit, push, pull) and gradually incorporate more advanced features. Don’t be afraid to experiment on branches - Git makes it hard to lose work permanently.

Remember: git reflog is your friend if things go wrong. It shows all reference updates, letting you recover “lost” commits.

Happy coding, and may your merges be conflict-free! 🚀