Git Basics: Hands-On Version Control For Beginners

Master Git Basics: Dive into Staging, Branching, Merging, & Rebasing

What you'll learn

Master version control fundamentals and “time travel” with Git.

Initialize repositories, track changes, and maintain a clean commit history.

Grasp Git’s three-state architecture for precise staging and committing.

Practice branching, merging, and conflict resolution to manage code effectively.

Use commits to save, revert, and compare project snapshots.

Explore rebase to keep your commit history clean and streamlined.

Stage changes selectively and undo mistakes with checkout, restore, and amend.

Set up remote repositories on GitHub for collaborative development.

Fetch, pull, and push updates to sync local and remote branches.

Fork repositories, open pull requests, and contribute to open-source projects.

Harness .gitignore to manage build artifacts and untracked files.

Visualize branch histories, inspect diffs, and revert to older commits.

Apply branching strategies, merges, and rebases for smoother code collaboration.

Requirements

Basic familiarity with any programming language or coding environment

A computer running Windows, macOS, or Linux

Internet connection to download Git and access GitHub

Willingness to use a command-line interface (terminal)

Description

Git is the world’s leading version control system, powering everything from the smallest open-source projects to the largest enterprise codebases. In this course, you’ll learn not just how to commit and push changes, but how to truly master Git’s core concepts so you can tackle any workflow challenge with confidence. We start by exploring the fundamentals—initializing repositories, staging files, and committing snapshots—so you gain a rock-solid understanding of Git’s three-state architecture. Then, you’ll dive deeper into branching, merging, and the powerful rebase command to maintain a clean, linear history. If you’ve ever struggled with merge conflicts or wondered how to keep your branches from falling out of sync, our detailed conflict-resolution tutorials will give you the hands-on practice you need.Beyond local operations, we’ll walk you through collaborative workflows on GitHub, teaching you how to fork repositories, clone projects, make pull requests, and stay in sync with remote teams. You’ll discover how to use .gitignore for managing unwanted files, explore advanced commands for viewing your commit history, and even practice reverting to older commits in “detached HEAD” mode. Each lesson is packed with real-world examples and practical tips that can streamline your daily development.This course is ideal for programmers using Git in their professional work environments as well as those gearing up for software job interviews. By the end, you’ll have the know-how to confidently manage code changes, coordinate with collaborators, and commit error-free. Gain the skills that top companies demand—and keep your projects organized, efficient, and future-proof.

Overview

Section 1: Welcome!

Lecture 1 Message from the instructor

Section 2: Managing versions with Git

Lecture 2 What does a version control system do?

Lecture 3 Git and Github - high level workflows

Lecture 4 Installing git

Lecture 5 Initializing repository

Lecture 6 Git two stage commit explained

Lecture 7 The three state architecture

Lecture 8 Selectively staging and committing

Lecture 9 Think Changes Not Files!

Lecture 10 Commit message editor

Lecture 11 Seeing previous commits

Lecture 12 Committing a file delete

Lecture 13 Looking at code changes in commit history

Lecture 14 Clearing local changes with git checkout

Lecture 15 Unstaging files with git restore

Lecture 16 Amending your last commit

Lecture 17 Viewing diff of your changes

Lecture 18 Using gitignore

Section 3: Branching and merging

Lecture 19 Understanding a git commit

Lecture 20 Branching concepts

Lecture 21 Understanding branching with Git

Lecture 22 Creating and switching between branches

Lecture 23 Committing to a branch

Lecture 24 Understanding branch pointers and commits

Lecture 25 Fast forward merge

Lecture 26 Merge with commit

Lecture 27 Resolving merge conflicts

Lecture 28 Git log with branches

Lecture 29 Deleting branches

Lecture 30 Switching to an older commit

Lecture 31 Detached head - understanding and fixing

Lecture 32 Rebasing explained - what and why

Lecture 33 Doing a rebase

Section 4: Working with remote repositories

Lecture 34 Cloning a remote repository

Lecture 35 Committing to a cloned repo

Lecture 36 Making changes to the remote repo

Lecture 37 Understanding remote branches

Lecture 38 Checking out remote branches and handling detached head

Lecture 39 Examining and fetching from remote using git fetch

Lecture 40 Syncing remote changes with local

Lecture 41 Using git pull

Lecture 42 Fetching, merging and pushing from other remote branches

Lecture 43 Git fetch vs pull

Lecture 44 Doing git pull with rebase

Section 5: Basic Github workflow

Lecture 45 Forking a repository

Lecture 46 Making a pull request

Section 6: Next Steps

Lecture 47 Conclusion

Programmers preparing for technical interviews who want a solid Git foundation,Software developers aiming to streamline their version control workflows,Anyone looking to manage project files and collaborate with teams effectively,Students or professionals transitioning into coding roles and needing real-world Git skills