Github Ultimate

Core Concepts Overview Preview 00:29

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

What is Git Preview 01:36

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

The Repository Preview 01:10

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.

Commits and Files Preview 00:50

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

What is GitHub Preview 01:17

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

Quick Installation Overview Preview 01:02

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

Quick Install on Windows Preview 08:37

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.

Quick Installation on Windows Notes Preview 03:37

Quick Install on Mac OS X Preview 06:18

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.

Quick Install on Mac OS X Notes Preview 02:42

The Basics Overview Preview 00:42

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.

Initialization Preview 01:28

Creating our initial Git repository using basic commands in Git.

Git States Preview 01:23

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.

First Commit Preview 03:04

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

Repository and the Git Folder Preview 01:59

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

Starting with Existing Project Preview 01:56

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

Commits and Messages Preview 02:01

Adding files to create differing commits within our Git repository.

Commit Details with Log and Show Preview 01:16

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

Express Commits Preview 02:58

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

Backing Out Changes Preview 02:12

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

History and Making New Commands with Alias Preview 03:50

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

Rename and Delete Files Preview 03:08

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

Managing Files Outside of Git Preview 03:06

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

Excluding Unwanted Files Preview 02:56

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

Advanced Overview Preview 00:35

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.

Comparing Differences Preview 02:39

How to compare differences between two commit points within Git.

Branching and Merge Types Preview 02:02

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

Special Markers Preview 00:37

Special markers generally help refer to the heads of branches.

Simple Branching Example Preview 04:56

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

Conflict Resolution Preview 04:50

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

Marking Special Events with Tagging Preview 02:38

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

Saving Work in Progress with Stashing Preview 02:17

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

Time Travel with Reset and Reflog Preview 05:23

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

Welcome to GitHub Overview Preview 01:04

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

Signup for GitHub Preview 02:06

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

GitHub Profile Preview 02:23

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

GitHub Settings Preview 02:34

Adjusting our general Git settings on GitHub.

Creating a GitHub Repository Preview 01:13

Creating a new remote repository on GitHub.

Linking to our GitHub Repository Preview 02:19

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

Pushing Changes to GitHub Preview 02:29

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

Verifying our Changes on GitHub Preview 01:00

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

Authentication Overview Preview 00:41

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

SSH vs HTTPS Preview 01:49

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

Generating an SSH Key Preview 02:21

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.

Verify SSH Authentication with GitHub Preview 02:37

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.

GitHub Repository Overview Preview 00:38

An overview of the topics covered in this section, mainly about doing operations to our remote repository on GitHub.

Starting Remote with a Starter Repository Preview 01:11

Creating a new repository on GitHub so that we can use it throughout this section.

Create a Local Copy with Clone Preview 03:42

Downloading our remote repository from GitHub onto our local system.

Seeding the Repository with Sample Content Preview 03:03

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

Publish Back to GitHub Preview 01:54

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

Fetch and Pull Preview 03:53

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

Repository Features and Settings Preview 02:58

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

Updating Repository and Remote References Preview 01:55

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

Looking at Files and Folders on GitHub Preview 00:55

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

Directly Editing Files on GitHub Preview 02:38

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.

Creating a New Files on GitHub Preview 02:40

Using GitHub to add new files to the repository.

Creating a New File on Master Preview 01:10

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

Renaming and Deleting Files on GitHub Preview 02:08

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

Synchronizing our Changes with our Local Repository Preview 01:31

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

Reviewing Commits with the Commit List Preview 00:58

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

Commit Details: Going Deeper Preview 03:17

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

GitHub Time Travel: Reviwing Your Repository as of a Particular Commit Preview 01:33

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

Using Commit IDs with the Local Repository Preview 01:22

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

Repository Branches Overview Preview 00:18

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

Creating Branches on GitHub Preview 02:54

Using GitHub to create branches on our remote repository.

Local Branches Preview 03:33

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

Comparing and Pull Requests Preview 05:23

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

Merging Locally Preview 05:26

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

Locally Switch to a Branch on GitHub Preview 03:57

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

Cleaning Up By Deleting Branches and References Preview 03:49

Removing old unneeded branches and references from our GitHub repository.

Pull with Rebase Preview 04:36

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.

GitHub Graphs Preview 01:51

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

Setting the Default Branch Preview 05:08

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.

Dealing with a Conflict while Pulling Preview 03:34

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

Tags and Releases Overview Preview 00:23

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

