Git Fundamentals Guide: Commands & Concepts Explained

Git Fundamentals Guide: Commands & Concepts Explained

What is Git?

Git is a distributed version control system that tracks changes in your files over time. Think of it as a sophisticated "undo" system for your code that also lets you collaborate with others without overwriting each other's work.

Imagine you're writing a book. Git lets you save snapshots of your work at different stages, go back to any previous version, and even create alternate storylines (branches) to experiment without affecting your main draft.

Key characteristics:

Distributed: Every developer has a complete copy of the project history on their machine
Fast: Most operations work locally, so they're lightning quick
Free and open-source: Created by Linus Torvalds in 2005 for Linux kernel development

Why Git is Used

Git solves several critical problems in software development:

Collaboration: Multiple developers can work on the same project simultaneously without conflicts. Git intelligently merges changes and highlights conflicts when they occur.

Version History: Every change is recorded with who made it, when, and why. You can revert to any previous state if something breaks.

Experimentation: Create separate branches to try new features without risking your stable code. If the experiment works, merge it back; if not, delete the branch.

Backup and Recovery: Your entire project history is distributed across multiple machines, making data loss nearly impossible.

Professional Standard: Git is the industry standard for version control, used by companies from startups to tech giants like Google, Microsoft, and Facebook.

Git Basics and Core Terminologies

Understanding these concepts is essential to working with Git effectively:

Repository (Repo): A repository is your project folder that Git tracks. It contains all your files plus a hidden .git folder where Git stores its tracking data. You can have local repositories on your computer and remote repositories on platforms like GitHub or GitLab.

Working Directory: This is your actual project folder where you create, edit, and delete files. It's what you see in your file explorer.

Staging Area (Index): Think of this as a preparation zone. When you finish working on some files, you add them to the staging area before committing. This lets you control exactly what changes go into each commit.

Commit: A commit is a snapshot of your project at a specific moment. Each commit has a unique ID (hash), a message describing what changed, and metadata like author and timestamp. Commits form the history of your project.

Branch: A branch is an independent line of development. The default branch is usually called main or master. You can create new branches to work on features, then merge them back when complete.

HEAD: HEAD is a pointer that shows you which commit you're currently viewing or which branch you're working on. Usually, HEAD points to the latest commit on your current branch.

Remote: A remote is a version of your repository hosted elsewhere (like GitHub). You can push your commits to remotes and pull others' commits from them.

Clone: Creating a complete copy of a remote repository on your local machine.

Merge: Combining changes from different branches into one branch.

Conflict: When Git can't automatically merge changes because the same lines were modified differently in two branches.

Visual Flow: How Git Work

Common Git Commands

Setting Up Git


git config --global user.name "Awdhesh kumar"
git config --global user.email "awdheskumar@gmail.com"

//Check your settings
git config --list

Starting a Repository

//Create a new repository in current directory
git init

// Clone an existing repository
git clone https://github.com/Awdhesh9860

Checking Status and History

// See which files are modified, staged, or untracked
git status

//View commit history
git log

//View condensed log (one line per commit)
git log --oneline

//View log with branch graph
git log --graph --oneline --all

Making Changes

//Stage a specific file
git add filename.txt

//Stage all modified files
git add .

// Commit staged changes with a message
git commit -m "Add user authentication feature"

// Stage and commit in one step (only for tracked files)
git commit -am "Fix navigation bug"

Working with Branches

//List all branches
git branch

//Create a new branch
git branch feature-login

//Switch to a branch
git checkout feature-login

//Create and switch to a new branch in one command
git checkout -b feature-dashboard

// Modern alternative to checkout (Git 2.23+)
git switch feature-login
git switch -c feature-new-branch

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

//    Delete a branch
git branch -d feature-login

Syncing with Remote Repositories

// View remote repositories
git remote -v

// Add a remote repository
git remote add origin https://github.com/Awdhesh9860

//Push commits to remote
git push origin main

// Pull changes from remote
git pull origin main

// Fetch changes without merging
git fetch origin

Undoing Changes

// Unstage a file (keep changes in working directory)
git reset filename.txt

// Discard changes in working directory
git checkout -- filename.txt

// Undo last commit but keep changes staged
git reset --soft HEAD~1

// Undo last commit and unstage changes
git reset HEAD~1

//Undo last commit and discard changes (dangerous!)
git reset --hard HEAD~1

// View what changed in a file
git diff filename.txt

Basic Developer Workflow

Starting a New Project

# Create project folder
mkdir my-website
cd my-website

# Initialize Git
git init

# Create your first file
echo "# My Website" > README.md

# Check status
git status
# Output: README.md is untracked

# Stage the file
git add README.md

# Commit with a message
git commit -m "Initial commit: Add README"

# View history
git log

Working on a Feature

# Create a new feature branch
git checkout -b add-homepage

# Create and edit files
echo "<h1>Welcome</h1>" > index.html

# Stage and commit
git add index.html
git commit -m "Add homepage with welcome message"

# Switch back to main branch
git checkout main

# Merge the feature
git merge add-homepage

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

Collaborating with Others

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

# Push your code
git push -u origin main

# Later, when working with a team...
# Pull latest changes before starting work
git pull origin main

# Make your changes, commit them
git add .
git commit -m "Update navigation menu"

# Push your changes
git push origin main