What is Git - Deep Dive

Overview - What is Git

What is it?

Git is a tool that helps people keep track of changes in files, especially code. It lets multiple people work on the same project without losing each other's work. Git saves snapshots of your files over time, so you can go back to earlier versions if needed. It works on your computer and can connect to shared places online to share work.

Why it matters

Without Git, teams would struggle to work together on projects because changes could easily overwrite each other. People would lose work or spend a lot of time copying files manually. Git solves this by organizing changes clearly and safely, making teamwork smoother and faster. It also helps keep a history of the project, so mistakes can be fixed by going back in time.

Where it fits

Before learning Git, you should understand basic file management on your computer and simple command-line usage. After Git, you can learn about online code hosting services like GitHub or GitLab, and then move on to advanced topics like branching strategies and continuous integration.

Mental Model

Core Idea

Git is a smart diary that records every change you make to your files, letting you revisit or share any moment in your project's history.

Think of it like...

Imagine writing a story in a notebook where every time you finish a page, you take a photo of it. If you make a mistake later, you can look back at any photo to see how the story was before. Git works like that photo album for your files.

┌───────────────┐
│ Working Files │
└──────┬────────┘
       │ save changes
       ▼
┌───────────────┐
│   Git Repo    │
│ (Snapshots)   │
└──────┬────────┘
       │ share
       ▼
┌───────────────┐
│ Remote Server │
│ (GitHub etc.) │
└───────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding Version Control Basics

Concept: Version control means saving different versions of files so you can track changes over time.

Think of version control as saving multiple drafts of a document. Each draft shows what changed from the last one. This helps you see progress and fix mistakes by going back to earlier drafts.

Result

You understand why saving versions is useful and how it helps avoid losing work.

Knowing that version control is about tracking changes over time sets the foundation for why tools like Git exist.

2

Foundation

What Git Tracks and How

Concept: Git tracks changes by saving snapshots of your files, not just differences.

Instead of only saving what changed, Git takes a picture of all your files at a moment. If nothing changed, it reuses the old picture to save space. This makes Git fast and efficient.

Result

You see that Git stores complete snapshots, which helps it manage changes quickly and safely.

Understanding Git's snapshot model explains why it can quickly switch between versions and handle complex changes.

3

Intermediate

Working Locally and Remotely

Concept: Git works both on your computer and with remote servers to share work.

You make changes and save snapshots on your computer. Then you can send these snapshots to a remote server like GitHub to share with others. You can also get updates from others by downloading their snapshots.

Result

You know how local and remote repositories connect to enable teamwork.

Recognizing the local-remote relationship helps you understand collaboration workflows in Git.

4

Intermediate

Basic Git Commands Workflow

Concept: Git uses commands like add, commit, push, and pull to manage changes and sharing.

You first tell Git which files to save using 'git add'. Then you save a snapshot with 'git commit'. To share your work, you use 'git push'. To get others' changes, you use 'git pull'.

Result

You can perform the basic cycle of saving and sharing changes with Git commands.

Knowing these commands is essential to use Git effectively for daily work.

5

Intermediate

How Git Handles Conflicts

🤔Before reading on: do you think Git automatically fixes all conflicts when two people change the same file? Commit to yes or no.

Concept: When two people change the same part of a file, Git asks you to fix the conflict manually.

If Git can't decide which change to keep, it marks the conflict in the file. You then open the file, see both versions, and choose or combine them before saving.

Result

You understand that Git helps but needs your decision to resolve conflicting changes.

Knowing how conflicts work prevents confusion and helps you handle teamwork challenges smoothly.

6

Advanced

Branching and Merging Explained

🤔Before reading on: do you think branches in Git are copies of the whole project or just pointers to changes? Commit to your answer.

Concept: Branches are pointers to snapshots that let you work on different ideas without affecting the main project.

When you create a branch, Git makes a new pointer to the current snapshot. You can make commits on this branch independently. Later, you can merge the branch back to combine changes.

Result

You can create isolated workspaces and combine them safely using branches and merges.

Understanding branches as pointers clarifies why Git is fast and flexible for managing multiple work streams.

7

Expert

Git Internals: Objects and References

🤔Before reading on: do you think Git stores file contents as plain files or in a special database? Commit to your answer.

Concept: Git stores data as objects (blobs, trees, commits) in a database called the object store, linked by references.

Each file content is a blob object. Trees represent folders linking blobs and other trees. Commits point to trees and have metadata. Branches and tags are references pointing to commits. This structure makes Git efficient and powerful.

Result

You understand the low-level data structures that make Git fast and reliable.

Knowing Git's internal object model explains many advanced features and helps troubleshoot complex issues.

