GitHub Ultimate: Master Git and GitHub - Beginner to Expert

An overview of the core Git concepts we will explain in this section.

A quick explanation of how Git works as a decentralized version control system.

An explanation of how Git uses a repository to keep track of all of the changes we will make to the code throughout this section.

A guide to the way that Git archives individual file history in order to preserve the total history of the repository.

A quick overview of the remote repository service GitHub, including the limitations of only allowing public repositories for free (which has recently been changed).

An overview to the tools we will install in this quick installation section of the course.

A quick guide to installing and configuring Git for Windows, Notepad++, and P4Merge on your system to be ready for the rest of this course.

A quick guide to installing and configuring Git from Apple, TextMate 2, and P4Merge on your system to be ready for the rest of this course.

An overview of the three local sates in Git, including the working directory, staging area, and Git repository, as well as the possible fourth state of remote.

Making our first commit in Git in order to start our repository's history.

A guide to the way the Git repository manages history inside it's ".git" folder.

Adding Git source control to an already existing project, just in case you forgot to initialize source control before starting your project.

Adding files to create differing commits within our Git repository.

Using the "git log" and "git show" commands in order to view our Git history so far.

Using options with the commit command to make committing faster when we update one of our files.

Backing out our changes in order to undo changes we might not want before we add them to our Git Repository.

Viewing our Git History in more practical ways and creating an alias to shorten that command down to be easier to use.

An explanation of how Git keeps track of files through renames and deletions.

Using external tools to manage files and seeing the impact this has on our Git Repository.

Using our ".gitignore" in order to only keep a history for the files we wish to keep track of.

An overview of the theory of how branching works within Git.

Special markers generally help refer to the heads of branches.

Creating a branch to work on a feature and then merging that branch back into master and finally deleting it.

Creating a conflict in our repository in order to view the various ways in which Git can show us the details of the conflict.

Adding tags to commits in order to bookmark them for later.

Saving our changes by stashing allows us to modify other things without committing our current changes.

Using "reset" and "reflog" in order to go back to previous commit points in our Git history.

An overview of why we will be using GitHub to back up our project and history remotely.

Creating our GitHub account so we can back up our repositories throughout the rest of this course.

Setting up our GitHub profile in order to up or trust level when committing on repositories.

Adjusting our general Git settings on GitHub.

Creating a new remote repository on GitHub.

Linking our local Git repository to our remote repository on GitHub using the command line on our local system.

Pushing our source files, changes, and history from our local Git repository to our remote GitHub repository.

Verifying that the changes we pushed up in the previous lesson actually made it up to GitHub.

An overview of why SSH authentication, which we will set up in this section, is faster and more secure.

A quick overview of the differences between the HTTPS and SSH authentication strategies, and how it will practically affect using the remote repository.

Using our system's terminal to generate a public and private SSH keypair that will allow us to use SSH authentication to log into our remote GitHub repository.

Using our newly generated GitHub key in order to set up SSH authentication to ease the process of pushing upto GitHub from our local system.

Downloading our remote repository from GitHub onto our local system.

Adding dummy HTML files to the local copy of our GitHub repository from initializr in order to have sample files on our repository.

Pushing our changes from our local system back onto our GitHub repository.

Understanding the differences between the fetch and pull command when getting changes from GitHub.

Exploring the features that GitHub provides, such as commits, branches, cloning, downloading, renaming and deleting repositories.

Updating our remote references on our local system in order to keep the local project synced up with the remote GitHub project.

Various ways of viewing the files and folders on our GitHub repository.

Although it isn't recommended, GitHub offers the capacity to directly edit files on GitHub, which may sometimes be the most convenient way of doing things.

Using GitHub to add new files to the repository.

Creating a file on GitHub and making sure that it is created onto our main (master) branch.

Showing how GitHub handles the renaming and deletion of files both in terms of it's repository and history.

Pushing the files we created on GitHub down to our local repository by pulling the changes down from GitHub.

Using the list of commits to view the history of commits we have made throughout this section.

Looking at specific commits on GitHub to get a more detailed look at our commit history.

Using GitHub to roll back our repository to an earlier commit.

Using GitHub's interface to find commit IDs and then viewing them on our local system.

An overview of the branching we will do in this section, including interactions between GitHub and our local repository.

Using GitHub to create branches on our remote repository.

Starting locally by creating a branch on our local system before pushing it up to GitHub for future work.

Using GitHub to initiate pull requests in order to merge in branches from within the GitHub interface.

Using out local copy of the GitHub repository to merge before pushing up the merge to GitHub.

Checking out a remote branch from GitHub onto our local system.

Removing old unneeded branches and references from our GitHub repository.

Using rebase to pull down commits from GitHub, stepping through the individual commits on our local system in order to more fully integrate the history of our remote branch with our local branch.

Using our local system to view a graph of our history before comparing that to the GUI graph that is provide on GitHub.

Changing the default branch of a repository from the master branch to another long living branch, due to the master branch commonly not being ideal for active development.

Comparing conflicts between a remote (GitHub) copy of repository and local copy of a repository in order to resolve them.

The uses of Git tags we will go over in this section, including marking project milestones and making release notes on GitHub.

Using our local repository to create tags and annotated tags for important commits, which we will use in the next few videos on our GitHub repository.

Using our local repository to push up the tags on our local system to our remote repository.

Viewing how the tags we created on our local system look on our remote GitHub repository.

Using both our remote GitHub repository as well as our local Git repository to remove tags that are no longer applicable or wanted.

Using more advanced techniques to create floating tags that move along with development, say to keep track of which is the most up to date version of the unstable build.

Using more advanced tagging features to create a tag that specifies release information about a build we want to release.

Observing the information GitHub has about releases, as well as deleting releases that are no longer relevant or wanted.

Using a more complicated feature in GitHub to create both a tag and a release at the same time, instead of creating them separately.