Local Tags (a bit of Review) Preview 04:27

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.

Pushing Local Tags to GitHub Preview 03:27

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

Tags on GitHub Preview 02:18

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

Deleting Tags on GitHub Preview 02:42

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

Updating Tags: Creating a Floating Tag Preview 03:56

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.

Starting a Release on GitHub Preview 02:52

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

Deleting a Release Preview 01:30

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

Creating a Completely New Release Preview 03:19

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

Comparing Differences Overview Preview 00:23

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.

Comparing with Pull Requests Preview 01:32

Using the pull request feature to make commit comparison easy on GitHub.

Comparing Commits Preview 02:45

Using GitHub to compare changes between two arbitrary commits.

Comparing Tags Preview 01:23

Using GitHub to compare between tags, instead of directly using commits.

Advanced Comparing: Even More Fun Preview 02:27

Using a variety of tags, releases, commit points, and specific ranges to compare any arbitrarily found commit point to an other.

Social Coding Overview Preview 00:42

An overview of the important social aspect of GitHub, including joining projects via forking, contributing your finalized changes with pull requests, reviewing and accepting pull requests from others, and making sure all of this stays synced up.

Copying A GitHub Repository by Forking Preview 02:10

Using forking to get a copy of a repository you want to collaborate with onto your personal GitHub repository space.

Creating A Branch on Your Fork Preview 02:42

Using your personal copy of the GitHub repository to clone to our local system and then create a new feature branch which we will then push back up to GitHub.

Pull Requests Preview 01:54

Using GitHub to accept our pull request from our local system in order to add the new branch onto our GitHub repository.

Updating Pull Requests Preview 03:03

Adding more commits to a pull request after the pull request process has started in order to keep all of the commits we want together in one pull request.

Accepting the Pull Request Preview 04:41

Reviewing the pull request we just made by adding comments and ensuring everything is ready to be pushed up before finally accepting the pull request to integrate the changes into the GitHub repository.

GitHub Graphs Preview 02:53

Using the pulse and graphs tab on GitHub to see the changes in our repository over time.

Synchronize Changes Back to Your Fork Preview 06:32

Synchronizing branch changes between your local and remote Git repository by pulling down and pruning branches no longer needed after merging.

Enlisting Help with Collaborators Preview 03:12

Using secondary GitHub accounts to simulate what it would be like to allow other real users to collaborate with you on a repository.

GitHub Issues Overview Preview 00:27

An overview of the important topics surrounding issues on GitHub that we will cover, including built in issue tracking and labels and milestones.

An Introduction to GitHub Issues Preview 01:01

A basic introduction to how issues are organized within GitHub.

Setting Up Issue Labels Preview 02:33

Adding and removing labels to help categorize our issues when we start adding them.

Setting Up Milestones Preview 02:38

Setting up milestones as goals for your project team to complete by certain dates. Issues can also be categorized under a milestone.

Creating Issues Preview 03:11

Creating issues to attach to our project to mark tasks that need to be done for the repository.

Closing Issues Preview 02:04

Completing issue tasks and then closing the issue from the issue tab on GitHub.

Associating Issues with Commits Preview 02:50

Associating issues with specific commits by using a specific syntax in GitHub.

Using Mentions with Issues Preview 01:49

Using special GitHub syntax for comments on commits to allow issues to link to back and forth to a specific commit.

GitHub Gists Overview Preview 00:37

An overview of the topics related to gists that will be covered, including how much content you can have in a snip and how it is basically functionally a "micro" Git repository.

Creating Gists Preview 02:32

Creating a gist within GitHub, and modifying it to show that Git keeps track of the history in a gist.

Working with Gists Locally Preview 02:24

Using our local system to clone our gist as if it was a remote Git repository.

Sharing Gists Preview 01:05

Allowing others to access our gists by using the URL that GitHub provides, as well as using bit.ly to shorten the link.

Deleting Gists Preview 01:31

Deleting a gist once we no longer need it available, as well as cleaning up any copies of the gist that exist on our local system.

GitHub Organizations Overview Preview 01:28

An overview of the topics related to organizations that will be covered, including grouping related repositories, making a team for a smaller project, and setting up permissions.

Creating a GitHub Organization Preview 02:24

Creating our first GitHub organization within GitHub, making sure we are keeping with the free plan.

Transferring a Repository to the Organization Preview 02:17

Moving a repository from our personal space into an organization space in GitHub.

Forking Back to Your Account Preview 01:43

