Fetch and pull master. Review our first conflict when trying to merge

GIT: From Beginner to Fearless

Getting Started

Welcome to GIT: From Beginner to Fearless! (3:52)
Setup an account at GitHub (3:19)
Create a new repository at GitHub (3:56)
Setup An Account At BitBucket (3:06)
Create our first Repository at BitBucket (3:18)
Get setup with Git on your local machine [Windows] (5:11)
Get Setup with Git on your local machine [Linux] (2:04)
Get setup with Git on your local machine [Mac]
Git config command: [git config] (5:15)
Git Init command [git init] (5:42)
Cloning a Public Repository (3:59)
Git Credentials Part 1 [git config] (9:55)
Git Credentials Part 2 [git config] (9:50)
Activity: Setting GIT Credentials
Cloning a Private repository (4:17)
Pull some changes from the repository (4:40)
Add, Commit, and Push some files to the repository (6:47)
Forking an existing Repository - another way to start your own repo (5:27)

We've seen it in action, now Let's talk a bit about Git

[Coming soon] Centralized, Distributed, and/or Local only, that is the question...
[Coming soon] Working Directory, Staging changes, Committing changes
[Coming soon] Pushing and Pulling changes
[Coming soon] What is a remote tracking branch?
[Coming soon] Things that shouldn't scare you now and by the time you are done with the course

Getting Setup for the rest of the course

I already have a project, how do I get it on a remote repository (9:48)
Fork my own project repository. (9:48)
[OPTIONAL] Git Viz [Requires Visual Studio and the .net framework] (8:25)
Visualizing GIT with D3

Check the state of the local repo and keep files and folders from being added to the repository

Activity: What is the state of my repo?: an activity using [git status], [git log], [git show], and [git diff]
Git status command: [git status] part 1 (8:36)
Git status command: [git status] part 2 (6:45)
Git status command: [git status] part 3 (7:44)
Activity: Keeping files out of the repo and including others with the .gitIgnore file
Git Ignore command [git ignore] part 1 (7:39)
Git Ignore command [git ignore] part 2 (8:08)
Git Ignore command [git ignore] part 3 (9:32)
Git Ignore command [git ignore] part 4 (8:05)

