Mastering Git — From Basics to Advanced
Course Curriculum
12 modules designed to master the subject.
Module 1: Introduction to Git
Learn the foundations of version control and the architecture of Git.
Module 1 Lesson 1: What is Git and why use version control
Discover the foundations of version control. Learn how Git helps you track changes, collaborate, and travel back in time through your code's history.
Module 1 Lesson 2: Git vs other version control systems
Why did Git win the version control wars? We compare Centralized (CVCS) vs. Distributed (DVCS) systems and explore the advantages of the modern approach.
Module 1 Lesson 3: Git architecture: working directory, staging area, repository
Understand the 'Three Trees' of Git. Learn how your files move from your folder to the 'Index' and finally into the 'Git Repository' history.
Module 1 Lesson 4: Installing and configuring Git
Get Git up and running on your machine. We cover installation for all OSs and the essential configuration steps to identify yourself to Git.
Module 2: Creating and Managing Repositories
Initialize, clone, and configure your Git repositories.
Module 2 Lesson 1: Initializing a repository
Turn any folder on your computer into a Git repository. Learn when and how to use 'git init' to start tracking your project's history.
Module 2 Lesson 2: Cloning existing repositories
Don't reinvent the wheel. Learn how to download a full copy of a project—including its entire history—from platforms like GitHub using 'git clone'.
Module 2 Lesson 3: Repository structure (.git folder)
Demystify the 'Brain' of Git. Explore the contents of the hidden .git directory—from the object database to the config file—and learn how Git stores your history.
Module 2 Lesson 4: .gitignore and ignoring files
Not every file belongs in history. Learn how to use .gitignore to keep temporary files, sensitive secrets, and heavy dependencies out of your repository.
Module 3: Basic Git Workflow
Master the add, commit, log, and diff commands for daily development.
Module 3 Lesson 1: Staging changes with git add
Master the art of the Staging Area. Learn the different ways to use 'git add'—from staging individual files to interactive patching.
Module 3 Lesson 2: Committing changes with git commit
Seal the snapshot. Learn how to record your staged changes into history, write professional commit messages, and follow the 'Atomic Commit' philosophy.
Module 3 Lesson 3: Viewing history with git log
Travel through time. Learn how to use 'git log' to explore your project's history, filter commits by author or date, and visualize the tree of changes.
Module 3 Lesson 4: Undoing changes
Everyone makes mistakes. Learn the three levels of 'Undo' in Git—from discarding unstaged edits to rolling back the entire repository history.
Module 3 Lesson 5: Diffing changes
See exactly what changed. Master 'git diff' to compare your working folder against the staging area, and your staging area against your latest commit.
Module 4: Branching and Merging
Isolate features and merge changes with confidence.
Module 4 Lesson 1: Branch basics and naming conventions
Branching is Git's 'superpower.' Learn how branches allow you to work on multiple features in parallel without breaking your main project, and discover professional naming standards.
Module 4 Lesson 2: Creating and switching branches
Master the mechanics of branch management. Learn how to create new branches, navigate between them, and understand 'HEAD'—the pointer that tells Git where you are.
Module 4 Lesson 3: Merging branches
Bring the team together. Learn how to merge a feature branch back into 'main' and understand the basic workflow for combining disconnected histories.
Module 4 Lesson 4: Fast-forward vs three-way merges
Not all merges are the same. Learn the difference between a simple 'Fast-Forward' and the more complex 'Merge Commit' (Three-Way Merge) and when to use each.
Module 4 Lesson 5: Handling merge conflicts
Don't panic! Learn why merge conflicts happen, how to read Git's conflict markers, and the step-by-step process for resolving them manually.
Module 5: Remote Repositories
Collaborate with others using GitHub, GitLab, and Bitbucket.
Module 5 Lesson 1: Adding and removing remotes
Connect your local machine to the cloud. Learn how to manage 'Remotes'—the links that allow your repository to talk to GitHub, GitLab, or your team's private servers.
Module 5 Lesson 2: Pushing and pulling changes
Sync your work with the world. Master the 'git push' and 'git pull' commands to upload your local commits and download the latest changes from your teammates.
Module 5 Lesson 3: Fetch vs pull
Look before you leap. Learn the difference between 'git pull' and 'git fetch', and discover the professional workflow for inspecting remote changes before merging them.
Module 5 Lesson 4: Tracking remote branches
Understand the link between local and remote. Learn how 'Upstream Tracking' simplifies your workflow and how to manage branches that live in both worlds.
Module 5 Lesson 5: Deleting remote branches
Keep the server clean. Learn the commands for deleting branches on the remote server and how to 'prune' your local repo to remove stale references to deleted branches.
Module 6: Advanced Git Features
Stashing, rebasing, cherry-picking, and interactive tools.
Module 6 Lesson 1: Git stash: saving and restoring work in progress
Pause your work without committing. Learn how to use 'git stash' to temporarily set aside your changes so you can switch branches and fix urgent bugs without losing your progress.
Module 6 Lesson 2: Git rebase: linearizing history
Keep your history clean. Learn how 'git rebase' differs from 'git merge', and discover how to use it to create a perfectly linear project timeline that's easy to read.
Module 6 Lesson 3: Cherry-picking commits
Precision version control. Learn how to 'cherry-pick' a single commit from any branch and apply it to yours—perfect for grabbing a hotfix without the rest of a feature's changes.
Module 6 Lesson 4: Interactive rebase
Master the 'Refactor' for your history. Learn how to use 'git rebase -i' to squash commits, reorder history, and edit old commit messages to make your project look perfect.
Module 6 Lesson 5: Tagging and releases
Mark your milestones. Learn how to use 'git tag' to label specific points in history as important releases, and discover the difference between lightweight and annotated tags.
Module 7: Git Submodules
Manage complex multi-repository projects cleanly.
Module 7 Lesson 1: What are submodules and why use them
Master project architecture. Learn how Git Submodules allow you to keep one repository as a subdirectory of another while maintaining independent version control histories.
Module 7 Lesson 2: Adding submodules to a repository
Start building your architecture. Learn the 'git submodule add' command and understand how the .gitmodules file tracks your external dependencies.
Module 7 Lesson 3: Cloning repositories with submodules
Why is the folder empty? Learn how to correctly clone a project that uses submodules, and understand the difference between recursive clones and manual initialization.
Module 7 Lesson 4: Updating and synchronizing submodules
Stay up to date. Learn how to pull the latest changes from a submodule's remote and how to synchronize your parent project when a teammate updates a submodule's version.
Module 7 Lesson 5: Removing submodules
Cleanup your architecture. Learn the surprisingly manual process of removing a submodule, including updating the .gitmodules file and cleaning up Git's internal index.
Module 8: Git Workflows
Standardize team collaboration with GitFlow and PR-based workflows.
Module 8 Lesson 1: Centralized Workflow
Start simple. Learn the Centralized Workflow—the most basic way for teams to collaborate, where everyone works on 'main' and manages conflicts as they arise.
Module 8 Lesson 2: Feature Branch Workflow
The industry standard. Learn the Feature Branch Workflow—how to keep your 'main' branch stable by doing all your work in isolated feature branches and using Pull Requests for reviews.
Module 8 Lesson 3: Git Flow
Master the classic enterprise workflow. Learn Git Flow—a highly structured branching strategy designed for projects with scheduled release cycles and multiple versions in the wild.
Module 8 Lesson 4: GitHub Flow
Simple, fast, and agile. Learn GitHub Flow—the preferred workflow for modern web applications and teams that practice continuous delivery.
Module 8 Lesson 5: Trunk-Based Development
The peak of velocity. Learn Trunk-Based Development—the workflow used by the world's most elite engineering teams to deploy code hundreds of times per day.
Module 9: Collaboration Best Practices
Write better commit messages and maintain a clean project history.
Module 9 Lesson 1: Writing professional Pull Requests
Sell your code. Learn how to write Pull Requests (PRs) that are easy to review, provide clear context, and help your team merge your work faster with less friction.
Module 9 Lesson 2: Code review etiquette
Review like a human. Master the art of the code review—how to give constructive, empathetic feedback as a reviewer, and how to receive technical criticism as an author.
Module 9 Lesson 3: The 'Squash and Merge' vs 'Merge Commit' debate
How should your history look? Explore the pros and cons of 'Squash and Merge' vs 'Create a Merge Commit', and learn how to choose the right strategy for your team.
Module 9 Lesson 4: Handling feedback and requested changes
Navigate the feedback loop. Learn how to update your Pull Request after a reviewer asks for changes, and how to communicate your fixes effectively.
Module 10: Git Tips and Tricks
Aliases, bisecting, and advanced debugging techniques.
Module 10 Lesson 1: Using aliases for speed
Stop typing long commands. Learn how to create custom Git aliases to turn complex commands into short, 2-character shortcuts that save you hours of typing every month.
Module 10 Lesson 2: Search and Interactive staging
Find and filter like a pro. Learn how to use 'git grep' to search your codebase instantly and master 'git add --interactive' for the ultimate control over your workspace.
Module 10 Lesson 3: The git reflog for disaster recovery
Nothing is ever truly lost. Master the 'git reflog'—the secret diary that tracks every move you make in Git, allowing you to recover 'deleted' branches and abandoned commits.
Module 10 Lesson 4: Git hooks: Automating your local environment
Let Git do the work for you. Learn how to use Git Hooks—local scripts that trigger automatically before a commit or push—to catch bugs, run tests, and format your code.
Module 11: Real-World Projects
Apply your skills to simulation projects for teams and multi-module repos.
Module 11 Project A: Open Source Contribution Workflow
Join the global community. Follow this step-by-step project to master the 'Fork and Pull' model—the standard way that millions of developers contribute to open-source software on platforms like GitHub.
Module 11 Project B: CI/CD with Git
From Git to Live. Learn how Git acts as the heartbeat of modern automation. Understand how a 'git push' triggers complex pipelines that build, test, and deploy your software automatically.
Module 11 Project C: Troubleshooting a 'Broken' Repository
Emergency room for Git. Learn how to fix the most common 'Broken' states, from detached HEADs and locked indexes to messy rebases and accidental large file commits.
Module 12: Capstone Project
Design a production-ready repository structure and team workflow.
Module 12 Capstone Part 1: Architecture and Setup
The Final Test begins. In this Capstone Project, you will build a complex multi-repo system from scratch. Part 1 covers repository architecture, organization, and submodule integration.
Module 12 Capstone Part 2: Feature Development and Review
Build the feature. In Part 2 of the Capstone, you will practice the Feature Branch Workflow, use interactive rebase to polish your history, and simulate a professional code review loop.
Module 12 Capstone Part 3: Release and Emergency Fixes
Handle the pressure. In Part 3 of the Capstone, you will create an official release tag and then practice a high-stakes disaster recovery using the git reflog.
Module 12: Course Conclusion and Certification
You are a Git Master. Summarize your journey from 'git init' to 'reflog' and discover the advanced resources and career paths that await a version control expert.
Course Overview
Format
Self-paced reading
Duration
Approx 6-8 hours
Found this course useful? Support the creator to help keep it free for everyone.
Support the Creator