Outlecture
Home
About
Technology
Design
Video
Contact
Official
日本語
Outlecture
Home
About
Technology
Design
Video
Contact
Twitter Official
  • Home
  • Technology

Top 9 Recommended Git Self-Study Materials! [December 2023]

Last updated: Dec 7th, 2023

This page introduces the best in educational materials for beginners who are trying to learn Git on their own.

Table of Contents:

1. Description of this page

1. Description of this page

We introduce 9 recommended video courses on various platforms for those who want to learn Git on their own.

What is Git?

Git is the world's leading version control system. By adopting Git in development, version control becomes easier, and team productivity can be greatly improved. Currently, Git is adopted in most development fields and is considered as one of the essential tools for engineers.

Our site, "Outlecture," evaluates courses using our proprietary algorithm that balances course rating, freshness of information, number of purchasers and viewers, and recent rate of increase, in order to extract only the most suitable courses for users.

In addition, we will explain the features of each video platform and provide use cases such as "this is better for people in this situation."

We hope this will be a reference for everyone who is going to learn Git.

2. Top 5 Recommended Udemy Courses

Here are Outlecture's top 5 recommended Udemy courses, carefully selected for you.

Title Ratings Subscribers Subscribers last month
(November 2023)
Level Video Duration Created Last updated Price

The Git & Github Bootcamp

thumbnail
4.76 121,832 4,288 beginner 17 hours 2 minutes Jan 21st, 2021 Apr 17th, 2023 $109.99

GitHub Actions - The Complete Guide

thumbnail
4.74 26,880 2,062 beginner 10 hours 17 minutes Sep 26th, 2022 Nov 7th, 2023 $109.99

Git for Beginners

thumbnail
4.53 27,194 3,004 beginner 2 hours 19 minutes Sep 12th, 2022 Dec 15th, 2022 $79.99

Master Git and GitHub in 5 Days: Go from Zero to Hero

thumbnail
4.66 10,399 733 all 5 hours 44 minutes Sep 7th, 2022 Oct 10th, 2022 $94.99

Git & GitHub - The Practical Guide

thumbnail
4.66 33,697 742 all 10 hours 22 minutes Jul 16th, 2021 Nov 7th, 2023 $99.99

Udemy, Inc. is an education technology company that provides the world's largest online learning and teaching platform.

The features of Udemy include:

  • Over 155,000 course
  • Instructors who are leading experts in their fields
  • Affordable prices range from tens to hundreds of dollars per course, with discounts of up to 70-90% during campaigns
  • Courses can be viewed without expiration after purchase, and come with a 30-day money-back guarantee
  • Courses can be taken at the student's own pace, with playback speeds of 0.5 to 2 times normal speed, and can be viewed offline on a smartphone with a dedicated app
  • Students can ask questions directly to the instructor on the course discussion board, allowing them to resolve any doubts and receive support for self-study

These are some of the benefits of using Udemy.

The management team at Outlecture consists of active software engineers, creators, and web designers. We often catch up on learning new programming languages and products by taking courses on Udemy.
As for our experience, we find that Udemy offers courses of very high quality. The instructors are all leading figures in their fields, and they teach cutting-edge knowledge and practical know-how in a clear and detailed manner. You can acquire the knowledge and skills that are actually used in the field and in practical projects, rather than just knowledge for exams.

We highly recommend Udemy courses, especially for those who want to apply what they learn in practical situations or for those who want to start self-studying. Once you purchase a course, you can take it without a time limit, and there is a 30-day money-back guarantee, so you can start learning with peace of mind.

Recommended for

  • Planning to use Git in actual projects
  • Wanting to learn the know-how of professionals who are active in the world's cutting-edge fields
  • Hesitant to use a subscription service
  • Having basic IT knowledge

The details of each course are as follows:


The Git & Github Bootcamp

Master the essentials and the tricky bits: rebasing, squashing, stashing, reflogs, blobs, trees, & more!

thumbnail
Ratings
4.76
Subscribers
121,832
Subscribers last month
(November 2023)
4,288
Level
beginner
Video Duration
17 hours 2 minutes
Created
Jan 21st, 2021
Last updated
Apr 17th, 2023
Price
$109.99

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 Git

  • Github & Collaboration

  • The Tricky Bits

