Git & GitHub: Learn Git and GitHub over the weekend

Explore how git's server and client systems operate in parallel, with cloud or dedicated hosting and a local git client that saves changes to repositories.

Install git on a Windows machine by downloading the installer, running it, configuring the default editor and the default protected master branch, choosing unix-style encoding, then verify with git --version.

Install git on a Linux machine by using the appropriate package manager (for Ubuntu, apt), then verify the installation with git --version.

Install git and perform first time configurations using git config --global --edit to set your email and username, enabling the local repository to synchronize with the cloud repository across platforms.

Explore git configurations across system, global, and local levels using git bash; learn system editor setup, global user details, and local repository information like URL, sub-modules, and branches.

Explore how git uses the hidden .git folder to identify version-controlled folders as repositories, then compare local versus remote repositories and learn how to connect them.

Learn to set up remote repositories on GitHub, create private or public repos, and clone them locally with HTTPS or SSH, including initial commits and the master branch.

Initialize a local repository with git init, connect it to a remote using git remote add origin, then pull content with git pull origin master to synchronize files.

Explore the git file lifecycle by tracing untracked, modified, staged, and committed (unmodified) states. See how staging and committing relate to these states as files move through the lifecycle.

Create a new text file named FirstFile.txt to show an untracked file. Run git status to see it in red as untracked, and enable color coding in the git config.

Learn how git reports changes by demonstrating untracked files and a modified readme. See how git status shows two changes, including the readme moved to modified state, using git bash.

Use git diff to view changes between version a and version b, with deletions shown as minus and additions as plus. Untracked files can't be diffed until staged.

Learn to stage untracked and modified files in git, either individually or with one command, and unstage or view diffs using git restore --staged and git diff --staged.

Commit the changes from the staging area using git commit -m to save a version in the repository history, with meaningful commit messages for the master branch.

Learn to view version history with git log, including commits, head pointer, and metadata, and use --stat, --patch, --graph, --format, and filters like --after and --since.

Demonstrates using git commit --amend to fix typos, add missed files, and maintain a clean history by updating the last commit message and contents.

Learn to use git branches for parallel feature work without affecting the master version in production. Treat the master as the trunk and branches as replicas for isolated development.

Explore branches in action with git branch to list local and remote branches, including remote/origin, switch to a feature branch with git switch, and verify the current branch with show-current.

Learn to use the git checkout command to switch branches, create and switch to new branches with -b, and discard or restore file changes to the last commit.

Learn how to use a .gitignore file to exclude IDE configuration files and other unwanted items from version history, using patterns and regular expressions.

Synchronize your local and remote git repositories by using fetch, pull, and push to share code with peers and enable collaboration.

Push the changes from the local develop branch to the remote origin, creating the remote develop branch if needed, and verify the update on GitHub.

Learn to use git fetch to track changes from a remote repository, update your local repository, and see how creating a new branch on GitHub becomes tracked remote branches.

Demonstrates pulling changes from a remote repository into a local git learning project on the master branch. It updates tracking information while combining fetch with pull.

Learn to merge branches with git merge and git pull origin, moving changes from develop to a feature branch or to master for production website.

Resolve merge conflicts when collaborators modify the same file in different branches by manually editing conflict markers, as demonstrated with readme changes during a branch merge from branch1.

Learn to resolve merge conflicts by selecting changes from the incoming branch, the current branch, or both, then continue with git merge --continue or abort with --abort.

Learn how git tags create checkpoints in a repository, marking versions for releases or markers, and distinguish lightweight tags from annotated tags with details like author, date, and tag message.

Explore git tags in action by creating lightweight and annotated tags, listing and viewing tag details with git show, and pushing tags to a remote using git push --tags.

Speed up git workflows by creating aliases for frequently used commands, such as st for status, and apply global config aliases across all repositories.

Rebasing b1 onto b2 replays commits after the last common commit in git, producing a clean, feature-focused history that separates unrelated commits.

Learn rebasing in action as you rebase the develop branch onto branch1, stage and commit changes, and review the updated history showing the new file additions.

Learn how squashing merges multiple commits into a single feature commit to keep a clean repository history and create reliable checkpoints for feature development.

Learn how to squash the last two commits into one using git rebase -i HEAD~2, detaching and recombining commits, editing the final commit message, and updating the version history.

Learn to use git stash to park changes with a stash name like WIP-FirstFile, view stash with git stash list, and reapply with git stash apply or git stash pop.

Learn how git reset moves head to a previous commit, discards later commits, and leaves them orphaned for garbage collection, useful to revert to the last good version after corruption.

Demonstrate resetting your head to a previous commit using Git reset on a feature branch, review un-staged changes, and decide which updates to keep or discard.

Compare soft and hard resets in git: soft resets move head back and stage changes; hard resets discard later commits, with advice on when to use each.

Explore submodules to modularize repositories by including a dependent project inside your git repository, such as a third-party library, and delegate tasks like database interactions for an e-commerce site.

Learn to add a submodule to the main GitLearning repository with git submodule add, review the .gitmodules and submodule folder, and push the commit pinning a specific submodule commit.

Explore submodules as independent repos tied to a main repository, and update the parent by staging, committing, and pushing. Clone with --recurse-submodules or initialize and update to fetch submodules.

Explore how to view versions of a repository by inspecting branches, commits, and tags, use the branches dashboard, and examine commit details to see changes.

Learn to manage branches in git and GitHub by creating and deleting branches from master, switching the parent branch, viewing all branches, and restoring deleted branches.

Learn how to make a sample commit in GitHub, explore file options like raw, blame, and history, edit a file, write a commit message, and push to the master branch.

Learn to create a GitHub release by using an annotated tag to mark a delivered version, name the release, and publish from a chosen branch or commit.

Create, review changes, and merge pull requests by switching between develop and master branches, and assign reviewers to approve the merge.