Git for Geeks: Quick Git Training for Developers
4.4 (970 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
6,055 students enrolled

Git for Geeks: Quick Git Training for Developers

Learn the core features of Git in less time for experienced software engineers new to Git
4.4 (970 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
6,055 students enrolled
Created by Jason Taylor
Last updated 3/2019
English
English
Current price: $31.99 Original price: $49.99 Discount: 36% off
19 hours left at this price!
30-Day Money-Back Guarantee
This course includes
  • 3 hours on-demand video
  • 1 article
  • 2 downloadable resources
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
Training 5 or more people?

Get your team access to 4,000+ top Udemy courses anytime, anywhere.

Try Udemy for Business
What you'll learn
  • Learn the key concepts of the Git source control system
  • Step through the entire Git workflow
  • Compare the different states in Git
  • Manage files inside and outside the control of Git
  • Create and manage repositories on GitHub and BitBucket
  • Create branches and resolve conflicts with confidence
  • Save work in progress with Stashes
  • Mark special events with Tags
  • Even a bit of time travel within Git repositories
Course content
Expand all 74 lectures 03:15:44
+ Introduction
3 lectures 06:17

An overview of the topics that will be covered in this course, including Git basics, advanced Git, and going remote with GitHub and Bit Bucket.

Preview 02:12

A quick guide to the general approach for this curse, including step by step demos that are short and focused using the command line. As well, it is recommended to follow along with all of the examples to maximize your learning.

Preview 01:47

A quick explanation of the reasoning for using the command line to start using Git, including new features hitting the command line first, online help being targeted at folks on the command line, the command line having more power, and the cross-platform nature of the bash terminal.

Preview 02:18
+ Core Concepts
4 lectures 04:03

An overview of the foundational aspects that will be covered in this section on the basic concepts in Git. This can be skipped if you already know what Git is and does.

Preview 00:27

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.

What is Git?
01:36

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.

What is a Git Repository?
01:10

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.

How Commits Work
00:50
+ Quick Installation
5 lectures 15:57

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

Quick Installation Overview
01:02

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

Quick Install and Setup on Windows
08:37
Installation Notes for Windows
3 pages

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

Quick Install and Setup on Mac OS X
06:18
Installation Notes for Mac OS X
3 pages
+ The Basics: Foundations In Git
14 lectures 31:59

An overview of the foundational commands that will be covered in this section, including getting information, creating a basic Git workflow, doing file operations, excluding files, and undoing mistakes.

Preview 00:42

Creating a new Git repository on our local system using the command line interface with the command "git init".

Preview 01:28

An overview of the three basic states of a file in Git, including working directory, staging area, and the repository (.git folder). This may also include the fourth stage, remote, which is a separate repository tacked on at the end to mirror the local side's final repository state.

Preview 01:23

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.

The First Commit and the Basic Local Workflow (git add / git commit)
03:04

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

Discover the Git Repository
01:59

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

Starting with an Existing Project (git init)
01:56

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

Going Deeper with Commits and Messages
02:01

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

Commit Log and Showing Commit Details
01:16

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.

Combining Steps with Express Commits
02:58

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

Backing Out Changes in Stage and the Working Directory
02:12

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.

Git History and Creating Custom Git Commands with Aliases
03:50

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

Renaming and Deleting Files within Git
03:08

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.

Making Changes to Files Outside Git
03:06

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.

Excluding Unwanted Files from Git
02:56
+ Advanced: Going Deeper with Git
9 lectures 25:57

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

Advanced Overview
00:35

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

Comparing Changes (git diff / difftool)
02:39

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.

What are Branches
02:02

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.

Special Markers and HEAD
00:37

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.

Branching and Simple Merging (Easy Paths)
04:56

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

Manual Merges and Conflict Resolution
04:50

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.

Marking Important Milestones with Tagging
02:38

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.

Saving Working in Progress with Stashing
02:17

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.

Repository Time Travel with Reset and Reflog (Undo Bad Commits)
05:23
+ Going Remote with GitHub and BitBucket
13 lectures 32:40

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

Going Remote Overview
00:58

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.

What are Remote Repositories
00:38

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.

What is BitBucket?
01:49

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

Sign up for BitBucket
01:31

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

Remote Repository Creation
00:53

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

Establish Relationship Between Local and Remote Repositories
03:05

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

Updating Remote Repositories (git push)
02:45

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

Removing the Remote Repository
01:01

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.

Comparing Services: GitHub vs BitBucket
03:01

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.

What is GitHub?
01:17

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.

Working with GitHub
04:40

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.

Cloning the Repository (git clone)
04:16

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.

Update without Merge: Fetching Updates (git fetch)
06:46
+ Conclusion
1 lecture 02:00

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.

Final Words
02:00
+ Bonus: Background
4 lectures 06:12

A quick overview of the background topics that will be covered, including a bio of the instructor, a brief history of Git, and comparing Git to other source control tools available.

Preview 00:29

A quick bio of Jason Taylor, the instructor for this course, who has had a lot of practical experience using Git on large productions.

Preview 01:13

A brief history of how Git was created out of necessity to support the Linux kernel project after a license for bit keeper was revoked.

Preview 00:48

A quick comparison of the advantages and disadvantages between Git and the leading competitors, such as Mercurial and commercial offerings.

Preview 03:42
+ Bonus: Complete Windows Installation
9 lectures 34:19

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

Installation Overview
02:23

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

Git for Windows Installation
05:37

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

Git for Windows Settings and Tweaks
02:05

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.

Gitting Help
01:10

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

Minimal Git Configuration
03:18

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

Notepad++ Installation
05:18

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

Notepad++ Git Integration
04:40

Installing the merge tool P4Merge onto our local Windows installation.

P4Merge for Windows Installation
05:35

Integrating the functionality provided by P4Merge into Git.

P4Merge Git Integration
04:13
+ Bonus: Complete Mac OS X Installation
11 lectures 25:31

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

Mac OS X Installation Overview
01:54

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

Apple Git Installation
01:07

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.

Gitting Help
01:03

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

Minimal Configuration
02:22

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

TextMate 2 Installation
01:57

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

TextMate 2 Configuration
01:12

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

TextMate 2 Git Integration
01:21

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

P4Merge for Mac OS X Installation
01:52

Integrating the functionality provided by P4Merge into Git.

P4Merge Git Integration
04:02

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

Mac Git Prompt: Make Your Prompt Like Mine
03:34

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

Resolve Problem with MacOS Upgrade Breaking Git (new!)
05:07
Requirements
  • Basic computer skills
  • Ability to install software on your computer
  • Admin rights may be required for software installation
Description

Git for Geeks

This course is designed to cut academic theory to just the key concepts and focus on basics tasks in Git in order to be productive quickly. Students can expect to learn the all the main features of Git in just two hours.

New! Closed captions throughout the course!

Course Outline

Course Introduction provides a welcome to this course with a few suggestions on how to get the most out of it. After that, we cover the minimum theory before getting our hands dirty with Git in the Core Concepts section.

Quick Installation provides an overview on the installation process for all tools needed for this course. A more detailed set of instructions are available in the Bonus section.

In The Basics, we walk through all the 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.

We then go a bit deeper in the Advanced section when we cover comparing changes, branching and merging (including merge conflict resolution), tagging milestones, saving temporary work, and even a bit of time travel.

Finally, Going Remote covers publishing the locally created repository (previous sections) on GitHub and BitBucket. We cover the main concepts related to working with any remote Git repositories and compare the differences between the two most popular Git hosting services.

After the main part of the course, this course offers several bonus sections that explore some topics in more detail for those that like more information.

Course Features

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. Excluding bonus lectures, this course offers about 2 hours of screencast videos.

Several attachments throughout the course provide supplemental information, illustrations, or other reference material.

Who this course is for:
  • Anyone interested in using source control and specifically Git
  • Software engineers, developers, programmers new to Git
  • IT Managers or technical leads considering Git for version control on their team
  • Freelancers or other creative professionals