We 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!

  1. Course Orientation
  2. Welcome To The Course!
  3. Join Our Community!
  4. What The Course Covers
  5. A Note On The Exercises
  6. Accessing The Slides & Diagrams
  7. Introducing...Git!
  8. What Really Matters In This Section
  9. What Exactly Is Git?
  10. Visualizing Git
  11. A Quick History Of Git
  12. Who Uses Git?
  13. Git Vs. Github: What's The Difference?
  14. Installation & Setup
  15. What Really Matters In This Section
  16. Installing Git: Terminal Vs. GUIs
  17. WINDOWS Git Installation
  18. MAC Git Installation
  19. Configuring Your Git Name & Email
  20. Installing GitKraken (Our GUI)
  21. Terminal Crash Course: Introduction
  22. Terminal Crash Course: Navigation
  23. Terminal Crash Course: Creating Files & Folders
  24. Terminal Crash Course: Deleting Files & Folders
  25. The Very Basics Of Git: Adding & Committing
  26. What Really Matters In This Section
  27. What Is A Git Repo?
  28. Our First Commands: Git Init and Git Status
  29. The Mysterious .Git Folder
  30. A Common Early Git Mistake
  31. The Committing Workflow Overview
  32. Staging Changes With Git Add
  33. Finally, The Git Commit Command!
  34. The Git Log Command (And More Committing)
  35. Committing Exercise
  36. Commits In Detail (And Related Topics)
  37. What Really Matters In This Section
  38. Navigating The Git Documentation
  39. Keeping Your Commits Atomic
  40. Commit Messages: Present Or Past Tense?
  41. Escaping VIM & Configuring Git's Default Editor
  42. A Closer Look At The Git Log Command
  43. Committing With A GUI
  44. Fixing Mistakes With Amend
  45. Ignoring Files w/ .gitignore
  46. Working With Branches
  47. What Really Matters In This Section
  48. Introducing Branches
  49. The Master Branch (Or Is It Main?)
  50. What On Earth Is HEAD?
  51. Viewing All Branches With Git Branch
  52. Creating & Switching Branches
  53. More Practice With Branching
  54. Another Option: Git Checkout Vs. Git Switch
  55. Switching Branches With Unstaged Changes?
  56. Deleting & Renaming Branches
  57. How Git Stores HEAD & Branches
  58. Branching Exercise
  59. Merging Branches, Oh Boy!
  60. What Really Matters In This Section
  61. An Introduction To Merging
  62. Performing A Fast Forward Merge
  63. Visualizing Merges
  64. Generating Merge Commits
  65. Oh No! Merge Conflicts!
  66. Resolving Merge Conflicts
  67. Using VSCode To Resolve Conflicts
  68. Merging Exercise
  69. Comparing Changes With Git Diff
  70. What Really Matters In This Section
  71. Introducing The Git Diff Command
  72. A Guide To Reading Diffs
  73. Viewing Unstaged Changes
  74. Viewing Working Directory Changes
  75. Viewing Staged Changes
  76. Diffing Specific Files
  77. Comparing Changes Across Branches
  78. Comparing Changes Across Commits
  79. Visualizing Diffs With GUIs
  80. Diff Exercise
  81. The Ins and Outs of Stashing
  82. What Really Matters In This Section
  83. Why We Need Git Stash
  84. Stashing Basics: Git Stash Save & Pop
  85. Practicing With Git Stash
  86. Git Stash Apply
  87. Working With Multiple Stashes
  88. Dropping & Clearing The Stash
  89. Stashing Exercise
  90. Undoing Changes & Time Traveling
  91. What Really Matters In This Section
  92. Checking Out Old Commits
  93. Re-Attaching Our Detached HEAD!
  94. Referencing Commits Relative to HEAD
  95. Discarding Changes With Git Checkout
  96. Un-Modifying With Git Restore
  97. Un-Staging Changes With Git Restore
  98. Undoing Commits With Git Reset
  99. Reverting Commits With...Git Revert
  100. Undoing Changes Exercise
  101. Github: The Basics
  102. What Really Matters In This Section
  103. What Does Github Do For Us?
  104. Why You Should Use Github!
  105. Cloning Github Repos With Git Clone
  106. Cloning Non-Github Repos
  107. Github Setup: SSH Config
  108. Creating Our First Github Repo!
  109. A Crash Course on Git Remotes
  110. Introducing Git Push
  111. Touring A Github Repo
  112. Practice With Git Push
  113. A Closer Look At Git Push
  114. What does "git push -u" mean?
  115. Another Github Workflow: Cloning First
  116. Main & Master: Github Default Branches
  117. Github Basics Exercise
  118. Fetching & Pulling
  119. What Really Matters In This Section
  120. Remote Tracking Branches: WTF Are They?
  121. Checking Out Remote Tracking Branches
  122. Working With Remote Branches
  123. Git Fetch: The Basics
  124. Demonstrating Git Fetch
  125. Git Pull: The Basics
  126. Git Pull & Merge Conflicts
  127. A Shorter Syntax For Git Pull?
  128. Github Grab Bag: Odds & Ends
  129. What Really Matters In This Section
  130. Github Repo Visibility: Public Vs. Private
  131. Adding Github Collaborators
  132. Github Collaboration Demo
  133. What are READMEs?
  134. A Markdown Crash Course
  135. Adding a README To A Project
  136. Creating Github Gists
  137. Introducing Github Pages
  138. Github Pages Demo
  139. Git Collaboration Workflows
  140. What Really Matters In This Section
  141. The Pitfalls Of A Centralized Workflow
  142. Centralized Workflow Demonstration
  143. The All-Important Feature Branch Workflow
  144. Feature Branch Workflow Demo
  145. Merging Feature Branches
  146. Introducing Pull Requests
  147. Making Our First Pull Request
  148. Merging Pull Requests With Conflicts
  149. Configuring Branch Protection Rules
  150. Introducing Forking
  151. Forking Demonstration
  152. The Fork & Clone Workflow
  153. Fork & Clone Workflow Demonstration
  154. Rebasing: The Scariest Git Command?
  155. What Really Matters In This Section
  156. Why is Rebasing Scary? Is it?
  157. Comparing Merging & Rebasing
  158. Rebase Demo Pt 1: Setup & Merging
  159. Rebasing Demo Pt 2: Actually Rebasing
  160. The Golden Rule: When NOT to Rebase
  161. Handling Conflicts & Rebasing
  162. Cleaning Up History With Interactive Rebase
  163. What Really Matters In This Section
  164. Introducing Interactive Rebase
  165. Rewording Commits With Interactive Rebase
  166. Fixing Up & Squashing Commits With Interactive Rebase
  167. Dropping Commits With Interactive Rebase
  168. Git Tags: Marking Important Moments In History
  169. What Really Matters In This Section
  170. The Idea Behind Git Tags
  171. A Side Note On Semantic Versioning
  172. Viewing & Searching Tags
  173. Comparing Tags With Git Diff
  174. Creating Lightweight Tags
  175. Creating Annotated Tags
  176. Tagging Previous Commits
  177. Replacing Tags With Force
  178. Deleting Tags
  179. IMPORTANT: Pushing Tags
  180. Git Behind The Scenes - Hashing & Objects
  181. What Really Matters In This Section
  182. Working With The Local Config File
  183. Inside Git: The Refs Directory
  184. Inside Git: The HEAD file
  185. Inside Git: The Objects Directory
  186. A Crash Course On Hashing Functions
  187. Git As A Key-Value Datastore
  188. Hashing With Git Hash-Object
  189. Retrieving Data With Git Cat-File
  190. Deep Dive Into Git Objects: Blobs
  191. Deep Dive Into Git Objects: Trees
  192. Deep Dive Into Git Objects: Commits
  193. The Power of Reflogs - Retrieving "Lost" Work
  194. What Really Matters In This Section
  195. Introducing Reflogs
  196. The Limitations of Reflogs
  197. The Git Reflog Show Command
  198. Passing Reflog References Around
  199. Time-Based Reflog Qualifiers
  200. Rescuing Lost Commits With Reflog
