Git & GitHub - The Practical Guide

Learn how to manage your projects with Git & GitHub - No previous knowledge is required, everything explained for everyone in easy to understand examples!

  1. Courses
  2. Git & GitHub - The Practical Guide

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 will guide everyone (no prior knowledge is required!) through the core steps required 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 (just an account must be created) and it brings Git's local "file-tracking" strengths to the cloud. Storing project code online, accessing other team members' code or even updating code - all possible with the help of GitHub!

Why Should I Know these Tools?

Every project needs proper version control so not knowing Git and GitHub makes your daily developer life a lot more complicated (same if you're currently looking for a new job in the industry). Although Git and GitHub are user-friendly, both come with their own logic and "language". Getting started therefore can 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 (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?

  • 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
  • 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 then)?"

"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 :)

Section: Getting Started

1. Welcome to this Course! (0:55) Preview
2. Git & GitHub - What & Why? (4:58) Preview
3. Course Content (2:38) Preview

Section: Optional: Mac Terminal & Windows Command Prompt Introduction

4. Module Introduction (0:39)
5. The Command Line - What & Why? (3:43)
6. Comparing the Mac & Windows Command Line (4:23)
7. Mac Terminal - The Basics (6:37)
8. Accessing Folders (3:39)
9. Absolute vs Relative Paths (3:10)
10. Creating & Deleting Files (6:27)
11. Introducing Flags and Removing Data (5:00)
12. Copying & Moving Files & Folders (8:55)
13. Mac Terminal - Core Commands Overview (2:44)
14. Windows Command Prompt - The Basics (4:35)
15. Absolute vs Relative Paths (4:31)
16. Creating & Deleting Files & Folders (3:06)
17. Copying & Moving Files (3:13)
18. Windows Command Prompt - Core Commands Overview (1:55)
19. Useful Resources & Links (1:00)
20. Course Slides (1:00)

Section: Version Management with Git - The Basics

21. Module Introduction (0:41) Preview
22. Theory - How Git Works (5:30) Preview
23. Theory - Understanding Branches (2:25)
24. Please Read! Windows & Mac Users (1:00)
25. Installing Git & Visual Studio Code (7:40)
26. Initializing the Repository & Creating the First Commit ("git init" & "git commit") (8:21)
27. Diving Deeper Into Commits with "git log" (4:14)
28. Understanding & Creating Branches (6:58)
29. Merging Branches - The Basics (1:51)
30. Understanding the HEAD (3:09)
31. The "detached HEAD" (3:52)
32. Branches & "git switch" (Git 2.23) (2:41)
33. Deleting Data - An Overview (1:06)
34. Deleting Working Directory Files (3:30)
35. Undoing Unstaged Changes (5:28)
36. Undoing Stages Changes (5:31)
37. Deleting Commits with "git reset" (6:17)
38. Deleting Branches (1:51)
39. Committing "detached HEAD" Changes (8:37)
40. Understanding .gitignore (5:32)
41. Wrap Up & Basic Commands Overview (5:50)
42. Mac Users Only: Git - MacOS Installation (3:44)
43. Useful Resources & Links (1:00)

Section: Diving Deeper Into Git

44. Module Introduction (0:45)
45. Understanding the Stash ("git stash") (8:58)
46. Bringing Lost Data Back with "git reflog" (5:44)
47. Combining Branches - What & Why? (1:49)
48. Understanding Merge Types (2:22)
49. Applying the Fast-Forward Merge (9:12)
50. The Recursive Merge (Non-Fast-Forward) (7:20)
51. Rebasing - Theory (3:20)
52. Applying "git rebase" (6:49)
53. Dealing with Merge Conflicts (6:48)
54. Merge vs Rebase vs Cherry Pick (2:01)
55. Undestanding "git cherry-pick" (5:39)
56. Working with Tags ("git tag") (6:29)
57. Wrap Up (2:37)
58. Useful Resources & Links (1:00)

Section: From Local to Remote - Understanding GitHub

59. Module Introduction (0:33)
60. Connecting Git & Github - Local vs Remote Repository (5:10)
61. Pushing Local Changes to an Empty Remote Repository (8:41)
62. From Local to Remote - Understanding the Workflow (4:41)
63. Remote Tracking Branches in Practice (8:33)
64. Understanding Local Tracking Branches (4:04)
65. Creating Local Tracking Branches (8:25)
66. Remote & Tracking Branches - Command Overview (2:30)
67. Cloning a Remote Repository (9:08)
68. Understanding the Upstream (2:33)
69. Deleting Remote Branches & Public Commits (6:03)
70. Wrap Up (1:52)
71. Useful Resources & Links (1:00)

Section: Congratulations!

72. Course Roundup (2:59)

Course Instructor


Manuel Lorenz

Having worked as a business analyst in both a major consultancy and an investment bank, I always found myself confronted with both various and complex problem sets and challenging client demands. The rapid development of technology and business requirements forces everyone to constantly adapt and to continue learning. Since I always found it hard to find high quality, understandable and comprehensive learning materials, I decided to create such materials on my own. Together with Maximilian Schwarzmüller I founded Academind to offer the best possible learning experience on web development and data science to our more than 1,000,000 students worldwide.