Git acts like a "time machine" for your work by letting you capture snapshots (commits) of your project at any moment. If you break something, you can rewind to a stable version. Want to test a risky idea? Create a branch—a parallel timeline—to experiment safely. If it fails, delete the branch; if it works, merge it into your main timeline. Git also logs who changed what and when, so you can track down bugs or recover deleted files. Like a safety net for creativity, it lets you explore fearlessly, knowing you can always undo mistakes.

• Git is like a supercharged "undo/redo" button for your projects. It lets you:

  • Save snapshots of your work (called commits).

  • Track who made changes, when, and why.

  • Collaborate without accidentally overwriting others’ work.

  Real-World Analogy:
  Imagine writing a book. With Git, you can:

  • Save drafts at every chapter (commits).

  • Experiment with alternate endings (branches).

  • Merge your editor’s notes seamlessly (collaboration).

• Collaboration: Work on the same codebase without overwriting others’ work.

  • Example: You and a teammate edit different files → Git merges them cleanly.

• History: See who changed what, when, and why.

  • Example: Track down when a bug was introduced using git log.

• Experimentation: Create branches to test ideas risk-free.

  • Example: Build a new feature in a branch without breaking the main app.

• Backup: Remote repositories (like GitHub) act as a safety net.

• Industry Standard: Used by 99% of tech teams (from startups to Google).

"I deleted my code by accident!"

Git lets you revert to any saved version.

"My teammate and I edited the same file!"

Git merges changes safely (most of the time!).

"What did I change yesterday?"

Git’s history shows you exactly what changed.

Developers, designers, writers, data scientists—anyone who works with files!

A hosted version of your repo (e.g., on GitHub, GitLab, or Bitbucket).

Why use it?

• Share code with others (e.g., open-source projects).
• Access your work from any device.
• Recover code if your laptop dies.

Example: You git push your local code to GitHub → Your teammate git pulls it.

Command Line (Terminal):

Pros: Full control, fastest for power users.

Example: git commit -m "Fix crash on login"

GUI Tools:

• GitHub Desktop, GitKraken, Sourcetree (visual, click-based interfaces).

IDE Integrations:

• Most code editors (VS Code, IntelliJ, PyCharm) have built-in Git buttons.

• VS Code: Commit, push, and resolve conflicts with a graphical interface.
• IntelliJ/PyCharm: Dedicated Git panel for diffing files and managing branches.
• Eclipse: Plugins for Git integration.
• Even Notepad++ has Git plugins!

Step 1: Install Git

• Windows/Mac/Linux: Download from git-scm.com.

Step 2: Introduce Yourself

git config --global user.name "Your Name"  
git config --global user.email "your@email.com"

This is like signing your work so others know who did what.

Create a Project Folder:

• mkdir recipe-site && cd recipe-site

Initialize Git:

• git init

This turns your folder into a Git-tracked project.
Add a File:

• Create index.html with basic HTML.

Save Your Work (Commit):

• git add index.html # Stage the file
• git commit -m "Create homepage skeleton"

Think of commits as "save points" you can return to.

A parallel workspace to test ideas without breaking the main project.

Example:
You want to redesign the navbar without affecting the live site.

git checkout -b new-navbar    # Create + switch to a new branch

• Edit index.html → test → commit.
• Happy with the design? Merge it back:

  git checkout main           # Go back to main branch  
  git merge new-navbar        # Bring in your changes

A cloud backup of your project

• A hosted version of your repo (e.g., on GitHub, GitLab, or Bitbucket).
• Why use it?
  • Share code with others (e.g., open-source projects).
  • Access your work from any device.
  • Recover code if your laptop dies.
• Example: You git push your local code to GitHub → Your teammate git pulls it.

Step 1: Push to GitHub

1. Create a repo on GitHub.
2. Link it to your local project:

   git remote add origin https://github.com/yourusername/recipe-site.git

3. Upload your code:

   git push -u origin main

Step 2: Collaborate

• Teammates can git clone your repo → make changes → git push updates.

What Happens:
Two people edit the same part of a file, and Git can’t automatically merge the changes.

Example:
You and your teammate both edited config.yml to add different database settings.

How to Fix It:

1. Identify the Conflict:

   git pull origin main  # Triggers a conflict message

2. Open the Conflicted File:

   <<<<<<< HEAD  
   database: mysql  
   =======  
   database: postgresql  
   >>>>>>> feature/db-update

   • HEAD: Your local changes.
   • feature/db-update: Incoming remote changes.
3. Edit the File (keep one version or combine both):

   database: postgresql  # Choose the correct value

4. Mark as Resolved:

   git add config.yml  
   git commit -m "Resolve database config conflict"

Pro Tip: Use VS Code’s built-in merge conflict tool for a visual fix!

The Problem: Both integrate changes from one branch to another, but with different histories.

Scenario: You’re working on feature/login while main gets updates.

Option 1: Merging

git checkout main  
git merge feature/login
Result: Creates a merge commit preserving branch history.
Use Case: Public branches (like main) where history clarity matters.

Option 2: Rebasing

git checkout feature/login  
git rebase main
Result: Moves your commits to the tip of main, creating a linear history.
Use Case: Private feature branches for cleaner logs.