GitHub Actions - The Complete Guide

Learn how to build automated CI / CD workflows with GitHub's DevOps service.

thumbnail
Ratings
4.74
Subscribers
26,880
Subscribers last month
(November 2023)
2,062
Level
beginner
Video Duration
10 hours 17 minutes
Created
Sep 26th, 2022
Last updated
Nov 7th, 2023
Price
$109.99

GitHub Actions is an extremely popular and fast-growing CI / CD automation service offered by GitHub.

This course teaches GitHub Actions from the ground up, without any prior GitHub Actions knowledge assumed or required.

In order to handle growing development and code complexity and deploy application updates with high frequency, powerful automation platforms and tools are required. As you will learn throughout this course, GitHub Actions is such a platform, enabling you to automate anything from code testing, building and deployment all the way up to GitHub repository and project management.

With this course, you'll learn:

  • About all key GitHub Actions building blocks & components

  • How to build and orchestrate both simple and complex workflows

  • How to connect workflows to events & configure event details

  • How to run jobs or job steps conditionally

  • How to manage environment variables

  • How to handle job results, outputs and inputs

  • How to leverage community actions

  • How to build custom actions

  • How to secure workflows and jobs

  • And much more!

This course requires no prior GitHub Actions knowledge. You also don't need to be an advanced developer or Git / GitHub user, though fundamental development and Git knowledge is recommended - though the course does come with a Git & GitHub refresher module.

This course is a practice-oriented courses, exploring all key concepts whilst diving into concrete examples. You'll build different workflows for multiple projects and requirements.

