Top 9 Recommended Git Self-Study Materials! [November 2024]

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

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

This course is neither endorsed by, nor in partnership, nor affiliated with GitLab, Inc.

This course will teach you how to use Gitlab CI for your own projects. You will learn the basics of CI/CD and start building pipelines right from the first lecture.

Some highlights:

- have an overview of the Gitlab architecture

- create a simple pipeline

- learn the CI/CD practice by deploying a simple website

- use Docker images within Gitlab

- learn how to deploy a Java application to AWS, using AWS S3 and AWS Elastic Beanstalk.

This course will NOT make you a GitLab CI / DevOps expert

A lot of courses promise you will become an expert in no time. Becoming an expert in any tool comes with time and hard work. It simply does not make sense to promise something like that. It will not be honest.

This is a course designed for beginners. Learning to build pipelines is a try-and-error process that can be very frustrating. You need to understand the tools you use and how GitLab can support your needs. In the end, GitLab is just a tool.

What I will try is to explain to you the basics and offer you enough practice opportunities so that you can apply what you learn easily in your own projects as well. I will show you how to build pipelines with Gitlab CI.

1. Introduction
2. Course notes & important resources
3. What is GitLab CI/CD?
4. GitLab.com account registration
5. Verifying your GitLab account
6. Your first pipeline
7. My GitLab CI pipeline is not running
8. Configuring Git for Gitlab CI
9. Gitlab architecture
10. Quiz #1
11. Why GitLab CI?
12. How much does Gitlab cost?
13. About the course
14. Important skills you need to acquire
15. Basic CI/CD workflow with Gitlab CI
16. Overview
17. What is CI / CD?
18. Alternative if you don't want to install new software
19. Short introduction to Node.js
20. Creating a new project
21. Troubleshooting
22. Building the project locally
23. Short introduction to images and Docker
24. Building the project using Gitlab CI
25. Adding a test stage
26. Running jobs in parallel
27. Running jobs in the background
28. Debugging the error curl: (7) Failed to connect to localhost port 9000: Connect
29. Deployment using surge.sh
30. Using Environment variables for managing secrets
31. Deploying the project using Gitlab CI
32. How does Surge.sh know the environment variables?
33. Quiz #2
34. Post-deployment tests
35. Gitlab CI Fundamentals
36. Overview
37. Predefined environment variables
38. Pipeline triggers / Retrying failed jobs / Pipeline schedules
39. Using caches to optimize the build speed
40. Assignment: Improving build speed by using caches
41. Cache vs Artifacts
42. Deployment Environments
43. Defining variables
44. Manual deployments / Manually triggering jobs
45. Merge requests - Using branches
46. Merge requests - What is a Merge Request?
47. Merge requests - Configuring Gitlab
48. Merge requests - Your first merge request
49. Working with Merge Requests
50. Dynamic environments
51. Troubleshooting environment variables not being available
52. Destroying environments (Clean-up after the Merge Request)
53. before_script & after_script configuration
54. Recap & conclusion
55. YAML basics
56. Overview
57. Understanding YAML
58. Disabling jobs
59. Anchors
60. Creating job templates
61. Using Gitlab CI to build and deploy a Java application to AWS Elastic Beanstalk
62. Overview
63. Introduction to the Java application
64. Calling an API with Postman
65. Continuous Integration (CI) pipeline overview
66. Build stage: Building a Java application locally
67. Build stage: Building a Java application with Gitlab CI
68. Test stage: Adding a smoke test
69. CI/CD pipeline recap
70. Brief introduction to Amazon Web Services (AWS)
71. Notice about unexpected costs while using AWS
72. Serverless computing with AWS Elastic Beanstalk
73. How to deploy to AWS (manual upload)
74. How to deploy to AWS from GitLab CI
75. Getting started with AWS S3
76. GitLab Group settings
77. How to upload a file to AWS S3 from GitLab CI
78. How to deploy a Java application to AWS Elastic Beanstalk using the AWS CLI
79. Assignment
80. Assignment solution
81. Create an application version
82. Verify the application version after deployment
83. Revisiting the CI pipeline
84. Ensuring coding standards with tools for codestyle checking with PMD
85. Assignment - Add code quality stage with PMD
86. Assignment solution - Add code quality stage with PMD
87. Quick introduction to unit testing in CI pipelines
88. Unit test stage: Run JUnit tests with GitLab CI
89. How to structure a CI/CD pipeline in GitLab CI?
90. API test stage: Run Postman API tests in GitLab CI
91. GitLab Pages (for publishing HTML reports or dashboards)
92. Final reminder to terminate all AWS services
93. Specific topics / User topics
94. Ask the instructor
95. Conclusion
96. Not the end
97. Bonus lecture

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