Visual Difference:

Merging:                   Rebasing:  
* merge commit             * feature commit C  
| * feature commit C       * feature commit B  
| * feature commit B       * feature commit A  
|/                         * main commit 2  
* main commit 2            * main commit 1  
* main commit 1  

Golden Rule: Never rebase public branches (others might rely on their history).

Scripts that trigger automatically during Git events (e.g., commits, pushes).

Example 1: Pre-Commit Linter

• Ensure code quality before a commit.

1. Create .git/hooks/pre-commit:

   #!/bin/sh  
   npm run lint  # Fail commit if linting errors exist  

2. Make it executable:

   chmod +x .git/hooks/pre-commit  

Example 2: Auto-Versioning on Tag Push

• Bump your app’s version when a Git tag is pushed.

1. Create .git/hooks/post-push:

   if git describe --tags --exact-match HEAD; then  
     npm version patch  
   fi  

   Popular Hooks:

   • pre-commit: Run tests/linters.

   • prepare-commit-msg: Standardize commit messages.

   • post-receive: Deploy code to production after a push.

   Tools for Easy Hooks:

   • Husky (JavaScript): Simplify hook management in npm projects.

   • pre-commit (Python): Framework for reusable hooks.

Scenario: You’re adding a payment feature.

1. Branch & Develop:

   git checkout -b feature/payment

2. Rebase Weekly to Keep Updated:

   git fetch origin  
   git rebase origin/main  # Avoid merge commits in your branch

3. Automate Checks with Hooks:
   • Use pre-push to run unit tests before pushing.
4. Resolve Conflicts During PR:
   • Fix conflicts in GitHub/GitLab’s UI before merging.
5. Merge with Squash:

   git checkout main  
   git merge --squash feature/payment  # Single commit for the feature

 

• Rebasing keeps history clean for code reviews.

• Hooks enforce team standards (no more “but it worked on my machine!”).

• Conflict Resolution skills prevent teamwork bottlenecks.

1. Setup & Configuration

Define your Git identity (required before first commit)

git config --global user.name "John Doe"
git config --global user.email "john@example.com"
Example: Set your name/email to attribute commits correctly.

---

2. Starting a Project

Clone an existing repository:

git clone https://github.com/username/repo.git
Example: Download a project from GitHub to your local machine.

Initialize a new repository:

mkdir my-project && cd my-project  
git init
Example: Start version control for a new app.

---

3. Everyday Workflow

Check status of changes:
git status
Example: See which files are modified/staged.

Stage changes for commit:
git add file.txt # Stage a single file git add . # Stage all modified files
Example: Prepare changes to a login feature for saving.

Commit staged changes:
git commit -m "Add user login functionality"
Example: Save a snapshot of your progress with a clear message.

---

4. Branching & Merging

Create a new branch:

 

git branch feature/payment  
git checkout feature/payment  
# Or shortcut:  
git checkout -b feature/payment  
Example: Develop a payment system without disrupting the main code.

Merge branches:

git checkout main  
git merge feature/payment  
Example: Integrate the completed payment feature into the main app.

List all branches:
git branch
Switch branches:
git checkout main
Delete a branch:
git branch -d feature/payment  

---

5. Remote Repositories

Push changes to GitHub/GitLab:

git push origin main
Example: Upload your latest bug fix to the team’s remote repo.

Pull latest updates:

git pull origin main
Example: Sync your local code with changes made by teammates.

Link a local repo to a remote:

git remote add origin https://github.com/username/repo.git  

---

6. Undoing Mistakes

Discard unstaged changes:

git restore file.txt
Example: Revert accidental edits to config.yml.

Amend the last commit:

git commit --amend -m "Improved login error handling"
Example: Fix a typo in the previous commit message or add missed files.

Reset to a previous commit:

git reset --hard HEAD~1  # WARNING: Destructive!  
Example: Completely undo a bad commit.

---

7. Stashing

Temporarily save uncommitted work:

git stash  
git stash pop            # Restore the stash
Example: Pause work on a feature to fix an urgent bug.

---

8. Collaboration

Push local changes to GitHub/GitLab:

git push origin main
Example: Upload your bug fix so the team can access it.

Link local repo to a remote:

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

Fetch updates without merging:

git fetch
Example: Check if teammates pushed new code before merging.

View commit history:

git log --oneline --graph
Example: Track who changed the API endpoint last week.

---

9. Advanced (But Useful!)

Cherry-pick a commit:

git cherry-pick abc1234
Example: Apply a hotfix from main to a legacy branch.

Manage submodules:

git submodule add https://github.com/library/dependency.git  

Example: Include a shared UI component library.

---

10. Aliases for Speed

Create shortcuts in ~/.gitconfig:

[alias]  
  co = checkout  
  br = branch  
  ci = commit  
  st = status  

Example: Type git st instead of git status!

Pro Tips:

• Use git diff to see line-by-line changes before committing.
• Always test code after pulling and before pushing.
• Write clear commit messages (e.g., "Fix navbar overflow bug" not "Update code").

Final Project:

• Create a GitHub account.
• Make a repo for a mock project (e.g., travel blog).
• Practice: Add files, commit, branch, merge, and push!