You will also learn how to interact with GitHub APIs and implement third-party (and custom) Actions into your workflows.

  1. Getting Started
  2. Welcome to the Course!
  3. What Is "GitHub Actions"?
  4. Git, GitHub & GitHub Actions
  5. About This Course
  6. Join The Discord Community!
  7. Course Code Attachments & Slides
  8. Git & GitHub Crash Course [Optional]
  9. Module Introduction
  10. Getting Started with Git
  11. Configuring Git
  12. Project Setup
  13. Working with (Local) Git Repositories
  14. Staging Files & Creating Commits
  15. Multiple Commits & Checking Out Snapshots
  16. Reverting Changes with "git revert"
  17. Resetting Code with "git reset"
  18. Staging Multiple Files & Ignoring with gitignore
  19. Understanding Branches
  20. Working with Branches
  21. Merging Branches
  22. GitHub Introduction
  23. Creating a GitHub Account
  24. Creating a (Remote) GitHub Repository
  25. Connecting Local & Remote Repositories
  26. Pushing Commits & Understanding Permissions
  27. GitHub & Branches
  28. Readme Files & Pulling Changes
  29. Cloning Repositories
  30. Making Changes As A Different User (Non-Owner)
  31. GitHub Issues & Collaborators
  32. Working with Pull Requests
  33. Understanding & Using Forks
  34. Module Summary
  35. GitHub Actions - Basic Building Blocks & Components
  36. Module Introduction
  37. Key Components: Workflows, Jobs, Steps & More
  38. GitHub Actions: Availability & Pricing
  39. Creating a First Workflow
  40. Running the First Workflow
  41. Running Multi-Line Shell Commands
  42. Onwards to a More Realistic Example
  43. A New Workflow & The "push" Event
  44. Using Actions In Workflows
  45. Checking Out Code In Workflows
  46. Configuring Actions
  47. Adding More Workflow Job Steps
  48. Failing Workflows & Analyzing Workflows
  49. Adding Multiple Jobs
  50. Jobs: In Parallel vs Sequential
  51. Using Multiple Triggers (Events)
  52. Expressions & Context Objects
  53. Module Summary
  54. Time to Practice: The Problem
  55. Time to Practice: Solution
  56. Workflows & Events - Deep Dive
  57. Module Introduction
  58. Which Events Can You Use?
  59. A Demo Project Setup
  60. More on the "push" Event
  61. Introducing Event Filters & Activity Types
  62. Using Activity Types
  63. Using Event Filters
  64. Special Behavior: Forks & Pull Request Events
  65. Cancelling Workflows & Skipping Workflows
  66. Module Summary
  67. Job Artifacts & Outputs
  68. Module Introduction
  69. Demo Project Setup
  70. Understanding Job Artifacts
  71. Artifacts - An Example
  72. Uploading Job Artifacts
  73. Downloading Artifacts (Manually & Automatically)
  74. Understanding Job Outputs
  75. Job Outputs - An Example
  76. Using Job Outputs In Other Jobs
  77. The Need For Dependency Caching
  78. Caching Dependencies in Practice
  79. Using & Invalidating Caches
  80. Module Summary
  81. Using Environment Variables & Secrets
  82. Module Introduction
  83. Project Setup & Understanding Environment Variables
  84. Providing Environment Variable Values
  85. Demo: Creating a Database & Using Database Environment Variable Values
  86. Using Environment Variables in Code & Workflows
  87. Default Environment Variables
  88. Understanding & Using Secrets
  89. Utilizing Repository Environments
  90. Module Summary
  91. Controlling Workflow & Job Execution
  92. Module Introduction
  93. Understanding Conditional Steps & Jobs
  94. Demo Project Setup
  95. Understanding a (Potential) Problem: A Failing Step
  96. Controlling Execution via "if"
  97. Working with Special Conditional Functions
  98. Conditional Jobs
  99. More "if" Examples
  100. Ignoring Errors & Failures with "continue-on-error"
  101. Understanding & Using Matrix Strategies
  102. Including & Excluding Values (Matrix Strategy)
  103. Saving Time & Code with Reusable Workflows
  104. Adding Inputs to Reusable Workflows
  105. Reusable Workflows & Secrets
  106. Reusable Workflows Outputs
  107. Module Summary
  108. Jobs & Docker Containers
  109. Module Introduction
  110. What Are Containers?
  111. Why Might You Want To Use Containers (With GitHub Actions)?
  112. Demo Project Setup & A Dockerfile
  113. Run Jobs In Containers
  114. Service Containers - Theory
  115. Adding Services (via Service Containers)
  116. Communication between Jobs & Service Containers
  117. Module Summary
  118. Building & Using Custom Actions
  119. Module Introduction
  120. Why Custom Actions?
  121. Understanding Different Types of Custom Actions
  122. Demo Project Setup
  123. Creating Composite Actions
  124. Using Custom Actions In Workflows
  125. Adding Inputs to Custom Actions
  126. Adding Outputs to Custom Actions
  127. Custom JavaScript Actions - Getting Started
  128. Configuring JavaScript Actions
  129. Adding Basic JavaScript Logic
  130. Creating a S3 Bucket (for a more advanced, custom Action)
  131. Adding Action Inputs
  132. Interacting with GitHub Actions Features
  133. Custom JavaScript Action: Real Deployment to AWS S3
  134. JavaScript Actions & Outputs
  135. Getting Started with a Custom Docker Action
  136. Creating a Custom Docker Action
  137. Storing Actions In Repositories & Sharing Actions With Others
  138. Module Summary
  139. Security & Permissions
  140. Module Introduction
  141. Key Security Concerns
  142. Understanding Script Injection Attacks
  143. Increasing Actions Safety
  144. Understanding Permissions & Potential Issues
  145. GITHUB_TOKEN & Managing Permissions
  146. More Security Settings
  147. Working with Third-Party Permissions & OpenID Connect
  148. Example: AWS Permissions
  149. Example: AWS Permissions (Continued)
  150. More On GitHub Actions Security
  151. Wrap Up
  152. Congratulations & Wrap Up
  153. Bonus Lecture
Git for Beginners

Learn everything you need to use Git and GitHub to track and store the changes of your source code.

thumbnail
Ratings
4.53
Subscribers
27,194
Subscribers last month
(November 2023)
3,004
Level
beginner
Video Duration
2 hours 19 minutes
Created
Sep 12th, 2022
Last updated
Dec 15th, 2022
Price
$79.99

Git is one of the most popular version control systems. This course will teach you how to work with Git to track and store the changes of your source code.

First, you will learn the bascis about Git. You will learn what version control systems are and how local, centralized, and distributed version control systems work.

After this, you will learn how to set up Git on your machine. You'll learn how to configure Git, so that your name and email are stored with every commit.

Next, you will learn how to work with local repositories. You will use the commandline to create a repository on your machine and I will show you how to stage and commit changes.

After this, you will learn how to branch and merge your code to work on specific features of your project. You will also learn how to handle merge conflicts that can happen when multiple developers are working on the same code base.

Finally, you will learn how to push your code to a remote repository on GitHub, how to clone an existing repository from GitHub, and how to use pull requests to collaborate with other developers.


After this course, you will have the skills and knowledge needed to use Git successfully in your projects.

  1. Introduction
  2. Introduction
  3. What to Expect From This Course
  4. Understanding the Git Basics
  5. Introduction
  6. What is a Version Control System?
  7. Know the Different Types of Version Control Systems
  8. Understand the Origin of Git
  9. Summary
  10. Learning Questions
  11. Setting up Git on Your Machine
  12. Introduction
  13. Install Git on Your Machine
  14. Configure Username and Email
  15. Summary
  16. Cheat Sheet - Git Commands Used in This Section
  17. Learning Questions
  18. Working with Local Repositories
  19. Introduction
  20. Create a Local Repository
  21. Understand the Three Main Areas
  22. Create Your First Commit
  23. Create Another Commit
  24. Know What Snapshots Are
  25. Look at the History of Your Code
  26. Ignore Files in the Working Directory
  27. Summary
  28. Cheat Sheet - Git Commands Used in This Section
  29. Learning Questions
  30. Branching and Merging Code
  31. Introduction
  32. Create a Branch
  33. Merge a Branch
  34. Handle Merge Conflicts
  35. Summary
  36. Cheat Sheet - Git Commands Used in This Section
  37. Learning Questions
  38. Pushing to a Remote Repository
  39. Introduction
  40. Create a Repository on GitHub
  41. Push Your Code to the Remote Repository
  42. Clone the Repository
  43. Pull Changes from the Remote Repository
  44. Understand the Pull Command
  45. Summary
  46. Cheat Sheet - Git Commands Used in This Section
  47. Learning Questions
  48. Creating and Merging Pull Requests
  49. Introduction
  50. What Is a Pull Request?
  51. Create and Merge a Pull Request
  52. Forking a Repository on GitHub
  53. Merge the Pull Request From Julia
  54. Summary
  55. What's Next?
  56. Learning Questions
