Git for Geeks: Quick Git Training for Developers

A quick overview of what Git is, a decentralized or distributed version control system that works off of local operations to allow it to be quick and large in scale. Git is considered de-facto for version control, making it widely supported.

In Git, the collection of files being managed and all of their version history is considered the repository. Not everything in the folder has to be managed by Git, but the .git folder is what contains all of the versioning files.

Commits are snapshots of an entire repository, showing the changes between it and the previous state of the Git repository's files. These commits follow a timeline of events to get you from one point to the next.

An overview of the way that this section lists out all tools to be installed in concise, slide driven installation guides.

An overview of what we will need to install on Windows for this course, including Git for Windows, Notepad++, and P4Merge.

An overview of what we will need to install on Mac OS for this course, including Git from Apple, TextMate 2, and P4Merge.

Continuing with our demo repository by adding files and checking out the status of the repository using the "git status" command to build up to our initial commit.

Understanding the inner workings of the Git repository by looking in and seeing what happens when the ".git" folder is removed.

Adding Git source control to an existing folder and files, recreating our Git project that we just started.

Adding new files before our initial commit on our newly created Git repository, using special characters to add multiple files at once.

Using "git log" to show the listing of commits that are part of this repository.

Editing an existing file that is currently managed by Git, in order to show how Git tracks modified files and how Git can add and commit these changes in one command.

Backing out changes by reverting changes from our staging area and then reverting the changes entirely.

Using the Git log command to display an easier to read commit log history, before making an alias that will run that command without having to type the full command out.

Using Git to rename and delete files, which will keep track of the changes between renames and deletes.

Using non-Git based commands to rename and remove files outside of Git in order to show how this messes up the Git history and to then show how to add the link back so Git can properly track the files.

Using the ".gitignore" file to exclude files that we don't want in our Git repository by using expressions to exclude files by extension type.

A description of the more advanced topics that will be covered in this section, including comparing changes, branching, creating milestones, time travel, and more.

Using "git diff" to show differences between two commit points within our Git history.

An explanation of what branches are, including diagrams of the most common types of branch resolutions, including fast forward, no fast forward, automatic merges, and manual merge conflicts.

An explanation of what special markers do, allowing you to access special points on the Git repository, such as HEAD, which is the most recent commit.

Creating and managing branches other than Master in our Git repository, then merging in those changes with the easiest path, a fast forward merge, finally deleting the branch we no longer need.

Creating a conflict between branches and walking through the steps to use our merge tool to resolve the conflict.

Looking at adding tag onto specific commits in Git. This allows us to create tags to associate with commits in our history in order to mark out milestone builds for future reference with a lot more detail.

Saving progress in our current repository by stashing our changes to be able to unpack them inside a different branch, effectively moving the changes so we don't have to destroy them.

Resting to arbitrary commits using "reset" and using "reflog" to display all of those changes, before finally resetting our history to the current commit without losing any history.

Exploring the remote side of Git by looking at the two main hosting services BitBucket and GitHub.

A quick explanation of what remote repositories are, basically a backup copy of your Git repository but on a remote service such as BitBucket or GitHub.

Bit bucket is a remote repository hosting service that can either be cloud hosted or hosted on a local system. The payment model is based on the number of contributors to private repositories.

Signing up for an account with BitBucket that we will use to create our remote copy of our local repository.

Creating our first demo repository in BitBucket using the basic repository creation interface.

Connecting the demo repository we just created on BitBucket to the existing project that we have on our local system.

Pushing the changes on our local repository to the remote BitBucket repository we just linked to the local repository.

Removing the remote BitBucket repository reference that we added to our local Git Repository.

Comparing the differences between GitHub and BitBucket. This comparison is out of date, as GitHub offers a fairly similar model of private repositories to BitBucket.

A quick overview of GitHub, which is currently owned by Microsoft, no longer GitHub itself. As such, GitHub has lost some popularity in hosting open source projects.

Signing into GitHub and creating a simple example repository, which we link to our local repository by pushing up our changes from our local side to the remote GitHub repository.

Using GitHub to create a repository on the remote side before then cloning it down to our local system, in order to ease the process of linking the two together.

Looking over the differences between fetch and pull, where fetch only looks at the differences and updates the remote references and pulling takes those changes down and tries to integrate them to our local repository.

A quick overview of what has been covered in this course, and how it will help you to be a better developer by using source control.

A guide to the programs that will be installed in this section, including Git for Windows, Notepad++, and P4Merge.

Installing the versioning software Git for Windows onto our local Windows System.

Tweaking Git for Windows to be more usable throughout the rest of this course.

Getting help on commands we are going to be using in this course by using the "git help" command to detail how to use things.

Setting up the minimal configuration needed by Git to get our Git for Windows setup working.

Installing the text editor Notepad++ onto our local Windows system.

Integrating our text editor Notepad++ with our install of Git for Windows.

Installing the merge tool P4Merge onto our local Windows installation.

Integrating the functionality provided by P4Merge into Git.

A guide to the programs that will be installed in this section, including Git from Apple, TextMate 2, and P4Merge.

Installing the versioning software, Git, on our local system using the command line utility provided by Apple.

Getting help on commands we are going to be using in this course by using the "git help" command to detail how to use things.

Setting up the minimal configuration needed by Git to get our Git setup working.

Installing the text editor TextMate 2 on our local Mac OS system.

Configuring TextMate 2 to be more usable throughout the rest of this course.

Configuring TextMate 2 to integrate closely with our installation of Git.

Installing the merge tool P4Merge onto our local Mac OS X installation.

Integrating the functionality provided by P4Merge into Git.

Updating our terminal prompt to be more usable throughout this section by using a script.

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