Git Fundamentals: A Developer's Guide

What is Git?

Git is a distributed version control system (VCS) that helps developers track changes in their code over time. Think of it as a sophisticated time machine for your project—it takes snapshots of your code at different points, allowing you to revisit, compare, or restore any previous state.

Unlike traditional file systems where you might create copies like project_final.zip, project_final_v2.zip, or project_ACTUAL_final.zip, Git organizes these snapshots intelligently. Each snapshot (called a commit) is stored efficiently, and you can navigate through your project's entire history with simple commands.

Want to understand the chaos before version control systems? Check out my previous blog post: Chaos Before VCS to see why Git was such a game-changer for developers.

What Makes Git "Distributed"?

The term "distributed" means every developer has a complete copy of the project history on their local machine. You're not dependent on a central server to access your project's history—you have the full power of version control right on your computer. This makes Git fast, reliable, and perfect for both solo developers and large teams.

Why Git is Used

1. Collaboration Made Easy

Multiple developers can work on the same project simultaneously without overwriting each other's work. Git intelligently merges changes and highlights conflicts when they occur.

2. Complete History Tracking

Every change is recorded with information about who made it, when, and why. This creates an audit trail that's invaluable for understanding how your project evolved.

3. Experimentation Without Fear

Want to try a risky refactor or test a new feature? Create a branch and experiment freely. If it works, merge it back. If it doesn't, simply discard the branch. Your main code remains untouched.

4. Backup and Recovery

Made a mistake? Git lets you roll back to any previous state. Accidentally deleted an important file? It's still in your Git history.

5. Code Review and Quality

Git workflows enable peer review before changes are integrated, helping teams maintain code quality and share knowledge.

6. Industry Standard

Git is used by virtually every tech company and open-source project. Learning Git is essential for modern software development.

Basic Developer Workflow: A Practical Example

Let's walk through a typical workflow from scratch to see Git in action before diving into the terminology:

Step 1: Create a New Project

# Create project directory
mkdir my-awesome-app
cd my-awesome-app

# Initialize Git
git init

Step 2: Create Your First Files

# Create a README
echo "# My Awesome App" > README.md

# Create a simple HTML file
echo "<!DOCTYPE html><html><body><h1>Hello World</h1></body></html>" > index.html

Step 3: Make Your First Commit

# Check status
git status
# Shows: 2 untracked files

# Stage files
git add README.md index.html

# Check status again
git status
# Shows: 2 files ready to commit

# Commit with message
git commit -m "Initial commit: Add README and index.html"

Step 4: Develop a New Feature

# Create a feature branch
git checkout -b add-styling

# Create a CSS file
echo "body { font-family: Arial; background: #f0f0f0; }" > styles.css

# Link it in HTML (you'd edit index.html here)

# Stage and commit
git add styles.css
git commit -m "Add basic styling with CSS"

Step 5: Merge Your Feature

# Switch back to main
git checkout main

# Merge the feature
git merge add-styling

# Delete the feature branch (optional)
git branch -d add-styling

Step 6: Connect to GitHub

# Add remote repository
git remote add origin https://github.com/yourusername/my-awesome-app.git

# Push your code
git push -u origin main

Step 7: Daily Development Cycle

# Start your day: get latest changes
git pull origin main

# Create a branch for your work
git checkout -b fix-header-alignment

# Make changes to files...
# (edit, test, repeat)

# Check what changed
git status
git diff

# Stage changes
git add .

# Commit
git commit -m "Fix header alignment on mobile devices"

# Push to remote
git push origin fix-header-alignment

# Create pull request on GitHub (web interface)
# After review and approval, merge on GitHub
# Then update your local main:
git checkout main
git pull origin main

Git Basics and Core Terminologies

Now that you've seen Git in action, let's understand the terminology behind what we just did:

Repository (Repo)

A repository is your project folder tracked by Git. It contains all your project files plus a hidden .git directory where Git stores all the version history and configuration.

Commit

A commit is a snapshot of your project at a specific point in time. Each commit has:

A unique identifier (SHA hash)
Author information
Timestamp
A commit message describing the changes
A pointer to the previous commit(s)

Think of commits as save points in a video game—you can always return to them.

Branch

A branch is an independent line of development. The default branch is usually called main or master. Branches allow you to:

Develop features in isolation
Work on multiple ideas simultaneously
Keep your main code stable while experimenting

HEAD

HEAD is a pointer that indicates your current location in the Git history. It usually points to the latest commit on your current branch. When you switch branches, HEAD moves to point to that branch.

Working Directory

This is your project folder where you actually work on files—what you see in your file explorer.

Staging Area (Index)

The staging area is a middle ground between your working directory and the repository. It lets you carefully select which changes to include in your next commit.

Remote

A remote is a version of your repository hosted elsewhere (like GitHub, GitLab, or Bitbucket). It enables collaboration and serves as a backup.

Clone

Cloning creates a local copy of a remote repository, including its entire history.

Merge

Merging combines changes from different branches into one.

Conflict

A conflict occurs when Git can't automatically merge changes because the same lines were modified in different ways. You'll need to manually resolve these.

Common Git Commands

Setting Up Git

Configure your identity (do this once):

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

Check your configuration:

git config --list

Starting a Repository

Initialize a new repository:

git init

This creates a .git directory in your current folder, turning it into a Git repository.

Clone an existing repository:

git clone https://github.com/username/repository.git

Basic Workflow Commands

Check repository status:

git status

Shows which files are modified, staged, or untracked. Use this frequently!

Add files to staging area:

git add filename.txt          # Add specific file
git add folder/               # Add entire folder
git add .                     # Add all changes
git add *.js                  # Add all JavaScript files

Commit changes:

git commit -m "Add user authentication feature"

Always write clear, descriptive commit messages that explain what and why.

View commit history:

git log                       # Full history
git log --oneline            # Condensed view
git log --graph --all        # Visual branch graph

See what changed:

git diff                      # Unstaged changes
git diff --staged            # Staged changes
git diff commit1 commit2     # Compare commits

Branch Management

Create and switch branches:

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

List branches:

git branch                    # Local branches
git branch -a                # All branches (including remote)

Merge branches:

git checkout main            # Switch to target branch
git merge feature-login      # Merge feature into main

Delete branches:

git branch -d feature-login   # Delete merged branch
git branch -D feature-login   # Force delete

Remote Operations

View remotes:

git remote -v

Add a remote:

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

Push to remote:

git push origin main          # Push main branch
git push -u origin main       # Push and set upstream

Pull from remote:

git pull origin main          # Fetch and merge

Fetch without merging:

git fetch origin

Undoing Changes

Discard changes in working directory:

git checkout -- filename.txt

Unstage files:

git reset HEAD filename.txt

Undo last commit (keep changes):

git reset --soft HEAD~1

Undo last commit (discard changes):

git reset --hard HEAD~1

Revert a commit (creates new commit):

git revert commit-hash

Other Useful Commands

Show commit details:

git show commit-hash

Stash changes temporarily:

git stash                     # Save changes
git stash list               # View stashes
git stash apply              # Reapply changes
git stash pop                # Apply and remove from stash

Tag releases:

git tag v1.0.0
git tag -a v1.0.0 -m "Release version 1.0.0"

Conclusion

Git is an essential tool for modern software development. While it might seem complex at first, the core concepts are straightforward: snapshots of code (commits), parallel timelines (branches), and collaboration (remotes). Start with the basic commands, practice regularly, and you'll soon wonder how you ever coded without it.

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

Command Palette