Master Git and GitHub in 5 Days: Go from Zero to Hero

Learn to master git and GitHub in just one week! Learn how to use commits, branches, pull requests, and more!

thumbnail
Ratings
4.66
Subscribers
10,399
Subscribers last month
(November 2023)
733
Level
all
Video Duration
5 hours 44 minutes
Created
Sep 7th, 2022
Last updated
Oct 10th, 2022
Price
$94.99

Understanding how to use Git and GitHub is now a basic requirement for any developer, but so many courses take forever to teach you anything of value! Unlike those other courses, we've specifically designed this course to teach you the 10% of Git commands that you use 90% of the time! When you're just starting off with git you don't want to waste time learning about commands you hardly ever use, especially when you could always easily look them up later. Instead this course focuses on giving you a Bootcamp style approach to turn you into a PRO in just ONE WEEK!

Why learn Git and GitHub?

Git and GitHub allow you to easily keep different versions of a large codebase organized. When working almost any job as a developer, understanding git and GitHub is an essential skill. It's also one of the very first things you need to know to hit the ground running at a new position, which is why this course is specifically designed to get you from zero to hero in just 5 days! We've designed the course in a 5 day format so you can get up and running in just one work week.

Why choose this course?

Many other courses waste time covering the same topics over and over again in a dull and repetitive format, instead of focusing on what you need to know in the real world! We've designed this course for someone who just started  a new developer role and needs to get up to speed on git and GitHub in their first week, which is why the sections are organized in a 5 day format. With just approximately one hour a day you can go from Zero to Hero with git and GitHub!

What's covered in this course?

We cover a wide variety of the most important topics in git and GitHub, including:

  • Understanding Version Control

  • Git and GitHub Setup

  • Code Repository Basics

  • Snapshots and Applications

  • Basic git commands

  • Working with Branches

  • Merges and Changes

  • Cloning Repos

  • Understanding git stash

  • Checking for differences between commits

  • Using git as an organization

Throughout the course you'll be provided with example code, diagrams, and slides so you have easy to understand references you can come back to whenever you need.

Enroll today and we'll see you inside the course!

  1. Day 0 - Course Overview
  2. Welcome to the Course!
  3. Course Overview
  4. Version Control Overview
  5. OPTIONAL: Command Line Basics - Windows Command Prompt
  6. OPTIONAL: Command Line Basics - MacOS or Linux
  7. Day 1 - Introduction to Version Control, Git and Github
  8. Welcome to Day 1!
  9. Git and GitHub
  10. Installing Git
  11. GitHub Account
  12. Configure Git
  13. Creating and Cloning Repositories
  14. Private Repositories
  15. Day 1 Summary and Exercise
  16. Day 2 - Starting to Use git
  17. Welcome to Day 2
  18. Understanding Git Usage and Workflow
  19. Add and Commit
  20. Git Log
  21. Git Remote and Git Push
  22. Fetch and Pull
  23. Day 2 Summary and Exercise
  24. Day 3 - Working with Others
  25. Introduction to Day 3 - Working with Others
  26. Understanding Branches
  27. Understanding HEAD
  28. Git Branch Commands
  29. Delete and Rename Branches
  30. Merging Branches - Theory and Concepts
  31. Merging Branches in Practice
  32. Git Diff
  33. Working with Others - Exercise and Solution
  34. Day 4 - Going back and Undoing Changes
  35. Introduction to Undoing Changes
  36. Git Checkout and Detached HEAD
  37. Git Restore
  38. Git Reset
  39. Git Revert
  40. Undoing Changes - Exercise and Solution
  41. Day 5 - Git and GitHub in Practice
  42. Introduction to Day 5 - Git and GitHub in Practice
  43. Using Git Stash
  44. Push and Pull with Git Remote
  45. Common Workflow Patterns
  46. GitHub Repository Tour
  47. GitHub Pull Requests
  48. Forking on GitHub
  49. GitHub Actions
  50. Day 5 Exercise and Solution
Git & GitHub - The Practical Guide

Learn Git & GitHub and master working with commits, branches, the stash, cherry picking, rebasing, pull requests & more!

thumbnail
Ratings
4.66
Subscribers
33,697
Subscribers last month
(November 2023)
742
Level
all
Video Duration
10 hours 22 minutes
Created
Jul 16th, 2021
Last updated
Nov 7th, 2023
Price
$99.99

No matter if you're just getting started with (web) development, if you're applying for a developer job or if you just need to refresh your knowledge - version control is a core skill you need to succeed as a developer!

Git (a version control system) and Github (a cloud provider for Git managed projects) form an outstanding combination to provide the best possible experience to create and maintain a clearly structured project history!

This course guides everyone (no prior knowledge is required!) through the core steps to use these tools in your daily projects with ease.

What is Version Control?

Saving & accessing data and tracking changes is what version control is all about. No matter if you're working on a private or a professional development project, code evolves, changes and continuously gets improved. A clean version management structure is therefore key to successfully manage the progress of your projects.

What is Git?

Git is a 100% free version management tool, specifically created for and used by developers all over the world to manage project code history locally on their machines (Windows, macOS, Linux/Unix).