Forking our repository back to our personal account in order to give personal access to the collaborative project.

Updating Remote Referneces on the Local side Preview 03:59

Making sure that our local side points to both the personal GitHub repository as well as the new one on the organization.

Branches and Confusion Preview 03:32

Accessing a branch that has the same name on two remote GitHub repositories from our local copy of the project.

Organizations vs Personal Account Preview 02:16

Explaining the differences and similarities between organizations and individual accounts, including how they have different sets of repositories as well as different profile pages.

Working with Teams Preview 05:00

Setting up teams and allowing an external account to join a team to participate in our organization.

Team Permissions Preview 02:46

Further managing our teams in GitHub by changing permissions to repositories within our GitHub organization.

Managing Teams Preview 02:18

Creating a new team and moving our external account to that new team within our organization.

Organization's Profile Preview 03:42

Updating the public facing organization profile, as well as settings that only apply to the organization.

Destructive Actions Preview 02:11

Going over destructive aspects, such as changing membership levels of external users, deleting or modifying teams, and renaming or deleting the organization.

Review and Next Steps Preview 02:26

An overview of everything we have learned throughout this course on Git and GitHub, including core concepts and basics, more advanced features, SSH authentication, branches, tags and releases, comparing differences, collaborating with others on GitHub, creating issues within GitHub, creating gists within GitHub, and finally creating organizations within GitHub.

Background Overview Preview 00:40

An overview of the background content on the course author, Git, and Git as compared to other SCM tools.

About the Instructor Preview 01:13

A quick background of the instructor, Jason G Taylor.

History of Git Preview 00:48

A quick history of the Git source control project, created by Linus Torvalds in order to address the needs of the Linux Kernel Project.

Comparing Git with Other SCM Tools Preview 03:42

Comparing the advantages and disadvantages of Git as compared to other source code management tools, such as commercial products, centralized SCM tools, and Mercurial.

Windows Full Install Overview Preview 02:23

An overview of the tools we will install in this section and why, including Git for WIndows, Notepad++, and P4Merge.

Git for Windows Installation Preview 05:37

A quick overview of how to install the source code management tool Git on our Windows system using the Git for Windows project.

Git Bash Window Adjustments Preview 02:05

Adjusting the Git Bash terminal we get with Git for Windows to be more readable throughout this course.

Git for Windows: Gitting Help Preview 01:10

Using the Git Bash terminal in order to get help with commands in Git.

Git for Windows: Minimal Configuration Preview 03:18

Setting up the minimum needed configuration to be allowed to do any meaningful work in Git, including giving our Name and email address to associate with any changes we make.

Notepad++ Installation Preview 05:18

Installing the text editor Notepad++ on our Windows system.

Notepad++ Git Integration Preview 04:40

Integrating our Git terminal with Notepad++ to make things easier in this course.

P4Merge Installation Preview 05:35

Installing the merge tool P4Merge onto our Windows system.

P4Merge Git Integration Preview 04:13

Integrating the features of P4Merge to be accessible by Git from within our Git for Windows terminal.

Full Mac OS X Installation Overview Preview 01:54

An overview of the tools we will install in this section and why, including Git from Apple, TextMate 2, and P4Merge.

Apple Git Installation Preview 01:07

Installing the Git source control command line tool as provided by Apple.

Gitting Help Preview 01:03

Using the git command in our terminal in order to get help with commands in Git.

Git Minimal Configuration Preview 02:22

Setting up the minimum needed configuration to be allowed to do any  meaningful work in Git, including giving our Name and email address to  associate with any changes we make.

TextMate 2 Installation Preview 01:57

Downloading and installing the text editor TextMate 2 on our Mac system.

TextMate 2 Configuration Preview 01:12

Configuring TextMate2 to be easier to read and use for this course.

TextMate 2 Git Integration Preview 01:21

Configuring Git to be able to work together with TextMate 2.

P4Merge Installation Preview 01:52

Installing the merge tool P4Merge on our Mac system.

P4Merge Git Integration Preview 04:02

Integrating the features of P4Merge to be accessible by Git from within our Mac terminal.

Git Prompt on Mac Preview 03:34

Using a specific shell script to make our Mac terminal have deeper Git integration.

Resolve Problem with MacOS Upgrade Breaking Git (new!) Preview 05:07

A guide to resolving the issue of Git not working after upgrading to a new version of Mac OS.

Bonus: Exclusive Student Discounts Preview 04:49