
Explore how git serves as a version control system that tracks changes through commits, enabling snapshots, history navigation, and line-by-line diffs.
Provide a brief course review to help improve future iterations of this practical Git and GitHub course, using one or two sentences.
Learn the basics of Git concepts such as commits, snapshots, and commit id, from init to log, plus untracked, staged, and tracked states.
Initialize a git repository for your new project, create and add files to the staging area, and commit with descriptive messages; review progress with git status and git log.
Modify content with Git by deleting a file, creating a folder, and staging changes. Commit with a descriptive message like 'shake and bake,' and view history with Git log.
Practice this optional project reinforces git fundamentals by initializing a repository, creating and merging feature and bug fix branches, rebasing, and deleting branches to solidify workflows.
learn to use git stash to switch branches, stash changes, and reapply with stash pop on return to the feature branch; beware tracked versus untracked changes when switching branches.
Explore how git head tracks your current position and how detached head occurs, then learn the git reflog command to view head changes, checkouts, merges, and recover commits.
Practice real-world git workflows by initializing a repo, configuring user data, making commits, using stash, exploring detached heads and branches, and mastering resets, reflog, and cleaning untracked files.
Apply git rebase to replay feature and bug fix commits on top of main, compare current versus incoming changes, resolve conflicts, and learn how rebasing differs from merging.
Learn how git and GitHub work together to store and backup your code online, push and pull changes, manage branches, and deploy to a hosting provider.
Create and push a GitHub repository from VS Code. Connect it to Netlify to host a static site with an index.html and main.css, enabling continuous deployment from GitHub.
In practical git and GitHub workflows, learn how to use git fetch to update remotes and cherry-pick a specific commit from a teammate’s feature branch.
Course Description:
This hands-on course is your complete guide to mastering Git and GitHub, starting from absolute basics and progressing through real-world, production-level workflows. You'll not only learn how Git works—you'll use it in structured projects, exercises, and challenges that mimic how modern development teams operate.
Section 1: Git Fundamentals & Setup
You'll begin by understanding what Git is and why it's essential for version control. In this section, you'll:
Install and configure Git globally and locally.
Learn how Git tracks code history and changes.
Explore critical commands like git init, git status, git add, and git commit.
Understand the difference between tracked, untracked, staged, and modified files.
Build your first Git project from scratch using the command line and VSCode.
Section 2: Exploring Commits & History
Dig deeper into Git internals and learn how to:
View detailed commit logs using git log and git log --oneline.
Navigate between commits with git checkout <hash>.
Understand HEAD and the concept of a detached HEAD.
Safely recover lost commits using git reflog.
Section 3: Branching, Merging & Rebase Workflows
You'll learn how teams manage parallel workstreams with branches and bring everything back together:
Create, switch, and delete branches.
Perform Fast-Forward and Three-Way merges.
Use git rebase to create a clean, linear history.
Compare merge vs rebase visually using Git log and VSCode GUI.
Resolve merge conflicts manually and understand common scenarios.
Section 4: Advanced Git Techniques
Go beyond the basics and unlock Git’s full power:
Perform soft and hard resets (git reset --soft, --hard, --mixed).
Unstage and discard changes using git restore and git checkout.
Clean untracked files with git clean.
Use .gitignore to exclude sensitive and temporary files.
Stash in-progress work and safely apply it later (git stash).
Section 5: Commit Squashing & Cherry-Picking
Understand how to craft clean and focused commit histories:
Use git rebase -i to squash commits interactively.
Learn how to apply individual commits from other branches using git cherry-pick.
Practice real scenarios that simulate production cherry-picking across cloned repositories.
Section 6: Working with GitHub
Push your local skills into the cloud and collaborate like a pro:
Create a GitHub repo and connect via SSH.
Push and pull branches, configure remotes, and set up upstream tracking.
Learn the difference between git fetch and git pull.
Use GitHub UI and VSCode to publish branches and manage repos.
Section 7: Real-World GitHub Workflows
Work through end-to-end collaborative GitHub challenges:
Clone repositories and simulate multiple developer environments (dev1, dev2, dev3).
Create and merge branches using pull requests.
Perform merge and rebase-based strategies for integrating code.
Explore GitHub branching models and workflow decisions.
Practice Challenges Throughout
Each section includes exercises and challenges to reinforce concepts:
Build isolated Git projects for hands-on repetition.
Simulate team-based workflows using multiple local environments.
Apply real-world recovery tools like reflog, stash, and cherry-pick.