Git & Version Control

# macOS (using Homebrew)
$ brew install git

# Ubuntu/Debian
$ sudo apt update
$ sudo apt install git

# Windows
# Download from https://git-scm.com/download/win

# Verify installation
$ git --version
git version 2.39.0

# Set your name (shown in commits)
$ git config --global user.name "Your Name"

# Set your email (shown in commits)
$ git config --global user.email "your.email@example.com"

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

# Set default text editor
$ git config --global core.editor "code --wait"  # VS Code
$ git config --global core.editor "vim"          # Vim

# View your configuration
$ git config --list

# View specific setting
$ git config user.name

# Create a new project directory
$ mkdir my-project
$ cd my-project

# Initialize Git repository
$ git init
Initialized empty Git repository in /Users/you/my-project/.git/

# Create a file
$ echo "# My Project" > README.md

# Check status
$ git status
On branch main
Untracked files:
  (use "git add <file>..." to include in what will be committed)
        README.md

# Stage the file
$ git add README.md

# Check status again
$ git status
On branch main
Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
        new file:   README.md

# Commit the change
$ git commit -m "Initial commit: Add README"
[main (root-commit) a1b2c3d] Initial commit: Add README
 1 file changed, 1 insertion(+)
 create mode 100644 README.md

# Clone a repository from GitHub
$ git clone https://github.com/username/repository.git
Cloning into 'repository'...
remote: Counting objects: 100, done.
remote: Compressing objects: 100% (80/80), done.
Receiving objects: 100% (100/100), done.

$ cd repository

# You now have a complete copy with full history
$ git log --oneline
a1b2c3d Fix bug in login
e4f5g6h Add user authentication
i7j8k9l Initial commit

# Start your day - get latest changes
$ git pull
Already up to date.

# Make some changes to your code
$ vim app.js
$ vim styles.css

# See what changed
$ git status
On branch main
Changes not staged for commit:
  modified:   app.js
  modified:   styles.css

# Review your changes
$ git diff app.js

# Stage specific files
$ git add app.js styles.css

# Or stage everything
$ git add .

# Commit with a descriptive message
$ git commit -m "Add user authentication feature"
[main f8e7d6c] Add user authentication feature
 2 files changed, 45 insertions(+), 3 deletions(-)

# Push to remote
$ git push
To github.com:username/project.git
   a1b2c3d..f8e7d6c  main -> main

# List all branches (* = current branch)
$ git branch
* main
  feature/authentication

# Create new branch
$ git branch feature/new-ui

# Switch to branch
$ git checkout feature/new-ui
Switched to branch 'feature/new-ui'

# Create AND switch in one command (recommended)
$ git checkout -b feature/payment
Switched to a new branch 'feature/payment'

# Modern syntax (Git 2.23+)
$ git switch -c feature/dashboard
Switched to a new branch 'feature/dashboard'

# Make changes and commit
$ echo "New feature code" > feature.js
$ git add feature.js
$ git commit -m "Add payment processing"

# Switch back to main
$ git checkout main

# Merge your feature branch
$ git merge feature/payment
Updating a1b2c3d..f8e7d6c
Fast-forward
 feature.js | 1 +
 1 file changed, 1 insertion(+)

# Delete branch after merging
$ git branch -d feature/payment
Deleted branch feature/payment (was f8e7d6c).

# View remotes
$ git remote -v
origin  https://github.com/username/project.git (fetch)
origin  https://github.com/username/project.git (push)

# Add a remote
$ git remote add origin https://github.com/username/project.git

# Remove a remote
$ git remote remove origin

# Rename a remote
$ git remote rename origin upstream

# Push to remote (first time)
$ git push -u origin main
# -u sets upstream, so next time just: git push

# Pull before you push (avoid conflicts)
$ git pull
$ git push

# Push a new branch
$ git push -u origin feature/new-ui

# Delete remote branch
$ git push origin --delete feature/old-feature

# Basic log
$ git log
commit f8e7d6c2a1b3e4f5g6h7i8j9k0l1m2n3o4p5q6r7
Author: Your Name <your.email@example.com>
Date:   Mon Jan 19 14:30:00 2026 -0500

    Add user authentication feature

# Compact one-line format (most useful)
$ git log --oneline
f8e7d6c Add user authentication feature
a1b2c3d Fix navigation bug
e4f5g6h Update dependencies
i7j8k9l Initial commit