Under the Hood

Git uses a content-addressable storage system where every file and folder snapshot is stored as an object identified by a hash. Commits link these objects together forming a graph of project history. References like branches point to commits, allowing easy navigation and branching. When you commit, Git creates new objects and updates references without copying entire files, making operations fast and space-efficient.

Why designed this way?

Git was designed by Linus Torvalds to handle large projects like the Linux kernel with speed and reliability. Traditional version control systems copied files or stored only differences, which was slow or fragile. Git's snapshot and hashing approach ensures data integrity, quick branching, and easy merging, solving problems faced by earlier tools.

┌───────────────┐
│ Blob (File)   │
├───────────────┤
│ Content Hash  │
└──────┬────────┘
       │
┌──────▼────────┐
│ Tree (Folder) │
├───────────────┤
│ Links to blobs│
└──────┬────────┘
       │
┌──────▼────────┐
│ Commit Object │
├───────────────┤
│ Points to tree│
│ Metadata      │
└──────┬────────┘
       │
┌──────▼────────┐
│ References    │
│ (Branches)    │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does 'git commit' send your changes to the online server automatically? Commit yes or no.

Common Belief: Many think 'git commit' uploads changes to the remote server immediately.

Reality: 'git commit' only saves changes locally. You must use 'git push' to send changes to the remote server.

Why it matters: Confusing commit and push can cause people to think their work is shared when it is only saved locally, leading to lost collaboration.

Quick: Can Git track changes in files that are not added with 'git add'? Commit yes or no.

Common Belief: Some believe Git tracks all file changes automatically without any setup.

Reality: Git only tracks files that have been added to the repository with 'git add'. Untracked files are ignored until added.

Why it matters: Assuming all files are tracked can cause confusion when changes don't appear in commits.

Quick: Does deleting a branch delete the commits made on it forever? Commit yes or no.

Common Belief: Deleting a branch removes all its commits permanently.

Reality: Deleting a branch only removes the pointer. Commits remain in Git until garbage collected or unreachable.

Why it matters: Understanding this prevents panic and data loss fears when cleaning up branches.

Quick: Is Git a cloud service? Commit yes or no.

Common Belief: Many think Git is an online service like GitHub.

Reality: Git is a tool that runs on your computer. Services like GitHub use Git but add hosting and collaboration features.

Why it matters: Knowing this clarifies the difference between the tool and hosting platforms, avoiding confusion in workflows.

Expert Zone

1

Git's object model allows it to detect identical files across branches, saving space by reusing objects.

2

The staging area ('index') lets you prepare exactly what changes to include in the next commit, enabling fine control.

3

Git's hashing ensures data integrity; any corruption changes the hash, alerting you to problems.

When NOT to use

Git is not ideal for large binary files or very large repositories without special extensions. Alternatives like Git LFS or other version control systems may be better for those cases.

Production Patterns

Teams use branching strategies like Git Flow or trunk-based development to organize work. Continuous integration systems automatically test and merge code pushed to shared branches. Pull requests enable code review before merging.

Connections

Database Systems

Git's object storage is similar to how databases store data with references and indexes.

Understanding Git as a database of snapshots helps grasp its efficiency and integrity guarantees.

Time Travel in Physics

Git lets you move backward and forward through project history like time travel.

Seeing Git as a time machine clarifies how you can revisit any past state safely.

Collaborative Writing

Git's branching and merging mirror how multiple authors edit drafts and combine changes.

Knowing collaborative writing processes helps understand Git's conflict resolution and teamwork features.

Common Pitfalls

#1 Forgetting to add files before committing.

Wrong approach:

git commit -m "Update"

Correct approach:

git add
git commit -m "Update"

Root cause:

Misunderstanding that Git only commits files that have been staged with 'git add'.

#2 Pushing to the wrong branch and overwriting others' work.

Wrong approach:

git push origin main

Correct approach:

git push origin feature-branch

Root cause:

Not checking the current branch or remote branch before pushing.

#3 Ignoring merge conflicts and forcing merges.

Wrong approach:

git merge feature-branch --strategy=ours

Correct approach:

git merge feature-branch
# Resolve conflicts manually in files
# Then commit the merge

Root cause:

Trying to bypass conflict resolution leads to lost or incorrect code.

Key Takeaways

Git is a powerful tool that tracks changes by saving snapshots of your files over time.

It works locally on your computer and connects to remote servers to enable teamwork.

Basic Git commands let you save, share, and update your work safely and efficiently.

Branches let you work on different ideas without affecting the main project, and merges combine them later.

Understanding Git's internal object model reveals why it is fast, reliable, and flexible for managing code.