Git Going with Comparing, Branching and Merging
4.1 (264 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.
3,062 students enrolled

Git Going with Comparing, Branching and Merging

Comprehensive, step-by-step guide to Comparing, Branching, Merging and Rebasing in the Git source control system
4.1 (264 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.
3,062 students enrolled
Created by Jason Taylor
Last updated 9/2018
English
English
Current price: $34.99 Original price: $49.99 Discount: 30% off
5 hours left at this price!
30-Day Money-Back Guarantee
This course includes
  • 2 hours on-demand video
  • 1 article
  • 1 downloadable resource
  • 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
  • Install Git and related tools, specifically for comparing and merging
  • Compare (diff) between various parts within Git (branches, commits, and more)
  • Create, manage, and delete branches
  • Merge branches and resolve conflicts
  • Rebase branches and resolve conflicts
Course content
Expand all 37 lectures 02:14:43
+ Introduction
1 lecture 04:53

An overview of the topics covered in this course, including branching, merging, and resolving conflicts in Git.

Preview 04:53
+ Windows Installation
6 lectures 21:55

A guide to what software is going to be installed in this section for this course.

Preview 00:44

A guide to installing and setting up the source management tool Git for Windows.

Preview 05:40

A guide to installing the text editor Notepad++.

Notepad++ Install
02:08

A guide to configuring Notepad++ to work better for this course.

Notepad++ Configuration
03:23

A guide to installing the merge tool P4Merge.

P4Merge for Windows Install
05:42

A guide to configuring P4Merge on Windows.

P4Merge for Windows Configuration
04:18
+ Mac OS X Installation
6 lectures 14:26

An overview to the tools that will be installed in this section for this course.

Preview 00:56

A guide to getting the Apple provided version of the source control tool Git.

Preview 01:11

A guide to installing the text editor TextMate 2 on Mac OS.

TextMate 2 Install
03:09

A guide to configuring TextMate 2 to improve usability for the rest of this course.

TextMate 2 Configuration
03:06

A guide to installing the merge tool P4Merge on Mac OS.

P4Merge for Mac Install
01:57

A guide to configuring P4Merge on Mac OS.

P4Merge for Mac Configuration
04:07
+ Setup
1 lecture 03:08

Cloning the GitHub repository for this course onto your personal GitHub account and then downloading the repository onto your local system.

Preview 03:08
+ Comparing in Git
8 lectures 21:31

Setting up our Git Repository in order to be able to do comparisons in later lessons.

Git Repository Setup (for Comparing examples)
05:47

Using P4Merge in order to compare our current GIt repository to the staged changes of our Git repository.

Preview 02:24

Comparing our current working directory in Git to the last commit on the Git repository.

Comparing Working Directory and the Git Repository (Last Commit)
01:44

Comparing our Git staging area to the last commit on the Git repository.

Comparing Between the Staging Area and the Git Repository (Last Commit)
01:38

Limiting a comparison to a single file to focus in on what changes were made to just that file.

Limiting Comparisons to one File (or Path)
01:54

Comparing any arbitrary commit to another arbitrary commit in Git.

Comparing Between Commits
04:32

Comparing commits between our local Git repository and our remote GitHub repository, in order to help with pulling down changes that may conflict.

Comparing Between Local and Remote Master Branches
02:00

Pushing our changes up to GitHub now that we have verified the changes, as well as general cleanup for this section.

Comparison Section Cleanup and Push back to GitHub
01:32
+ Branching and Merging in Git
6 lectures 34:01

An overview of the basic branching techniques that will be covered in this section by creating our first branch on Git that isn't our Master branch.

Preview 04:43

Merging branches in the easiest way possible, in which the changes can be smoothly integrated with no issues.

Happy Path / Fast Forward Merges
06:39

Disabling the easy path to merging in order to complicate the merge history when needed.

Happy Path / Disable Fast Forward Merges
04:07

Creating a slightly more complicated merge, in which changes from both branches can automatically be integrated in with each other.

Automatic Merges
05:25

Resolving conflicts that arise when the same code is changed in two different branches in our Git repository.

Conflicting Merges and Resolution
11:35

Cleaning up what we have done in this section and pushing those changes back up to our remote GitHub repository.

Section Clean up and Push back to GitHub
01:32
+ Rebasing in Git
6 lectures 23:34

A guide to basic rebaseing within Git, in which we will take two branches with different changes to create a cohesive linear commit history.

Simple Rebase Example
08:16

Setting up a conflict that will make our rebase process a bit more complex.

Setup a Rebasing Conflict
02:45

Aborting a Git rebase in case that isn't what is wanted.

Abort a Rebase
02:01

Resolving merge conflicts in order to allow our rebase to continue.

Rebase Conflict and Resolution
03:59

Rebasing our local repository with our remote repository in order to create a linear history path between the two.

Pull with Rebase (GitHub)
04:45

Cleaning up our repository after we are finished rebasing and pushing up those changes to our remote GitHub repository.

Section Cleanup and Push to GitHub
01:48
+ Updates and Errata
1 lecture 05:07

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

Git Mac OS X Updates
05:07
+ Conclusion
2 lectures 06:08

An review of the topics we covered in this course, including branching, merging, and resolving conflicts in Git.

Review
01:19
Bonus: Exclusive Student Discounts
04:49
Requirements
  • Basic Computer Skills
  • Ability to install software on your system
  • Admin rights may be required for software installation
  • Basic understanding of Git source control (add, commit, push and pull)
Description

Git Going with Comparing, Branching and Merging

Are you sure how to compare between commits, branches or the three states of Git? Do merges cause you trouble? What is a rebase, anyway?

In this course, students will walk though comparing (diffs), branching, merging and rebasing in Git. At the end of this course, students will have a firm understanding and experience with those paricular aspects of Git. Note: This is not a comprehensive course on Git -- we focus exclusively on comparing, branching, merging, and rebasing.

Recent Course Updates

  • October 17: Added Updates and Errata section

Course Outline

Course Introduction and Overview provides an introduction to this course.

After the introduction, the first thing we do is Git Installation for both Windows and Mac. There are dedicated sections for Windows and Mac -- so students can jump directly to the lectures specifically designed for their system. After the installation process, we will download the example project repository from GitHub (clone) which we will use throughout the course.

After installation and downloading the example project, we explore ways to make Comparisons in Git, including all the different local states, between commits, and between local and remote repositories.

We give great attending to Branching and Merging in Git. We start off with the simple "happy path" and learn about "Fast-Forward" merges and how to control them. The we walk through common "automatic" merges. Finally, we cause trouble on purpose so we can step through resolving conflicting merges with our visual merge tool.

With a strong foundation in branching and merging, we will then cover a more complex topic, Rebasing. In that section, we cover several rebasing examples, including how to resolve a rebase conflict.

All tools have installation and configuration sections to ensure no one is left behind.

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. There is nearly 2 hours of screencast based video training in order to step through each command or action in sufficient detail.

Special Notes

This course is part of the "Git Going" series and is included with the Git Complete comprehensive course. If you are already enrolled in that course, do not enroll in this course.

This course makes extensive use of the command line. Each command is discussed in detail, so everyone can follow along.

Who this course is for:
  • Anyone that needs learn about comparing, branching, merging and rebaseing within Git
  • Not for Git beginner (should be taken after intro course on Git)
  • Software engineers, developers, programmers on teams using branches