# Show last N commits
$ git log --oneline -5

# Show commits with file changes
$ git log --stat

# Visual graph of branches
$ git log --oneline --graph --all
* f8e7d6c (HEAD -> main) Merge feature
|\
| * d5c4b3a Add feature
|/
* a1b2c3d Fix bug
* e4f5g6h Initial commit

# Search commits by message
$ git log --oneline --grep="authentication"

# Show commits by author
$ git log --author="Your Name"

# Show commits in date range
$ git log --since="2 weeks ago" --until="yesterday"

# Show unstaged changes
$ git diff

# Show staged changes
$ git diff --staged

# Compare branches
$ git diff main..feature/new-ui

# Show changes in specific file
$ git diff README.md

# Show changes between commits
$ git diff a1b2c3d..f8e7d6c

# Made a typo in commit message?
$ git commit --amend -m "Correct message"

# Forgot to add a file?
$ git add forgotten_file.txt
$ git commit --amend --no-edit

# Want to temporarily save changes?
$ git stash
Saved working directory and index state

# Bring stashed changes back
$ git stash pop

# View stashed changes
$ git stash list

$ git merge feature/new-ui
Auto-merging app.js
CONFLICT (content): Merge conflict in app.js
Automatic merge failed; fix conflicts and then commit the result.

$ git status
On branch main
You have unmerged paths.

Unmerged paths:
  (use "git add <file>..." to mark resolution)
        both modified:   app.js

// app.js content with conflict:
function greet() {
<<<<<<< HEAD
  console.log("Hello World");
=======
  console.log("Hi there!");
>>>>>>> feature/new-ui
}

# 1. Open the conflicted file
$ vim app.js

# 2. Choose which version to keep (or combine them)
// Remove conflict markers and edit to:
function greet() {
  console.log("Hello World"); // Kept this version
}

# 3. Stage the resolved file
$ git add app.js

# 4. Complete the merge
$ git commit -m "Resolve merge conflict in app.js"

# Conflict resolved!

1. Fork the repository on GitHub
   (Creates your own copy)
   
2. Clone your fork locally
   $ git clone https://github.com/YOUR-USERNAME/project.git
   
3. Create a branch for your work
   $ git checkout -b feature/my-feature
   
4. Make changes and commit
   $ git add .
   $ git commit -m "Add awesome feature"
   
5. Push to your fork
   $ git push origin feature/my-feature
   
6. Open Pull Request on GitHub
   (Request to merge your changes into original repo)
   
7. Code review & discussion
   
8. Merge (by maintainer)
   
9. Update your fork
   $ git checkout main
   $ git pull upstream main

git checkout -b develop main
git checkout -b feature/new-microservice develop
# Work and commit
git checkout develop
git merge --no-ff feature/new-microservice

git checkout -b feature/event-handler main
# Work and commit
git push origin feature/event-handler
# Create Pull Request, review, merge

git checkout -b short-feature main
# Small changes, commit
git push origin short-feature
# PR, quick merge to main

# Format: <type>(<scope>): <subject>

feat(auth): add OAuth2 login
fix(api): resolve null pointer in user endpoint
docs(readme): update installation instructions
style(css): fix button alignment
refactor(db): optimize query performance
test(auth): add login unit tests
chore(deps): update dependencies

# Types:
feat     - New feature
fix      - Bug fix
docs     - Documentation
style    - Formatting, no code change
refactor - Code restructuring
test     - Adding tests
chore    - Maintenance, dependencies

# Setup
git config --global user.name "Your Name"
git config --global user.email "you@example.com"

# Start
git init                    # New repo
git clone <url>             # Copy existing repo

# Daily Workflow
git status                  # Check status
git add <file>              # Stage file
git add .                   # Stage all
git commit -m "message"     # Commit
git pull                    # Get updates
git push                    # Send commits

# Branching
git branch                  # List branches
git branch <name>           # Create branch
git checkout <name>         # Switch branch
git checkout -b <name>      # Create + switch
git merge <branch>          # Merge branch
git branch -d <name>        # Delete branch

# Viewing
git log --oneline           # View history
git diff                    # See changes

# Undoing
git restore <file>          # Discard changes
git restore --staged <file> # Unstage
git commit --amend          # Fix last commit
git revert <commit>         # Safe undo

# Remote
git remote -v              # View remotes
git push origin <branch>   # Push branch
git pull origin <branch>   # Pull branch