What is GitHub?

GitHub is an online service, it is also free for many use cases (an account is all you need) and brings Git's local "file-tracking" strengths to the cloud. Storing project code online, updating code, accessing other team members' code or collaborating on large scale projects inside your organization - all possible with the help of GitHub!

Why Should I Know these Tools?

Version control is key to manage projects efficiently so not knowing Git and GitHub makes your daily developer life a lot more complicated. The same apply if you're currently looking for a new job in the industry, version control is required in any developer projects these days, so not knowing Git & GitHub puts you behind your competition!

Although Git and GitHub are user friendly, both come with their own logic and "language". Getting started can therefore be a bit cumbersome and this is where this course comes into play!

What do I Learn in this Course?

This course starts at the very basics, no prior Git or GitHub knowledge is required! You'll learn how to use Git and how to write Git commands in the Mac Terminal or the Windows Command Prompt (optional refreshers on both are also part of the course).

Starting with the first initialization of a so-called Git repository, we'll build up your knowledge step-by-step and understand the what & why behind concepts like branches, commits, the staging area, merging & rebasing, cloning, pushing & pulling branches and a lot more!

What's Inside this Course?

  • An optional Command Line Crash Course for both Windows & MacOS users

  • Git Download & Installation

  • Git Theory - Working Directory, Staging Area (Index) and Repository explained

  • Creating Git Repositories

  • Working with Commits

  • Understanding Branches

  • Understanding the HEAD and the detached HEAD

  • Newly Introduced Git Commands with Git Version 2.23

  • Deleting Data (Staged & Unstaged, Commits & Branches)

  • Ignoring Files

  • The Stash

  • Merging, Rebasing and Cherry Picking

  • Bringing Back Deleted Data with the Reflog

  • Connecting Local Git Repositories to Remote GitHub Repositories

  • Git Push & Pull (+ Fetch)

  • Local, Remote Tracking & Remote Branches

  • GitHub Collaborators & Contributors

  • Forks & Pull Requests

  • GitHub Issues

  • Github Projects

  • and so much more!

All covered, explained and applied in easy to understand examples in the course!

-

In this course we'll find answers to questions like:

"How can I delete my last commit?"

"What is the Stash?"

"What is the difference between a merge and a rebase (and what is cherry-picking actually)?"

"How to bring back a deleted commit?"

"What is the difference between a local tracking branch and a remote tracking branch?"

-