Basic Git Operations: A general flow for a single developer [and a review of some of the major concepts we've covered so far]

[Conquered Fear] No more fear of losing work (3:13)
[Review] Staging changes with the Git Add command: [git add] (9:49)
[Review] Committing your changes with the Git commit command: [git commit] (5:32)
[Review] Commit your changes to the remote repository using the Git push command: [git push] (3:53)
[Review] Get changes from the repository using the Git pull command: [git pull] (3:40)
[Review] Viewing your Git commit history using the Git log command: [git log] and [git show] (5:26)

Tools to improve our ability to work with Git and the Bash command-line Terminal

Activity: Set VSCode as our default editor
Get a text editor for use when editing files [i.e. VS Code, SublimeText, Brackets, or something else you like] (3:49)
Setting the default Editor [don't worry: you can still use VI if you really want to] (5:13)
Activity: Set up VSCode to be our default difftool
Setting and using a diff tool to view differences [with VSCode] (8:25)
Turn off the difftool prompt (4:42)

Branching - and an Advanced Single-Developer Flow and prep for multi-developer flow using Local and Remote branches

Introduction to Branching (5:58)
Always remember to git pull when starting a new workflow! (1:28)
Create a local branch (4:42)
Make changes, add, commit, switch branches, see that things are different across branches (7:22)
Introduction to merging (9:48)
Checkout master, merge feature branches, and push to GitHub (7:03)
Create a local branch and publish to GitHub - so that I can have pull requests/merging handled at GitHub, not locally (6:15)
Creating your first individual development branch at GitHub (3:12)
Fetch And Checkout Local version tracking to Remote Branch that was created at GitHub (3:38)
Quick Review: Make your changes, add, commit your changes locally (1:37)
Push to your branch at GitHub (2:10)
Create a pull request at GitHub (5:30)
Merge the Pull Request at GitHub (4:32)
Fetch and Pull changes from Remote [GitHub] to local after the pull request is completed to continue working (8:46)
Delete a branch from your local repository (4:23)
Delete a branch at GitHub [remote] using Git Bash (5:34)
Delete a branch with force delete -D (7:39)
Delete And Restore Branches at GitHub (6:23)
Use git prune to clean up remote references that no longer exist (10:09)

Intermediate Git Operations: A simple multi-developer flow with Merge Conflicts

Create an organization at GitHub for your team (3:16)
Setting Up Teams, Projects, account privileges, and Creating And Transferring Repos to the Team (8:06)
Getting our team repo setup on Local from DefaultWeb to Ultimate Default Web, and pushing out to our TEAM REMOTE repository (4:36)
[Review] Create your feature branch at GitHub (1:38)
[Review] Get your LOCAL repo in sync with master using git fetch and git pull, then checkout your branch. Review branches with git branch (2:51)
[Review] Make changes, commit to your branch, do not push out to GitHub yet. (2:37)
SIMULATE a multiple developer by making a change at GitHub [new branch, quick change, pull request, merge] (5:17)
Fetch and pull master. Review our first conflict when trying to merge your change into the master branch locally. (9:34)
Push, Pull Request, and merge your changes into master at GitHub after successfully resolving the merge commit locally (6:09)
Setting and using a merge tool to resolve merge conflicts [with VSCode or p4Merge] (4:05)
Create another conflict from dev 2 and dev 1 (6:28)
Sync Up Master on Local again to avoid merge conflict at GitHub (6:28)
Solve the merge conflict with our default merge tool, then push and commit via pull request at GitHub (6:28)
Create another conflict between dev 1 and 2 changes, Resolve at GitHub while creating the Pull Request (7:49)

Advanced Git Commands

Activity: Amending Commits
Amending a previous commit - changing the commit message:: [git commit --amend] (6:00)
Amending a previous commit: adding a file to a previous commit. [git commit --amend] (3:57)
Activity: Exploring the Reflog
Git reflog part 1 (8:15)
Git reflog part 2 (7:28)
Activity: Squash And Merge at GitHub
Squash And Merge at Github part 1 (9:08)
Squash and Merge at GitHub part 2 (7:58)
Squash and Merge at GitHub part 3 (9:28)
Activity: Using Aliases
Using Aliases (5:31)
Always Prune on Fetch (1:47)
Activity: Reset and Clean
Performing a soft reset [git reset] (6:38)
Hard Reset and clean on current commit [git reset --hard && git clean ] (7:49)
Hard Reset on a previous commit - merge into master - quick 'bug fix' (9:40)
Activity: Reverting one or more commits
Git revert command: [git revert] (4:56)
Introduction to Rebasing (6:17)
Activity: Rebasing
Git rebase Activity 1: [git rebase] (7:29)
Git rebase Activity 2 (7:23)
Git rebase Activity 3 (9:59)
Activity: Cherry Picking
Cherry Picking (9:35)
Activity: Stashing changes
Git stash command, part 1: [git stash] (9:42)
Git Stash Part 2 (7:15)
Real Life Activity 01 - I committed to my local master, how do I fix this without losing my changes
Real Life Activity 02: I commited to local master and pushed to remote master without thinking - how do I fix this?
Real Life Activity 03 - Remove developer commits from remote master and keep consecutive commits in history.

Using Tags to manage releases

Activity: Tagging
Tagging commits with version and other information using the Git tag command: [git tag] (10:35)

Other Workflows

[Coming soon] Integration Manager Workflow Overview
[Coming soon] Dictator and Lieutenants Workflow Overview

Using GIT from Visual Studio

[Coming soon] A brief overview of working with GIT via Visual Studio

Final Thoughts

[Coming soon] Next steps
[Coming soon] Conclusion

Fetch and pull master. Review our first conflict when trying to merge your change into the master branch locally.

Lecture content locked

If you're already enrolled, you'll need to login.

Enroll in Course to Unlock