Fundamentals of Git Source Control Management

Covers the basics of git repositories, remotes, commits, tracked and untracked files, common git commands, and how to create a new git repo.

This lecture describes the foundation of source control management, specifically applied to git -- save states of files and those save states' parental relationships.

Covers linear and merge commits in detail and how they fully define the structure of the git repository. Also covers the most common and useful forms of the 'git log' command.

Shows and example git clone of a repo, discusses default branches and then explores the commit tree in default and graph views.

Covers git tags and git branches. Explains in detail how branches point to particular commits in the repository tree and how they can be manipulated by various git commands.

Shows how to create and delete a branch and some of the branch deletion issues you may encounter. Finally shows how to restore a recently deleted branch.

Discusses REF reachability and how reachability is used to determine how various mechanisms in git operate.

Covers a few remote interaction examples like 'git fetch' and 'git push' as well as best practices for using centralized remote/project hosting services.

Covers adding a new remote to an existing repository and then fetching from and pushing to that remote. Also touches on GitLab forking and authentication since the repo used in this exercise originates from a GitLab project.

Covers git diff and difftool and the various notations those commands accept.

Shows several examples of using git diff and git difftool in practice. Explains how to use git diff with explicit arguments to compare any two states of repo history as well as "no-argument" default usage which helps you understand what you've changed in everyday software development.

Describes in detail what causes merge conflicts, how to resolve them, and what you will see in 'git status' during the process.

Covers the creation and resolution of an example merge conflict using both the editor and git mergetool.

Covers git rebase and shows visually the difference between 'git rebase' and 'git merge'.

Shows the execution of the example rebase scenario presented in the previous lecture.

Explains in detail how rebasing shared commits adds "duplicate" commits to the repository tree and discusses some rules of thumb to avoid this issue in practice.

In this exercise I show you how to squash multiple linear commits into a single commit.

Covers the purpose of the git index and how it should be used as a way of "checkpointing" good content incrementally as you do software development. Shows what happens when executing each of the three common options listed in git status: 'git reset HEAD <file>', 'git checkout <file>' and 'git add <file>'

Shows several examples of adding and removing content from the index and the 'changes not staged for commit' section of 'git status'.

Discusses best practices for wielding the index effectively, git fetch, git pull, commit messages, and using merge requests in your git workflow.

A summary of everything we discussed in this course as well as links to additional resources.