Git & GitHub Crash Course: Hands-On + Interview Prep Guide

Learn how to initialize a git repository with git init, set the initial branch (master, main, trunk, or development), and start tracking changes.

Master the git life cycle, including the working directory, staging area, and repository, and learn init, add, commit, push, pull, and undo with restore, reset, and revert.

Learn how to use git status to view the current working directory and staging area, identify untracked and changed files, and see how to stage changes with git add.

Learn how to use git add to move changes from the working directory to the staging area and committed area, track new changes, and prepare for the next commit.

Commit changes in git by moving updates from the working directory to the staging area and then to the repository, creating a snapshot with a concise -m message.

Undo staging by using two commands—git restore stage <file> and git rm cached <file>—to move items from the staging area back to untracked in your working directory.

Master git logs to view commit history with author dates and messages, and use oneline, -p, and --stat options to trace changes and file edits for debugging and auditing.

Understand how dot gitignore hides files and prevents tracking in version control, keeping logs, dependencies, and local environment configs out of production by using root dot gitignore patterns.

Master the git lifecycle from init to commit and push. Use the working directory, staging area, and git add and git commit for pushing to GitHub or Bitbucket.

Explore git help and git manual to view command syntax, usage, and documentation for git commands; learn how to access detailed help for any command with examples.

Learn how to create a GitHub account to move from local git to a remote repository, including signing up on github.com, choosing a unique username, and verifying your account.

Discover the GitHub UI and dashboard, create remote repositories for collaboration, explore projects, and manage profile, settings, and themes, including Copilot, enterprise options, and GitHub actions.

Create a public repository on GitHub with name, description, readme, .gitignore, license, and default branch, then clone via https, ssh, or GitHub CLI and explore issues, pull requests, and actions.

Create and manage files directly in a remote GitHub repository using the console, including creating new files, uploading, and committing to main or new branches.

Push local commits to a remote GitHub repository using git push, with token-based authentication on https to keep the remote origin main up to date and share changes with teammates.

Clone a repository securely using ssh, generate RSA keys, add the public key to GitHub, and clone via the ssh url for passwordless pushes.

Push local changes to a remote GitHub repository using SSH authentication. Use git status, git add, commit, and git push origin main with SSH keys, avoiding tokens.

Practice hands-on git branch commands, switch between main, test, and prod branches, and delete branches with git branch -d, while exploring remote branches with git branch -a.

Create a local branch, commit changes, and push to the remote GitHub repository with git push origin <branch>, illustrating remote updates and merging into main.

Create a branch directly in GitHub from a chosen source like main or test, then verify the new branch (Dev Branch) contains the source files.

Demonstrate how git clone shows only the main branch, switch to other branches with git checkout, view files with ls, and list remote branches with git branch -r.

Master how to use git diff to view changes between commits, branches, and the staging area, with line-by-line comparisons to review before committing or merging.

Perform hands-on git diff across local branches, commits, and the staging area, then compare local and remote states using main, test, and origin to spot exact changes.

Learn how the git pull command extends git fetch to automatically download and integrate remote changes into your local repository, using origin or main, with a fetch-before-pull workflow.

Learn git fetch to retrieve remote updates without merging, review differences with git diff, and keep your local and remote-tracking branches aligned for safer review.

Connect your local repository to a remote using git remote add, configure origin, and push or pull changes to collaborate across GitHub, GitLab, or Bitbucket.

Discover the key difference between fetch and pull in git, with fetch reviewing remote changes safely and pull updating your local work and potentially causing conflicts.

Explore GitHub.dev and Codespaces to edit code in the browser, with Codespaces offering pre-configured environments and a terminal for cloud-based debugging and collaboration.

Learn practical hands-on with GitHub dev and Codespaces to edit files in the browser, using VSCode features, a built-in terminal, and Git commands.

Learn to use git stash to temporarily save uncommitted changes when switching branches, and apply or manage stashes with options like -u, -e, and -m.

learn how to use git stash to temporarily save your work in progress on a feature branch, switch to the main branch, then recover with stash pop.

Learn to stash untracked and tracked changes with git stash, use stash push with messages, apply specific stashes, and drop or sync changes to keep your repo clean.

