The Git Github Bootcamp
What you’ll learn
Understand how Git works behind the scenes
Explain the difference Git objects: trees, blobs, commits, and annotated tags
Master the essential Git workflow: adding & committing
Work with Git branches
Perform Git merges and resolve merge conflicts
Use Git diff to reveal changes over time
Master Git stashing
Undo changes using git restore, git revert, and git reset
Work with local and remote repositories
Master collaboration workflows: pull requests, “fork & clone”, etc.
Squash, clean up, and rewrite history using interactive rebase
Retrieve “lost” work using git reflogs
Write custom and powerful Git aliases
Mark releases and versions using Git tags
Host static websites using Github Pages
Create markdown READMEs
Share code and snippets using Github Gists
Requirements
Basic computer skills
Description
The following sentence is annoying, but also true: the best time to learn Git was yesterday. Fortunately, the second best time is today! Git is an essential tool for work in any code-related field, from data science to game development to machine learning. This course covers everything you need to know to start using Git and Github in the real-world today!The course’s 20+ sections are broken down into four separate units:Git Essentials Next Level GitGithub & CollaborationThe Tricky BitsWe start off with Git Essentials. The goal of this unit is to give you all the essential Git tools you need for daily use. We start off talking about version control software, what it is, why it matters, and the history of Git. Then we install Git and run through the Unix commands you’ll need to work with Git (you can skip this if you’re already familiar). The bulk of this unit is focused on teaching the core Git mechanics like committing and branching and the associated concepts: the working directory, the repository, the staging area, etc. We cover Git commands including: git init, git add, git commit, git status, git log, git branch, and git merge. We end with a detailed look at branching, merging, and resolving conflicts. Then we move on to out Next Level Git unit, where we cover additional commands and Git concepts that are extremely useful, but maybe not as “core” as the Git Essentials. We start with a comprehensive look at the gif diff command and the various comparisons that we can make between commits, branches, the working directory, the staging area, and more! We pay special attention to reading and parsing the dense output generated by diffs. Then we shift our focus to stashing with the git stash command, a “convenience command” that many users love incorporating into their Git workflow. Finally, we dive deep into undoing changes and time traveling with Git. We learn how to revisit earlier work, detach and re-attach HEAD, and discard changes. We cover git commands that help us undo changes including git checkout, git restore, git reset, and git revert.Next up, we change gears to focus on Github & Collaboration. We start by exploring Github (and similar tools) that host remote repositories and discussing the benefits they provide. We create our own Github repositories and sync up changes between our remote and local repositories using the git push, git pull, and git fetch commands. We then focus on commonly used collaboration workflows that students may encounter in the real world: feature branching, pull requests, forking & cloning, and more! We discuss contributing to open source projects and configuring Github repositories for collaboration. We also spend some time learning about useful Github features including Github Gists and Github Pages for free static hosting.The last unit in the course, The Tricky Bits, is really just a collection of useful Git command and advanced topics. We start by covering one of the “scarier” Git commands: rebasing! We discuss the potential benefits and pitfalls of rebasing and compare it to merging. Then we learn how to clean up our Git history by rewording, editing, dropping, and squashing commits using the interactive rebase command. Next, we discuss Git tags (lightweight and annotated tags) semantic versioning and tagging workflows. After that, we move on to a deep dive into the inner workings of Git. We discuss the files and folders Git uses internally, the role of hashing functions in Git, and the role of Git objects (blobs, trees, etc.). Next, we talk about reference logs and the git reflog command. Specifically, we learn how we can use reflogs to rescue “lost” commits and undo rebases. Finally, we learn how to write custom and powerful Git aliases!Throughout the course, you’ll find tons and tons of diagrams and visual references I’ve created to try and explain Git. The course also includes exercises I’ve tested on my in-person students, to give you an opportunity to practice the concepts in the course along the way. If you are reading this sentence, I congratulate you on making it this far 🙂 I hope you enjoy the course!
Overview
Section 1: Course Orientation
Lecture 1 Welcome To The Course!
Lecture 2 Join Our Community!
Lecture 3 What The Course Covers
Lecture 4 A Note On The Exercises
Lecture 5 Accessing The Slides & Diagrams
Section 2: Introducing…Git!
Lecture 6 What Really Matters In This Section
Lecture 7 What Exactly Is Git?
Lecture 8 Visualizing Git
Lecture 9 A Quick History Of Git
Lecture 10 Who Uses Git?
Lecture 11 Git Vs. Github: What’s The Difference?
Section 3: Installation & Setup
Lecture 12 What Really Matters In This Section
Lecture 13 Installing Git: Terminal Vs. GUIs
Lecture 14 WINDOWS Git Installation
Lecture 15 MAC Git Installation
Lecture 16 Configuring Your Git Name & Email
Lecture 17 Installing GitKraken (Our GUI)
Lecture 18 Terminal Crash Course: Introduction
Lecture 19 Terminal Crash Course: Navigation
Lecture 20 Terminal Crash Course: Creating Files & Folders
Lecture 21 Terminal Crash Course: Deleting Files & Folders
Section 4: The Very Basics Of Git: Adding & Committing
Lecture 22 What Really Matters In This Section
Lecture 23 What Is A Git Repo?
Lecture 24 Our First Commands: Git Init and Git Status
Lecture 25 The Mysterious .Git Folder
Lecture 26 A Common Early Git Mistake
Lecture 27 The Committing Workflow Overview
Lecture 28 Staging Changes With Git Add
Lecture 29 Finally, The Git Commit Command!
Lecture 30 The Git Log Command (And More Committing)
Lecture 31 Committing Exercise
Section 5: Commits In Detail (And Related Topics)
Lecture 32 What Really Matters In This Section
Lecture 33 Navigating The Git Documentation
Lecture 34 Keeping Your Commits Atomic
Lecture 35 Commit Messages: Present Or Past Tense?
Lecture 36 Escaping VIM & Configuring Git’s Default Editor
Lecture 37 A Closer Look At The Git Log Command
Lecture 38 Committing With A GUI
Lecture 39 Fixing Mistakes With Amend
Lecture 40 Ignoring Files w/ .gitignore
Section 6: Working With Branches
Lecture 41 What Really Matters In This Section
Lecture 42 Introducing Branches
Lecture 43 The Master Branch (Or Is It Main?)
Lecture 44 What On Earth Is HEAD?
Lecture 45 Viewing All Branches With Git Branch
Lecture 46 Creating & Switching Branches
Lecture 47 More Practice With Branching
Lecture 48 Another Option: Git Checkout Vs. Git Switch
Lecture 49 Switching Branches With Unstaged Changes?
Lecture 50 Deleting & Renaming Branches
Lecture 51 How Git Stores HEAD & Branches
Lecture 52 Branching Exercise
Section 7: Merging Branches, Oh Boy!
Lecture 53 What Really Matters In This Section
Lecture 54 An Introduction To Merging
Lecture 55 Performing A Fast Forward Merge
Lecture 56 Visualizing Merges
Lecture 57 Generating Merge Commits
Lecture 58 Oh No! Merge Conflicts!
Lecture 59 Resolving Merge Conflicts
Lecture 60 Using VSCode To Resolve Conflicts
Lecture 61 Merging Exercise
Section 8: Comparing Changes With Git Diff
Lecture 62 What Really Matters In This Section
Lecture 63 Introducing The Git Diff Command
Lecture 64 A Guide To Reading Diffs
Lecture 65 Viewing Unstaged Changes
Lecture 66 Viewing Working Directory Changes
Lecture 67 Viewing Staged Changes
Lecture 68 Diffing Specific Files
Lecture 69 Comparing Changes Across Branches
Lecture 70 Comparing Changes Across Commits
Lecture 71 Visualizing Diffs With GUIs
Lecture 72 Diff Exercise
Section 9: The Ins and Outs of Stashing
Lecture 73 What Really Matters In This Section
Lecture 74 Why We Need Git Stash
Lecture 75 Stashing Basics: Git Stash Save & Pop
Lecture 76 Practicing With Git Stash
Lecture 77 Git Stash Apply
Lecture 78 Working With Multiple Stashes
Lecture 79 Dropping & Clearing The Stash
Lecture 80 Stashing Exercise
Section 10: Undoing Changes & Time Traveling
Lecture 81 What Really Matters In This Section
Lecture 82 Checking Out Old Commits
Lecture 83 Re-Attaching Our Detached HEAD!
Lecture 84 Referencing Commits Relative to HEAD
Lecture 85 Discarding Changes With Git Checkout
Lecture 86 Un-Modifying With Git Restore
Lecture 87 Un-Staging Changes With Git Restore
Lecture 88 Undoing Commits With Git Reset
Lecture 89 Reverting Commits With…Git Revert
Lecture 90 Undoing Changes Exercise
Section 11: Github: The Basics
Lecture 91 What Really Matters In This Section
Lecture 92 What Does Github Do For Us?
Lecture 93 Why You Should Use Github!
Lecture 94 Cloning Github Repos With Git Clone
Lecture 95 Cloning Non-Github Repos
Lecture 96 Github Setup: SSH Config
Lecture 97 Creating Our First Github Repo!
Lecture 98 A Crash Course on Git Remotes
Lecture 99 Introducing Git Push
Lecture 100 Touring A Github Repo
Lecture 101 Practice With Git Push
Lecture 102 A Closer Look At Git Push
Lecture 103 What does “git push -u” mean?
Lecture 104 Another Github Workflow: Cloning First
Lecture 105 Main & Master: Github Default Branches
Lecture 106 Github Basics Exercise
Section 12: Fetching & Pulling
Lecture 107 What Really Matters In This Section
Lecture 108 Remote Tracking Branches: WTF Are They?
Lecture 109 Checking Out Remote Tracking Branches
Lecture 110 Working With Remote Branches
Lecture 111 Git Fetch: The Basics
Lecture 112 Demonstrating Git Fetch
Lecture 113 Git Pull: The Basics
Lecture 114 Git Pull & Merge Conflicts
Lecture 115 A Shorter Syntax For Git Pull?
Section 13: Github Grab Bag: Odds & Ends
Lecture 116 What Really Matters In This Section
Lecture 117 Github Repo Visibility: Public Vs. Private
Lecture 118 Adding Github Collaborators
Lecture 119 Github Collaboration Demo
Lecture 120 What are READMEs?
Lecture 121 A Markdown Crash Course
Lecture 122 Adding a README To A Project
Lecture 123 Creating Github Gists
Lecture 124 Introducing Github Pages
Lecture 125 Github Pages Demo
Section 14: Git Collaboration Workflows
Lecture 126 What Really Matters In This Section
Lecture 127 The Pitfalls Of A Centralized Workflow
Lecture 128 Centralized Workflow Demonstration
Lecture 129 The All-Important Feature Branch Workflow
Lecture 130 Feature Branch Workflow Demo
Lecture 131 Merging Feature Branches
Lecture 132 Introducing Pull Requests
Lecture 133 Making Our First Pull Request
Lecture 134 Merging Pull Requests With Conflicts
Lecture 135 Configuring Branch Protection Rules
Lecture 136 Introducing Forking
Lecture 137 Forking Demonstration
Lecture 138 The Fork & Clone Workflow
Lecture 139 Fork & Clone Workflow Demonstration
Section 15: Rebasing: The Scariest Git Command?
Lecture 140 What Really Matters In This Section
Lecture 141 Why is Rebasing Scary? Is it?
Lecture 142 Comparing Merging & Rebasing
Lecture 143 Rebase Demo Pt 1: Setup & Merging
Lecture 144 Rebasing Demo Pt 2: Actually Rebasing
Lecture 145 The Golden Rule: When NOT to Rebase
Lecture 146 Handling Conflicts & Rebasing
Section 16: Cleaning Up History With Interactive Rebase
Lecture 147 What Really Matters In This Section
Lecture 148 Introducing Interactive Rebase
Lecture 149 Rewording Commits With Interactive Rebase
Lecture 150 Fixing Up & Squashing Commits With Interactive Rebase
Lecture 151 Dropping Commits With Interactive Rebase
Section 17: Git Tags: Marking Important Moments In History
Lecture 152 What Really Matters In This Section
Lecture 153 The Idea Behind Git Tags
Lecture 154 A Side Note On Semantic Versioning
Lecture 155 Viewing & Searching Tags
Lecture 156 Comparing Tags With Git Diff
Lecture 157 Creating Lightweight Tags
Lecture 158 Creating Annotated Tags
Lecture 159 Tagging Previous Commits
Lecture 160 Replacing Tags With Force
Lecture 161 Deleting Tags
Lecture 162 IMPORTANT: Pushing Tags
Section 18: Git Behind The Scenes – Hashing & Objects
Lecture 163 What Really Matters In This Section
Lecture 164 Working With The Local Config File
Lecture 165 Inside Git: The Refs Directory
Lecture 166 Inside Git: The HEAD file
Lecture 167 Inside Git: The Objects Directory
Lecture 168 A Crash Course On Hashing Functions
Lecture 169 Git As A Key-Value Datastore
Lecture 170 Hashing With Git Hash-Object
Lecture 171 Retrieving Data With Git Cat-File
Lecture 172 Deep Dive Into Git Objects: Blobs
Lecture 173 Deep Dive Into Git Objects: Trees
Lecture 174 Deep Dive Into Git Objects: Commits
Section 19: The Power of Reflogs – Retrieving “Lost” Work
Lecture 175 What Really Matters In This Section
Lecture 176 Introducing Reflogs
Lecture 177 The Limitations of Reflogs
Lecture 178 The Git Reflog Show Command
Lecture 179 Passing Reflog References Around
Lecture 180 Time-Based Reflog Qualifiers
Lecture 181 Rescuing Lost Commits With Reflog
Lecture 182 Undoing A Rebase w/ Reflog – It’s A Miracle!
Section 20: Writing Custom Git Aliases
Lecture 183 What Matters In This Section
Lecture 184 The Global Git Config File
Lecture 185 Writing Our First Git Alias
Lecture 186 Setting Aliases From The Command Line
Lecture 187 Aliases With Arguments
Lecture 188 Exploring Existing Useful Aliases Online
Anyone interested in learning Git in any capacity :),Anyone learning to code or hoping to enter a tech field,Web developers, data scientists, software engineers, mobile developers, game developers, etc.,Anyone who works with code or in a code-adjacent role
Course Information:
Udemy | English | 17h 3m | 8.63 GB
Created by: Colt Steele
You Can See More Courses in the Developer >> Greetings from CourseDown.com