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

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

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

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