GitHub Ultimate: Master Git and GitHub – Beginner to Expert
This course will comprehensively cover the GitHub hosting service as a companion to the Git source control tool, which means no prior knowledge or experience is required. Students will emerge at the end with a very solid understanding and hands-on experience with Git and GitHub.
The course is divided into four major components:
Introduction and Setup
Learning Git Source Control
All About GitHub
Each one of the above components spans multiple sections in this course.
New! Video explaining how to resolve Git breaking when upgrading macOS each year
The Introduction provides a welcome to the course including some useful tips for getting the most out of taking the course and how the course is designed. That is followed by the Core Concepts which go over some critical theory before diving straight into Git.
After the introduction and core concepts, the first thing we do is a Quick Installation for both Windows and Mac. The Bonus section has a more comprehensive, step-by-step process for those that prefer it.
Learning Git Source Control
In The Basics, we walk through all the foundational commands needed to start a new project managed by Git (or enable Git for an existing project) all the way through making commits, including common file operations like moving and deleting files. We also cover how to exclude the wrong files from accidentally being committed and how to review your repository’s history.
With a strong foundation in place, we explore some more Advanced Git topics like comparing differences, branching and merge resolution, tagging special events, saving work in progress, and even a bit of time travel.
All About GitHub
The main part of this course is all about GitHub. We will explore GitHub indepth from a source control hosting repository perspective.
In Welcome to GitHub we start off exploring some of the basic features of GitHub by creating a fresh repository and associate our local repository with it. Then, we prepare for the remainder of the course by setting up SSH Authentication, which we will use from this point forward. After that, we continue looking at the GitHub Repository, including many of the same operations we performed locally, but done directly within GitHub. Then in GitHub Repository Branches we dive into how Branches on GitHub and our local system work with each other.
After we have comprehensively covered how GitHub repositories work, we focus on how GitHub Tags and Releases work and their relationship with local tags in Git. We can then use tags/releases while Comparing Differences on GitHub.
We start tying things together in Social Coding where we join other projects on GitHub by forking and then submitting our contributions back using pull requests.
Once part of a team, you might use GitHub Issues to track defects or enhancement requests.
Sometimes you just need to share small parts of a file or a set of files, but don’t want to bother with a full Git repository. That where GitHub Gists help out — share just a snip of code or entire files.
Finally, group related GitHub repositories with GitHub Organizations and manage permissions and access using teams.
The bonuses sections and lectures provide additional information, more comprehensive instructions, or non-critical lectures.
All tools have installation and configuration sections to ensure no one is left behind.
Presentations provide audio/video training of conceptual ideas. Since few like slide-ware presentations, slide-presentations are kept to a minimum.
Screencasts provide a video of the instructor’s computer system with any actions, commands, or screens displayed and narrated. There is nearly 5 hours of screencast based video training in order to step through each command or action in sufficient detail.
All videos are available in high quality 1080p / Full HD resolution for sharp and clear viewing on modern desktops and tablets.
Several attachments and document lectures throughout the course provide supplemental information, illustrations, or other reference material.
This course will expand periodically to include more topics, supporting materials and bonus content! Some content may be in direct response to student feedback or discussions — so get engaged with the course discussions feature!
An overview of what we will be covering in this course, including Git basics, advanced git techniques, sharing code snippets, and organizations within Git.
A guide to the technical level this course is targeted at, as well as an explanation of the pace and step-by-step command line approach used by this course.
We will be using the command line due to it's rich feature set and ability to teach concepts in more depth than would be otherwise possible.
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 topics covered in this section, including creating a new repository, getting support, performing a basic workflow, working with files, excluding files from Git, and undoing mistakes.
Creating our initial Git repository using basic commands in Git.
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.
Advanced: Beyond the Basics
An overview of the advanced topics covered in this section, such as comparing differences, branching, merging, resolving conflicts, creating milestones, and traveling through time in our repository.
How to compare differences between two commit points within Git.
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.
Welcome to GitHub
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.
An overview of the topics covered in this section, mainly about doing operations to our remote repository on GitHub.
Creating a new repository on GitHub so that we can use it throughout this section.
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.
GitHub Repository Branches
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.
GitHub Tags and Releases
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.
An overview of the ways in which we will use GitHub to compare differences, including comparing between branches, tags, and commits, as well as integration with pull requests.
Using the pull request feature to make commit comparison easy on GitHub.
Using GitHub to compare changes between two arbitrary commits.