Git Basics: Hands-On Version Control for Beginners

Explore why a version control system is essential for software by using commits as checkpoints, taking project-wide snapshots, and merging changes via a centralized repository such as GitHub or GitLab.

Explore git fundamentals through a practical, two phase commit workflow, branching, merging or rebasing, and collaborating via local and remote repositories, forks, pull requests, and GitHub workflows.

Learn to install git across Mac, Windows, and Linux, verify installation in the terminal, and set up your path using options like git-scm.com, Homebrew, Chocolatey, or apt/yum.

Initialize a git repository to track changes in a simple HTML project, create index.html, and use git to checkpoint the state by saving snapshots of your code as you update.

Learn how to take snapshots in git through a two-step process: stage changes with git add and commit them with a message, capturing edits to files like index.html.

Master the three state architecture in git by visualizing the working directory, staging area, and commit history; map git add and git commit to moving between states.

Demonstrate selective staging and committing by adding a new file and updating an existing one, resulting in two commits that form separate snapshots using git add and git commit.

Learn to stage and commit changes, not files, by selectively adding modifications to index.html and app.css. Understand that only staged changes are committed, and subsequent edits require re-staging.

Open a git editor by omitting the -m flag and run git commit to craft a detailed, multi-line message, then save with :wq to finalize.

Learn to view previous commits with git log, revealing commit hashes, authors, dates, messages, and file changes. Filter by author, limit results with -n, or show names with name-only.

Explore how git tracks deletions as changes and learn to stage and commit a file deletion, producing separate commits for add and delete, even if final state matches earlier.

Explore how git log uses patch output to reveal diffs in each commit, showing added and removed lines with plus and minus signs and highlighting newly added files.

Learn how to clear uncommitted and unstaged changes in your working directory using git checkout, restoring a single file or all changes to the last committed state.

Learn how to unstage changes using git restore, including the --staged option, compare with git checkout, and clarify updating both staging area and working directory for precise version control.

Amend the last commit by staging the changes and running git commit --amend to rewrite the previous commit, and optionally update the commit message.

Learn to view code changes with git diff, see added and removed lines, compare unstaged versus staged changes, and preview what you will commit.

Configure a .gitignore at the repository root to ignore build artifacts and IDE files, commit the pattern, and keep untracked files from cluttering version control.

Understand how git commits capture a snapshot of tracked files plus metadata, linking to the previous commit to form a chained history, with a unique commit hash as a checksum.

Explore how branching enables parallel work on features and bug fixes, stash management, and commits to create separate states, and compare Git's branching prowess with other systems.

Git tracks branches with a pointer to the latest commit, capturing the current state and all previous commits as a linked list.

Create and manage branches in git by initializing a repository, committing changes on master, and creating a color experiment branch; switch between branches with checkout, guided by the head pointer.

Switch to the color experiment branch, modify the background and text colors, then stage and commit changes to keep them isolated from master and illustrate divergent history.

Explore how branch pointers and commits move with color experiment and master, switch branches with git checkout, and see how changes diverge before merging back to master for deployment.

Explore fast forward merge by updating the master branch to the commit on the ahead bug fix branch, using git merge to move pointers and synchronize histories.

Merge diverging branches in git when fast-forward isn't possible, creating a two-parent merge commit that brings color experiment changes into master.

Git handles merges between diverged branches and may require manual conflict resolution by editing the conflicting file, removing conflict markers, and committing the merged result.

Explore git log with a graph to visualize commits and branches, showing how master and color experiments diverged and merged, and how merges reflect project history.

Learn how to delete git branches after merging to master, using git branch -d, and why you must switch away from a checked-out branch before deletion.

See how to switch to an older commit by using git log to find a commit hash and git checkout to move the head, creating a detached head.

Understand the detached head state, create and switch branches, and explore fast-forward, recursive, and manual merges with a teaser on rebase in the next tutorial.

Understand how rebasing replays commits from another branch onto the master, avoiding merge commits and preserving the intended changes.

Demonstrates creating and managing branches, then rebasing the fix one branch onto master to replay commits on top of the latest history, and performing a fast-forward merge to update master.

Discover how to clone a remote repository from GitHub, work with a central server as another branch, and push changes back to the online repository.

Learn to work with a cloned repo by making local changes on branches, committing to master, and pushing updates to the remote, while staying connected to the remote repository.

Push local commits to the remote repository with git push. Pull online changes using git pull to keep your clone synchronized with origin master, including online edits.

Understand how a local repository maintains a link to the remote via the origin pointer and tracks remote branches like origin/master to synchronize with the remote repository.

Learn to switch to remote branches and manage detached head, create local branches from remote commits, and understand pointers to commits in a cloned repository.

Peek at remote state with git remote show origin to see fetch url, head branch, and remote branches, then fetch updates with git fetch to refresh origin references.

Learn to sync remote changes to your local repo by fetching updates from origin master and merging them into your local master, using git fetch and git merge.

Understand how git pull updates your local branch in one step by fetching from origin and merging, replacing the two-step fetch and merge to keep master or test in sync.

Learn to fetch and merge changes from another remote branch into master using git fetch, git merge, or git pull, and push. Understand how to resolve conflicts when merging origin/test.

Compare git fetch and git pull. Fetch updates origin branches without touching your work, while pull may modify your local branch and requires a clean state.

Learn to pull with rebase to avoid merge commits by fetching remote changes and replaying local commits on top.

Learn how forking a repository creates a copy in your account, enabling you to clone, modify, and push changes to contribute to open source projects on GitHub.

Fork a repository, create a branch, and open a pull request to merge your changes, then review diffs, discuss, and obtain approval from the maintainers.

Gain a working knowledge of git and version control basics, covering commits, branches, merging, rebasing, and GitHub workflows like clone, fork, push, pull, and pull requests.