Master git merge by combining a feature branch into the main branch, preserving commit history, and resolving conflicts through fast-forward and three-way merge concepts.

Explore fast-forward and three-way git merges, comparing how fast-forward moves the main pointer without a merge commit and how three-way creates a merge commit after resolving conflicts.

Demonstrate the fast forward git merge by creating a feature branch, committing to main, and merging back, with git status and git log checks and graph visualization.

Learn how git merge works through a three-way merge example, merging a feature branch into main, creating a merge commit, and comparing fast-forward and three-way strategies.

Learn how pull requests enable code review and collaboration, guiding the process from feature branches to main, with approvals, comments, and safe merging on GitHub.

Master pull request workflows for collaboration and code review by creating branches, committing changes, and publishing a pull request; assign reviewers, add labels and milestones, and merge after approval.

Learn how merge conflicts arise when two branches modify the same file and auto-merge fails. Resolve conflicts manually by choosing which changes to keep and committing the resolution.

Resolve merge conflicts hands-on by learning how conflicting edits on the same file arise during merges between branches and how to resolve them through practical Git commits and steps.

Move commits from one branch onto another to keep a linear history and avoid merge commits. Prefer rebase for changes before pushing, and use interactive rebase to keep commits clean.

Learn practical git rebase to maintain a linear history by rebasing a feature branch onto main, resolving conflicts, and visualizing branches with a graph.

Compare merge and rebase in git, explaining when each preserves history or creates a linear history. Provide guidance for team workflows (merge) versus solo work (rebase).

Learn to use git restore to discard uncommitted changes, revert to the last committed state, recover deleted files, and unstage or handle untracked files in the working directory.

Explore the git restore command through hands-on demos, undoing changes from untracked to staging to working directory, restoring deleted files, and moving items back from the staging area.

Learn to use git clean to remove untracked files with -f or -i, while not touching tracked or staged files, especially for cleaning temporary files.

Explore git reset and its three flavors, soft, mixed, and hard, showing how each moves changes among committed, staging, and working directories, with safety tips.

Explore git reset—soft, mixed, and hard—through practical codespace demos that show how each reset moves commits between the head, staging area, and working directory.

Learn how to use git reset --hard with head tilde to delete commits up to a point, and the risks of losing history when syncing with GitHub.

Learn how git revert safely undoes changes by creating a new commit that preserves history and keeps a clear record of what was undone, without altering history.

Learn to revert changes with git revert, creating a new commit to undo a mistaken commit while keeping history intact and visible in git log.

Compare reset and revert in git, detailing soft, mixed, and hard resets, how they move commits and history, and why revert preserves history for safer collaboration.

Explore how git blame reveals who modified each line and when, providing file history for audit, debugging, and understanding code changes with commit hash, author, and timestamp.

Explore how git tags mark releases and track versions from 1.0 to 4.0. Learn about annotated and lightweight tags and how to push them to GitHub.

Learn how to use git rebase -i to reword commit messages without changing the commit content, fixing typos and clarifying messages for reviewers and auditors in codespace workflows.

Learn how to squash commits using git rebase -i to create a clean, readable history before merging. Consolidate related commits for feature development, improving code review and bug fixes.

Learn how to git cherry-pick a specific commit from a feature branch into the main branch, avoiding full-branch merges. Explore practical use cases, conflict handling, and hotfix scenarios.

Learn to install Jenkins on AWS using EC2, configure security group port 8080, install Java/openjdk, start Jenkins service, unlock with password, and set up GitHub plugins and admin access.

Learn how GitHub webhooks enable event-driven notifications to trigger Jenkins jobs automatically, reducing latency and eliminating manual triggers while improving traceability, visibility, and pipeline security.

Set up a GitHub webhook to trigger a Jenkins freestyle job on commits, configure the main branch, and verify webhook deliveries to enable automatic builds.

Create and verify a free GitLab account using your personal email, sign in via Google or GitHub, and then set up a project with a group and readme.

Learn to import a GitHub repository into GitLab using repository by URL, configure mirroring for automatic updates, and complete a hands-on migration in a new project.