Play Speed
  • 0.5x
  • 1x (Normal)
  • 1.25x
  • 1.5x
  • 2x
52 Videos (4h 21m)
    • Introduction and Welcome: Git - Branching and Merging

      2:41
    • Before we start: What we won't be covering in this course

      1:34
    • Get Setup with an Account at GitHub

      3:19
    • Setup our first repo at GitHub

      3:56
    • Get GIT on Windows

      5:11
    • Get GIT on Ubuntu

      2:04
    • Get GIT on a Mac

      2:25
    • Get VS Code for use as a difftool, mergetool, and Editor

      3:49
    • Setting VS Code as our Default Editor

      5:13
    • Add an existing project to a remote repository

      9:48
    • Stage changes to Index with [git add]

      9:49
    • Commit changes with [git commit]

      5:32
    • Push changes to remote at GitHub with [git push]

      3:53
    • Pull changes from remote to local with [git pull]

      3:40
    • Reviewing our history and commits with [git log] and [git show]

      5:26
    • Configure GIT to use VSCode as our default DiffTool

      8:25
    • Remove prompting for the diff tool in GIT

      4:42
    • Configure GIT to use VSCode as our default mergetool

      4:05
    • Introduction to Branching

      5:47
    • Always remember: Do a GIT pull

      1:28
    • Create local branches with [git branch]

      4:42
    • Make changes, add, commit, and switch branches. See the difference

      7:22
    • Introduction to Merging

      9:48
    • Merge branches and push to GitHub

      7:03
    • Push a local branch to remote

      6:15
    • Create a new branch at GitHub

      3:12
    • Fetch and checkout a new Remote Branch to our Local Repo

      3:38
    • Quick change, add, commit, status

      1:37
    • Push our latest changes to remote

      2:10
    • Create a new Pull Request

      5:30
    • Merge a Pull Request

      4:32
    • Pull the latest to even out our branches

      8:46
    • Delete a local branch

      4:23
    • Use GIT bash to delete a branch at origin from the command line

      5:34
    • Force Delete a branch

      7:39
    • Delete branches at GitHub

      6:23
    • Cleanup local repository branches and references

      10:09
    • Setup an Organization at GitHub to simulate multiple developers

      3:16
    • Setup Teams and Projects at GitHub

      8:06
    • Getting the team repository setup

      4:36
    • Creating a feature branch as developer 1

      1:38
    • Sync to local and checkout the feature branch

      2:51
    • Make some changes and commit

      2:37
    • Simulate another team member making a change

      5:17
    • Resolve the merge conflict locally

      9:34
    • Push changes to GitHub branch, and merge a pull request

      6:09
    • Simulate another conflict

      6:28
    • Setup to resolve the merge conflict

      1:59
    • Use a Merge Tool to resolve conflicts, then push and commit the changes

      6:28
    • Resolve a merge conflict directly at GitHub

      7:49
    • GIT: Branching and Merging: Conclusion

      1:40
    • What to do/learn Next

      0:52

About This Class

This course is an introduction and overview of branching and merging with GIT.  By the time you complete this course, you'll be able to understand what it means to create branches locally or at a remote repository.  You'll have a great command of keeping your branches up-to-date and cleaning up both your local and remote repository.

By the end of the course, you'll be in command of working with teams at GitHub and using Pull Requests to validate changes by multiple developers.  You'll know how to make sure you get their changes as well, and finally you'll be able to resolve merge conflicts locally and at GitHub.

Why should you learn the command line when tools are available like Visual Studio, E-Git, GitHub for desktops, and many others?  Because all tools are just wrappers around the commands.  If you use the tools you should be fine, but what about when things go wrong?  Who will help you then?  Knowing the commands makes it EASY to go to using any IDE with Git.  Not knowing the commands could be the difference between doing something wrong or just not knowing what to do at all.

Here are some of the commands we'll be interacting with during this course [and you'll get good at using them -- however -- we won't MASTER any of them, but --after this course -- you'll be able to take the study deeper on your own from here for any of these commands!].

  1. git add
  2. git commit
  3. git push
  4. git pull
  5. git fetch
  6. git status
  7. git log
  8. git show
  9. git checkout
  10. git diff
  11. git difftool
  12. git merge
  13. git mergetool
  14. git config

Additionally, this course will show you how to setup a default tool for editing, git difftool, and git mergetool [VSCode in this course, but you could use Perforce P4Merge or another tool if you want]. 

1

Student

--

Projects

0

Reviews (0)

Brian Gorman

Software Engineer & Instructor

I am an experienced .Net developer, previously certified as an MCSD .Net in C#.net [expired]. I have a masters of science degree in computer information systems, and a bachelor of science degree in computer science. I also have many years of experience instructing college courses online in SQL databases, C#/VB .Net programming, Java programming, and Microsoft Office. I have created many online technical training courses which can be found at my website. I also run MajorGuidanceSolutions, a tr...

See full profile

Technology Web Development Git Github