The Git & Github Bootcamp

Learn how Git, the free yet distributed version control system, tracks changes, enables collaboration among many developers, and allows comparing, undoing, and sharing edits.

Explore how Git, a popular version control system, tracks changes, compares versions, and time-travels through save points, enabling collaboration, branching, merging, and fine-grained change sharing.

Explore the origin of Git, from Linus Torvalds' drive for a free, fast version control tool to its open-source creation in april 2005, and its rapid global adoption.

Discover how Git is used by engineers, developers, governments, scientists, writers, and composers, illustrating its ubiquity as a version control tool and the role of GitHub in collaboration.

Differentiate Git from GitHub by understanding Git as a local version control tool and GitHub as a cloud hosting service for repositories, enabling collaboration.

Explore Git installation and setup via command line or gui, Mac and Windows steps, configure name and email, and a terminal crash course for basic Unix commands.

Compare terminal and GUI Git work modes, install Git on macOS and Windows, and learn to use both the command line and GitKraken through practical guidance.

Install and configure Git on Windows using Git Bash, addressing the Unix-based prompt challenge and choosing a user-friendly editor like VS Code over Vim.

Configure your git identity by setting a global user.name and user.email so commits are attributed to you across projects. Use a recognizable name and accessible email for GitHub.

Explore installing GitKraken, a free GUI for Git, and learn how to download, install, and set up an account on Windows or Mac to visualize history, branches, and file changes.

Take an optional crash course on basic Unix commands, learn to navigate the terminal, manipulate folders and files, and interact with Git from the command line.

Master essential terminal navigation with ls, pwd, and cd. Learn to list directories, print your path, and move between folders across Mac and Windows, including cd.. and open commands.

Master terminal file management by creating files with touch and folders with mkdir, using relative paths and commands like cd and ls, and learning how to delete items.

Learn how to delete files and directories using rm, including rm -r and rm -rf, with safe notes that Git can restore tracked changes, and practical examples in the terminal.

Master git commands and workflows, starting with git init and git status, and follow the committing workflow. Explore repositories and key commands like git add, git commit, and git log.

Explore the concept of a Git repository as a self-contained Git workspace with its own history, and see how separate repositories maintain distinct histories across projects.

Initialize a new git repository with git init and verify status with git status, distinguishing not in a repo from a repo, and learn the one-time per project setup.

Explore how git init creates a hidden .git directory that stores your history, how to reveal it with ls -a, and why deleting it erases the project history.

discover why git tracks entire directories, avoid initializing inside another repo, and fix nested repos by removing a .git folder to keep one repo per project.

Master the committing workflow, creating checkpoints or snapshots of changes with messages. Use git add and git commit to selectively include changes across files such as team.html, about.html, and about.css.

Learn to stage changes with git add, move work from the working directory to the staging area, then commit in the repository, demonstrated with outline.txt and characters.txt.

Learn how to commit staged changes with git using a message, including the -m flag, and understand that commit messages should summarize the changes, working tree clean and Vim pitfalls.

Learn to track changes with git: stage and commit chapter updates, view history with git log, and batch changes with git add dot for efficient commits and new files.

Practice git fundamentals by creating a shopping folder, initializing a repo, adding and committing yard.txt and groceries.txt, updating both files, and reviewing commits with git log.

Navigate the Git documentation to learn the reference manual and the Pro Git book, discover command options and examples for git-commit, git-log, and more.

Keep commits atomic by isolating a single feature or fix, as shown when renaming Gatsby to Catsby and adding a mood board, with staged changes and separate commits.

Learn about commit message tense, uncover the Git docs' present tense imperative recommendation, discuss consistency with team or project guidelines, and recognize the ongoing debate between present and past tense.

Configure git to use VS Code as the default editor instead of Vim by running git config --global core.editor 'code --wait' and ensuring code is on your path.

Explore the git log command to view commit histories, shorten commit hashes with --oneline and --abbrev-commit, and format logs for quick one-line summaries.

Learn to commit with a GUI like GitKraken, stage and commit changes, and view commit history, while understanding GUI interfaces versus the command line and the .git folder.

Fix git mistakes by amending the previous commit to include files. Use git commit --amend to update the message or include files; this applies only to the last commit.

Discover how to keep API keys, credentials, secrets, and large dependencies and system files out of your Git repo with a .gitignore file, patterns, and practical examples.

Master branching and daily Git workflows by learning the Git branch, switch, checkout, and rename commands, plus head, refs, and the .git directory for deeper understanding.

Explore how Git branches create isolated contexts for parallel work, enabling experiments and bug fixes without impacting others, and learn how merging combines branches when ready.

Explore the master and main branches in git, learn that you always work on a branch, and understand default branch names, the source of truth, renaming, and feature branching.

Head is a pointer to your current location in a git repository, pointing to a branch reference like master. Switch branches to work on different commits, and HEAD updates.

Learn to list repository branches with the git branch command, see the active branch marked by an asterisk, and distinguish existing branches like master from others.

Learn how to create a new git branch with git branch, then switch branches using git switch, and review branch history with commits and logs in a practical repo example.

Explore creating and switching branches with git branch and git switch, based on the current head, and see how commits on diverging branches like oldies and georges affect history.

Explore git checkout as an older, versatile way to switch branches and compare it with git switch, including creating branches with dash C and dash B in one step.