What are you waiting for, jump and board and let's GIT started :)

  1. Introduction
  2. Welcome to this Course!
  3. What is Git?
  4. What is GitHub?
  5. Join Our Learning Community!
  6. Course Content
  7. How to Get the Most out of this Course!
  8. Course Slides
  9. Optional: Mac Terminal & Windows Command Prompt Introduction
  10. Module Introduction
  11. The Command Line - What & Why?
  12. Comparing the Mac & Windows Command Line
  13. Please Read! Windows & Mac Users
  14. Mac Terminal - The Basics
  15. Accessing Folders
  16. Absolute vs Relative Paths
  17. Creating & Deleting Files
  18. Introducing Flags and Removing Data
  19. Copying & Moving Files & Folders
  20. Mac Terminal - Core Commands Overview
  21. Windows Command Prompt - The Basics
  22. Absolute vs Relative Paths
  23. Creating & Deleting Files & Folders
  24. Copying & Moving Files
  25. Windows Command Prompt - Core Commands Overview
  26. Useful Resources & Links
  27. Version Management with Git - The Basics
  28. Module Introduction
  29. Theory - How Git Works
  30. Theory: Working Directory vs Repository
  31. Theory - Understanding Branches
  32. Please Read! Windows & Mac Users
  33. Installing Git on Windows
  34. Installing Git on MacOS
  35. Installing Visual Studio Code
  36. Initializing the Repository & Creating the First Commit ("git init" & "git commi
  37. Please Read: Exiting the Log
  38. Diving Deeper Into Commits with "git log"
  39. Understanding & Creating Branches
  40. Merging Branches - The Basics
  41. Understanding the HEAD
  42. The "detached HEAD"
  43. Branches & "git switch" (Git 2.23)
  44. Deleting Data - An Overview
  45. Deleting Working Directory Files
  46. Undoing Unstaged Changes
  47. Undoing Staged Changes
  48. Deleting Commits with "git reset"
  49. Deleting Branches
  50. Committing "detached HEAD" Changes
  51. Understanding .gitignore
  52. Wrap Up & Basic Commands Overview
  53. Assignment - Practicing the Git Basics
  54. Useful Resources & Links
  55. Diving Deeper Into Git
  56. Module Introduction
  57. Understanding the Stash ("git stash")
  58. Bringing Lost Data Back with "git reflog"
  59. Combining Branches - What & Why?
  60. Understanding Merge Types
  61. Applying the Fast-Forward Merge
  62. The Recursive Merge (Non-Fast-Forward)
  63. Rebasing - Theory
  64. Applying "git rebase"
  65. Handling Merge Conflicts
  66. Merge vs Rebase vs Cherry Pick
  67. Undestanding "git cherry-pick"
  68. Working with Tags ("git tag")
  69. Wrap Up
  70. Useful Resources & Links
  71. From Local to Remote - Understanding GitHub
  72. Module Introduction
  73. What is GitHub?
  74. From Local to Remote Repository - Theory
  75. Creating a GitHub Account & Introducing GitHub
  76. Creating a Remote Repository
  77. Connecting Local & Remote Repositories
  78. Understanding the Personal Access Token
  79. MacOS Users Only: Please Read
  80. Pushing a Second Commit
  81. From Local to Remote - Understanding the Workflow
  82. Remote Tracking Branches in Practice
  83. Understanding Local Tracking Branches
  84. Creating Local Tracking Branches
  85. Remote & Tracking Branches - Command Overview
  86. Cloning a Remote Repository
  87. Understanding the Upstream
  88. Deleting Remote Branches & Public Commits
  89. Wrap Up
  90. Useful Resources & Links
  91. GitHub Deep Dive - Collaboration & Contribution
  92. Module Introduction
  93. The 4 GitHub Usecases
  94. Understanding GitHub Account Types
  95. Changing the Repository Type from Public to Private
  96. Pushing Commits to a Public Repository
  97. How GitHub Manages Account Security
  98. Understanding & Adding a Collaborator to a Private User Account
  99. Collaborating in Private Repositories
  100. Comparing Owner & Collaborator Rights
  101. Limiting Interactions
  102. Introducing Organizations
  103. Creating an Organization
  104. Exploring Member Repository Permissions
  105. Adding Outside Collaborators
  106. Adding Organization Members
  107. Failing to Manage Access for Individual Repositories
  108. Introducing Teams
  109. Managing Team Repository Access Efficiently
  110. Understanding Forks & Pull Requests
  111. Forking a Repository
  112. Pull Requests in Practice
  113. Opening & Closing Issues
  114. Working with GitHub Projects
  115. Creating a README File in a Repository
  116. Presenting Yourself as Developer on GitHub
  117. About GitHub Stars
  118. Wrap Up
  119. Useful Resources & Links
  120. Real Project Example: Git & GitHub Applied
  121. Module Introduction
  122. Preparing the Project
  123. Project Setup
  124. Creating our First Commit Locally
  125. Changing the ReactJS Project Code
  126. Pushing the Code to the Owner's Remote Repository
  127. Cloning the Project & Changing the Code
  128. Pushing the Commit & Why it Fails
  129. Adding a Collaborator
  130. Creating the Personal Access Token & Pushing Successfully
  131. Merging the Owner Branches
  132. Fixing Merge Conflicts
  133. Accessing Code via Forks
  134. Contributing to the Project by Improving the Code
  135. Creating the Pull Request
  136. Accepting the Pull Request
  137. Useful Resources & Links
  138. Course Roundup
  139. Course Roundup

3. Top 3 Recommended YouTube Videos

Here are Outlecture's top 3 recommended YouTube videos, carefully selected for you.

Title View count View count last month
(November 2023)
Like count Publish date

Complete Git and GitHub Tutorial for Beginners

thumbnail

Channel: Apna College

906,072 162,490 25,830 Aug 24th, 2023

The BEST way to learn Git👩‍💻 #technology #programming #software #career #code #tech #learncode

thumbnail

Channel: Coding with Lewis

585,059 - 47,244 Aug 23rd, 2022

Git and GitHub Tutorial for Beginners

thumbnail

Channel: Kevin Stratvert

791,631 63,895 18,142 Jun 24th, 2022

YouTube has become a familiar platform for everyday use, where viewers can watch videos for free, although they may contain advertisements. Recently, there has been an increase in the availability of high-quality educational materials on this platform. It is an excellent option for those who want to learn without paying or simply obtaining a quick understanding of a topic.
We highly recommend utilizing YouTube as a valuable learning resource.

Recommended for

  • Wanting to learn without spending money
  • Wanting to quickly understand the overview of Git

The details of each course are as follows:

Complete Git and GitHub Tutorial for Beginners

Apna College

View count
906,072
View count last month
(November 2023)
162,490
Like count
25,830
Publish date
Aug 24th, 2023
Link for GitHub Notes : https://www.apnacollege.in/notes

You can Learn Website Development in 4.5 Months with us.
🔥Delta 3.0(Full Stack Web Development) : https://www.apnacollege.in/course/delta-batch-3

Early bird offer for first 5000 students only!

International Student (payment link) - https://buy.stripe.com/7sI00cdru0tg10saEQ
---------------------------------------------------

📌 Details about the Delta 3.0 Batch :
- Start Date : 7th November, 2023
- Alternate day lectures (at 8PM)
- Duration - 4.5 months
- Each Class duration : 1.5 hour-2hour (alternate days)
- Access to the course is for 2 years
- Complete Frontend Development with HTML, CSS, Javascript & ReactJs
- Complete Backend Development (NodeJs, ExpressJs)
- Complete Database -( SQL & MongoDB)
- Complete MERN Stack (MongoDB, Express, React, Node)
- Real Life and Industry Grade Projects
- Live Mentorship Sessions
- 500+Topic Videos
- Certificate will be given on Completion.
The BEST way to learn Git👩‍💻 #technology #programming #software #career #code #tech #learncode

Coding with Lewis

View count
585,059
View count last month
(November 2023)
-
Like count
47,244
Publish date
Aug 23rd, 2022
Git and GitHub Tutorial for Beginners

Kevin Stratvert

View count
791,631
View count last month
(November 2023)
63,895
Like count
18,142
Publish date
Jun 24th, 2022
In this step-by-step tutorial, learn how to use Git and GitHub for source control management (SCM). We start with Git. What is it? How you can get it running on your system, and how you can start working with it? Then we look at GitHub.com, a platform for hosting and collaborating on Git repositories. By the end of this video, you'll be well on your way to using Git and GitHub. If you'd like to follow along, I've included sample files down below.

📚 RESOURCES
- Sample files to follow along: https://1drv.ms/u/s!AmxrofZZlZ-whOIll3D3rv-iWMxqYw?e=JsqfMu
- Official Git web site: https://www.git-scm.com/
- Official GitHub.com web site: https://github.com/
- Git and GitHub.com cheat sheet: https://education.github.com/git-cheat-sheet-education.pdf
- Git Reference Manual: http://git-scm.com/docs
- Git Overview Book: http://git-scm.com/book/en/v2
- Sample ignore files: https://github.com/github/gitignore
- Hyper.is Terminal: https://hyper.is/

⌚ TIMESTAMPS
00:00 Introduction
00:40 What is Git?
02:11 Get Git
03:13 Configure Git
04:55 Get help
05:59 Initialize repository
07:19 Git status
07:53 Track and untrack files
09:18 Ignore files with .gitignore
11:23 Track all files / add to staging
12:07 Commit
13:27 Change files and view differences
16:00 Bypass staging and commit
16:32 Delete / remove files
17:13 Restore files
17:55 Rename files
18:56 View commit history with git log
19:52 Amend commit
20:48 View changes in commits
22:08 Reset to previous commit
22:30 Rebase git repository
23:12 Branches
27:19 Merge branches
27:57 Delete branch
28:30 Merge conflicts
32:16 Typical Git flow
32:37 Set up GitHub account
33:37 Create new cloud repository
35:09 Push local repo to GitHub
37:29 Working with files
38:25 Edit repo details
38:44 Issues
40:17 Pull requests
43:05 Actions, Projects, Wiki, Security, Insights, Settings
44:18 Releases
45:00 Fetch and pull
45:37 Wrap up

🖥️ GIT COMMANDS CHEAT SHEET
Set configuration values for your username and email
git config --global user.name YOUR NAME
git config --global user.email YOUR EMAIL

Set default branch to main
git config --global init.default branch main

Get help on a command
git help COMMAND
git COMMAND -h

Initialize a new git repository
git init

Clone a repository
git clone REPOSITORY URL

Add a file to the staging area
git add FILE

Add all file changes to the staging area
git add --all
git add -A
git add .

Check the unstaged changes
git diff

Commit the staged changes
git commit -m "MESSAGE"

Reset staging area to the last commit
git reset

Check the state of the working directory and the staging area
git status

Remove a file from the index and working directory
git rm FILENAME

Rename a file
git mv (OLD NAME) (NEW NAME)

List the commit history
git log

List all the local branches
git branch

Create a new branch
git branch BRANCH NAME

Rename the current branch
git branch -m NEW BRANCH NAME

Delete a branch
git branch -d BRANCH NAME

Switch to another branch
git switch BRANCH NAME

Merge specified branch into the current branch
git merge BRANCH NAME

Create a connection to a remote repository
git remote add (NAME) (REPOSITORY URL)

Push the committed changes to a remote directory
git push (REMOTE) (BRANCH)

Download the content from a remote repository
git pull REMOTE

📺 RELATED VIDEOS
- Playlist with all my videos on Git and GitHub: https://youtube.com/playlist?list=PLlKpQrBME6xL-CUCBBsk7j61kznnXqhIv
- Python for Beginners Tutorial: https://youtu.be/b093aqAZiPU
- SQL for Beginners Tutorial: https://youtu.be/h0nxCDiD-zg

🙌 SUPPORT THE CHANNEL
- Hit the THANKS button in any video!
- Amazon affiliate link: https://amzn.to/3kCP2yz (Purchasing through this link gives me a small commission to support videos on this channel -- the price to you is the same)

🔽 CONNECT WITH ME
- Official web site: http://www.kevinstratvert.com
- LinkedIn: https://www.linkedin.com/in/kevinstratvert/
- Discord: https://bit.ly/KevinStratvertDiscord
- Twitter: https://twitter.com/kevstrat
- Facebook: https://www.facebook.com/Kevin-Stratvert-101912218227818
- TikTok: https://www.tiktok.com/@kevinstratvert
- Instagram: https://www.instagram.com/kevinstratvert/

🎒 MY COURSES
- Excel for Beginners in under 2 hours: https://kevinstratvert.thinkific.com/

🙏 REQUEST VIDEOS
https://forms.gle/BDrTNUoxheEoMLGt5

🔔 SUBSCRIBE ON YOUTUBE
https://www.youtube.com/user/kevlers?sub_confirmation=1

#stratvert

4. Progate

You can learn Git on Progate.

Progate is a programming learning service that is available in over 100 countries and has been used by more than 2.8 million people. Its features include:

  • You can write code on Progate's service, so there is no need for a local development environment setup
  • Intuitive understanding through illustration-centered explanations
  • A low cost of $9.99 per month
  • You can take courses other than React without additional fees

For those who are struggling with setting up a local development environment (especially IT beginners), these features can be a big advantage.
Additionally, this subscription payment model also provides cost-effectiveness for those who want to take courses other than React.

Recommended for

  • Lacking basic IT knowledge
  • Wanting to take courses other than Git
Progate's Git Learning Course

5. Wrap-up

We introduced recommended courses for Git. If you are interested in learning other related courses, please refer to the following.

Docker
IntelliJ
Ruby
Docker
IntelliJ
Ruby

If you want to further explore and learn after taking one of the courses we introduced today, we recommend visiting the official website or community site.

If you want to stay up-to-date on the latest information, we suggest following the official Twitter account.

Furthermore, We highly recommend utilizing General AI such as ChatGPT as a study aid. This can enable more effective learning, so please give it a try.

We hope you found our website and article helpful. Thank you for visiting.

Back to list
Home About Share
Home
About
Privacy policy
Disclaimer
Contact
Official
© 2023 outlecture.com All Rights Reserved.