Learn how to safely switch branches without losing work by committing or stashing unstaged changes. Understand how untracked files behave when you move between branches.

Learn how to delete and rename branches using git-branch, including safety checks for fully merged branches, force deletion, switching branches, and the dash M rename flag.

Discover how git stores head and branches behind the scenes. See how head points to a branch reference in the dot git directory and how each branch references a commit.

Practice with git branches through a wizarding patronus exercise, creating a repository, adding patronus.txt, and switching, branching, editing, and committing changes on Harry, Snape, and Lily branches.

Learn how to merge branches in git, including fast-forward merges and merge commits, resolve merge conflicts, and optionally use VS Code to assist conflict resolution.

Master the basics of merging in git by moving to the receiving branch with git switch, then merging a feature or bugfix branch with git merge, including fast-forward scenarios.

Switch to Master, run git merge Oldies, and fast-forward Master to include the Oldies commits. Remember that fast-forward merges move the pointer and don't delete branches.

Explore visualizing branches and merging in git using GitKraken, showing how master and oldies become in sync through a fast-forward merge by adding Wings and Joni Mitchell songs.

Demonstrate generating a merge commit when merges aren’t fast-forward, merging a feature ABBA branch into master, and understanding a merge commit with two parents.

Resolve merge conflicts in Git by editing conflicted files, removing conflict markers (head and branch), and committing the final resolution after choosing edits to keep.

Explore how to generate and resolve a Git merge conflict by creating Serena and Bjorn branches, resolving conflicts in songs.txt, and finalizing the combo branch.

Learn to resolve git merge conflicts in VS Code using built-in tools, create branches, simulate conflicts on master and silence, and finalize merges with clear conflict resolution steps.

Practice mastering git merging with fast-forward and merge commits, handle conflicts, and resolve them across branches like master, Spanish, French, and Japanese in realistic scenarios.

Master git diff by learning what it does and how to read its outputs, and practice comparing commits, branches, files, and the staging area with working directory; basics are critical.

Explore how the git diff command shows changes across the last commits and the working directory, the staging area, and between local and GitHub, aiding you to read diff output.

learn to read git diff output, where changes appear as minus and plus lines within chunk headers, comparing file a and file b across contexts and line ranges.

Learn to use git diff to compare the working directory, staging area, and HEAD, including file-name variations, and see how changes move from unstaged to staged.

Git diff head lists changes since last commit, with staged and unstaged edits. After adding colors.txt and numbers.txt, git diff shows nothing for those files, while diff head reveals them.

Explore how to view only staged changes with git diff --staged (or cached), compare the last commit with staging, and note that git diff head shows both.

Learn how to narrow git diffs to specific files, compare staged or unstaged changes, and view changes for a file like style/main.css or index.html using git diff and related options.

Use git diff to compare changes between branches such as master and odd-numbers, showing removals and additions with minus and plus signs, and learn dot-dot notation or space syntax.

Compare changes between any two commits with git diff. View changes for specific files and see staged, unstaged, or all changes since HEAD.

Explore visual diff workflows with gui tools like Git Kraken to see changes in files, stage and compare diffs, between commits, and view hunks for large projects.

Practice git diff across two branches (1970s and current) using Fleetwood Mac and Queen files, learn staging, commits, and diffs, including head and head~1.

Master git stash basics, including git stash save and git stash pop, and learn when stashing is a convenient tool for managing work in progress.

Learn why git stash solves the problem of switching branches with uncommitted changes by temporarily saving edits, avoiding conflicts, and keeping branches separate.

Learn to use git stash save and git stash pop to stash uncommitted changes, switch branches, and reapply work without committing.

Practice using git stash to save unstaged and staged changes, switch branches, and pop the most recent stash, applying edits to app.css and index.html.

Explore git stash apply to reuse stash changes across branches, contrast it with git stash pop, and resolve conflicts while keeping stashed changes available.

Master how to create and manage multiple stashes in git, view stash lists, and selectively apply a specific stash by index, using stash pop vs apply.

Learn how to drop and clear stashes in Git using Git stash drop and Git stash clear. Manage stash entries with stash list and apply.

Explore git commands that undo changes, revert work, or view earlier commits, including detached head, git checkout, restore, reset, and revert.

Learn to check out old commits with git checkout and commit hashes, and view history with git log. Explore the detached head state when HEAD points to a commit.

Explore how to navigate a detached HEAD, inspect old commits, switch back to master, and create a new branch to preserve different versions.

Learn to reference commits relative to HEAD with HEAD tilde N, understand detached HEAD, and switch back to branches using git switch and dash on master or other branches.

Use git checkout to discard uncommitted changes and restore files to their last committed state via HEAD or the short form, and learn how git restore offers a similar workflow.

Learn git restore, a new command that simplifies undoing changes and discarding edits. Use --source or head to restore files from a past commit while staying on the current branch.

Learn to use git restore to unstage changes or discard modifications, using --staged to unstage a file and reset a file to head, guided by git status.

Learn how git reset moves a repository to a commit hash, compare regular reset with --hard, and see commits disappear while changes stay in the working directory.

Compare git revert with reset: revert creates a new commit that undoes a previous change, preserving history for safer collaboration and easier conflict resolution.

Practice core git commands with a hands-on undoing changes exercise, cloning a starter repo, editing and restoring the lyrics across commits, and managing branches like scrambled-eggs and 404.