Complete Git and GitHub guide. Master basic and advanced Git features: commits, branches, merging, rebasing, squashing.
Complete Git Guide: Understand and master Git and GitHub
19h 21m 2s
English
Paid
This course is all about Git and GitHub.
Understand HOW Git works and learn all Git features from basic commits to squashing and rebasing.
Blobs, Trees, Annotated tags, SHA1 hashes
If those terms are new to you - jump in and you will learn all about Git internals and afterwards practice basic and advanced Git features using multiple practice activities.
Become a master of Git, GitHub, GitHub Desktop, SourceTree and Visual Studio Code.
This is the most complete practical Git and GitHub guide here on Udemy that includes tons of practical activities. Most important is that you will learn how Git works and knowing it you will be able much more easier use Git features and fix mistakes in your development workflow. You can have zero knowledge about Git and GitHub. All will be taught from scratch, from basic to advanced features. If you want to get deep knowledge of Git and GitHub this course is for you!
We will start by exploring internal structure of the Git repository. You will learn that Git has 4 types of objects: blobs, trees, commits and annotated tags. Each object has unique SHA1 hash. Also all objects are stored in the folders. Every object has just single reference to it - SHA1 hash. Files are stored in blobs. Filenames are stored in other Git objects called trees.
I will explain you how to create new Git objects without using git commit and git add. After creating Git object in the Git repository you will checkout it to staging area and working directory (opposite direction to traditional Git flow)
Afterwards we will jump into tons of practice activities and use different Git and GitHub features
In practice sections you will perform multiple practice Git activities:
Initialize new Git repository
Make changes, add them to staging area and commit
Create branches, checkout branches and merge branches
Perform fast-forward and 3-way merges of the branches
Resolve merge conflicts
Move into detached HEAD state and make experimental commits there
Perform rebasing of the branches
You will also learn and practice different GitHub features
Connect local and remote repositories
Pushing, fetching and pulling operations
Open Pull Request
Merge Pull Request
Add software versions using Git Tags
Create forks from other repositories
Contribute to public repositories using technique of forks and pull requests
Perform rebasing with squashing
You will use not just terminal and shell commands for performing Git operations. In parallel you will also use GUI applications that simplify routine day-by-day Git operations:
GitHub Desktop
SourceTree
VisualStudio Code
Requirements:
- We will start from the very beginning, from basic Git features and move on to advanced techniques and operations
- Prepare only your Mac, Windows or Linux/Unix computer. Anything will work.
- If you are new to Git, please start from the very beginning: learn how Git works and how to perform basic operations (git add, git commit, git branch)
- If you are advanced Git user I highly recommend you to watch "How Git works under the hood" section and then jump to advanced Git features like squashing, cherry-picking etc.
- Complete Git and GitHub guide. Master basic and advanced Git features: commits, branches, merging, rebasing, squashing.
Who this course is for:
- You could be either complete beginner or experienced developer with years of usage of Git
- You may know how to USE Git but you may not know HOW Git works
- If you want to learn HOW and WHY Git and GitHub work - this course is for you!
What you'll learn:
- Deeply understand how Git works under the hood
- Use Git not just in terminal but also in graphical user interfaces like GitHub Desktop, SourceTree, Visual Studio Code
- Learn different GIt objects - blobs, trees, commits and annotated tags
- Create local and remote Git repositories
- Perform basic and advanced Git operations
- Learn how to perform rebasing and merging of the branches
- Learn what is pull request and how to create pull request at GitHub
- Contribute to public repositories using technique of forks and pull requests from the forked repository
- Understand what is semantic versioning and how to use Git Tags in order to create software release versions
- Learn advanced Git operations - squashing, cherry-picking, amending, reverting commits.
About the Author: Udemy
Udemy is the largest open marketplace for online courses on the internet. Founded in 2010 by Eren Bali, Oktay Caglar, and Gagan Biyani and headquartered in San Francisco, the company went public on the Nasdaq in 2021 under the ticker UDMY. The platform hosts well over two hundred thousand courses across software development, IT and cloud, data science, design, business, marketing, and creative skills, taught by tens of thousands of independent instructors. Roughly seventy million learners use it worldwide, and the corporate arm — Udemy Business — supplies a curated subset of that catalog to enterprise customers.
Because Udemy is a marketplace rather than a single editorial publisher, the catalog is uneven by design. The strongest material lives in the long-form, project-based courses authored by working engineers — full-stack JavaScript, React, Node.js, Python data science, AWS, Docker and Kubernetes, mobile development with Flutter and React Native, and cloud certification preparation. The CourseFlix listing under this source is the slice of that catalog that has been mirrored here for offline-friendly viewing, organized by topic and updated as new releases land. Pricing on Udemy itself swings dramatically with the site's near-permanent sales, which is why the platform is best treated as a deep reference catalog: pick instructors with strong reviews and a track record of updating their material rather than buying on the headline price alone.
Watch Online 224 lessons
0:00
/ #1: Section 1 Introduction
All Course Lessons (224)
| # | Lesson Title | Duration | Access |
|---|---|---|---|
| 1 | Section 1 Introduction Demo | 01:29 | |
| 2 | Git vs GitHub | 05:31 | |
| 3 | Section 2 Introduction | 00:43 | |
| 4 | Installing Git on MacOS | 02:25 | |
| 5 | Installing Git on Windows | 10:42 | |
| 6 | Installing Git on Linux | 08:21 | |
| 7 | Installing iTerm2 on the Mac | 05:37 | |
| 8 | Installing custom shell Z-Shell on the Mac | 05:33 | |
| 9 | Section 3 Introduction | 00:44 | |
| 10 | Shell commands - directory management | 09:39 | |
| 11 | Shell commands - file management - PART 1 | 09:00 | |
| 12 | Shell commands - file management - PART 2 | 08:26 | |
| 13 | Section 4 Introduction | 00:58 | |
| 14 | Initialize new Git repository | 04:13 | |
| 15 | Overview of .git folder | 04:02 | |
| 16 | Git object types | 03:03 | |
| 17 | Writing new Git object with git hash-object | 06:46 | |
| 18 | JSON vs Git database | 03:58 | |
| 19 | What is hash function | 03:53 | |
| 20 | Hash functions overview | 03:30 | |
| 21 | SHA1 Hash Function | 10:19 | |
| 22 | How many files Git could store | 04:10 | |
| 23 | Probability theory in Dice game | 04:12 | |
| 24 | Git hash collision probability | 05:57 | |
| 25 | More details on hash collision probability | 27:14 | |
| 26 | Exploring Git objects with git cat-file command | 05:25 | |
| 27 | Create new Git Blob based on the file | 07:57 | |
| 28 | Git blobs don't store filenames | 02:41 | |
| 29 | Contents of Git objects | 10:15 | |
| 30 | What we have so far | 01:57 | |
| 31 | Tree objects in Git | 02:42 | |
| 32 | Git object permissions | 02:26 | |
| 33 | Creating Git Tree object | 09:53 | |
| 34 | Examining Tree Object | 04:53 | |
| 35 | Working directory, Staging area and Git repository | 01:56 | |
| 36 | Overview of current files distribution | 03:51 | |
| 37 | Git read-tree | 03:52 | |
| 38 | Read files in the staging area using git ls-files | 01:59 | |
| 39 | Git checkout-index | 03:12 | |
| 40 | How many folders could be created for objects | 02:21 | |
| 41 | Section Summary | 04:21 | |
| 42 | Section 5 Introduction | 00:54 | |
| 43 | What is Commit | 04:00 | |
| 44 | Configure Git author name and email | 04:01 | |
| 45 | Creating first commit | 05:37 | |
| 46 | Exploring commit object | 05:09 | |
| 47 | Current project state overview | 03:35 | |
| 48 | Basic Git commands | 05:44 | |
| 49 | Adding new file to working directory | 08:38 | |
| 50 | Git files lifecycle | 02:00 | |
| 51 | Stage file | 02:58 | |
| 52 | Unstage file using git rm | 02:08 | |
| 53 | Commit changes | 07:54 | |
| 54 | Exploring changes in Git repository | 06:16 | |
| 55 | Current diagram of Git repository | 03:51 | |
| 56 | Section 6 Introduction | 01:13 | |
| 57 | Most common Git operations | 06:18 | |
| 58 | Overview of the current project state | 01:24 | |
| 59 | Installing GitHub Desktop | 03:37 | |
| 60 | GitHub Desktop Overview | 04:59 | |
| 61 | What is branch in Git | 06:45 | |
| 62 | What is HEAD in Git | 05:32 | |
| 63 | Third commit | 05:23 | |
| 64 | Git repository changes after third commit | 07:13 | |
| 65 | Checkout specific commit | 13:50 | |
| 66 | Why do we need branches | 10:37 | |
| 67 | Git branches management | 03:05 | |
| 68 | Create new branch | 07:21 | |
| 69 | Commit changes in the new branch | 04:36 | |
| 70 | Explore commit in the new branch | 05:32 | |
| 71 | Git reuses blobs with the same contents | 07:35 | |
| 72 | Section 7 Introduction | 00:56 | |
| 73 | Cloning remote repository | 06:02 | |
| 74 | Exploring contents of the cloned repository | 07:53 | |
| 75 | Unpacking Git objects | 04:07 | |
| 76 | Exploring cloned repository in GitHub Desktop | 05:19 | |
| 77 | Installing text editor Visual Studio Code | 02:46 | |
| 78 | Exploring Visual Studio Code | 06:06 | |
| 79 | Commit changes in the cloned repository | 11:35 | |
| 80 | Git diff command | 13:57 | |
| 81 | Overview of the changes | 03:44 | |
| 82 | Section 8 Introduction | 01:15 | |
| 83 | Why branches merging is needed | 03:28 | |
| 84 | Fast forward merge | 04:16 | |
| 85 | Merging process | 01:54 | |
| 86 | Fast forward merge in action | 06:58 | |
| 87 | 3-way merge | 06:00 | |
| 88 | Performing 3-way merge | 12:39 | |
| 89 | Observing Git repository after 3-way merge | 06:41 | |
| 90 | Installing SourceTree | 04:01 | |
| 91 | SourceTree in action | 06:35 | |
| 92 | What is merge conflict | 03:06 | |
| 93 | Creating merge conflict | 09:49 | |
| 94 | Observing conflicts in staging area and working directory | 06:45 | |
| 95 | Resolving merge conflict in Terminal | 03:01 | |
| 96 | Resolving conflicts in VS Code | 09:01 | |
| 97 | Section 9 Introduction | 00:56 | |
| 98 | What is Git hosting service | 03:36 | |
| 99 | Creating GitHub account | 03:33 | |
| 100 | Exploring first repository at GitHub | 11:01 | |
| 101 | Creating another commit at GitHub | 02:57 | |
| 102 | Creating new branch at GitHub | 01:26 | |
| 103 | Making changes in the new branch | 04:23 | |
| 104 | Cloning remote repository | 05:15 | |
| 105 | What is remote repository | 02:56 | |
| 106 | How remote repository empowers collaboration | 04:04 | |
| 107 | Section 10 Introduction | 01:36 | |
| 108 | Overview of the push, fetch and pull Git commands | 06:16 | |
| 109 | What is origin | 04:18 | |
| 110 | List remote and local branches | 03:05 | |
| 111 | What is tracking branch | 05:00 | |
| 112 | Checkout remote branch | 03:56 | |
| 113 | Git remote show origin | 03:09 | |
| 114 | Git fetch in action | 06:23 | |
| 115 | Git pull is 2-step process | 03:55 | |
| 116 | How to perform git pull | 05:09 | |
| 117 | What is FETCH_HEAD | 08:25 | |
| 118 | Git pull with fast forward merge | 07:38 | |
| 119 | Fetch remote changes manually | 09:10 | |
| 120 | Merge FETCH_HEAD manually | 06:06 | |
| 121 | Resolving conflicts during Git pull | 11:59 | |
| 122 | Pushing to remote repository | 09:28 | |
| 123 | Commit under another author | 02:43 | |
| 124 | Remote and local branches are in sync now | 03:35 | |
| 125 | Create remote branch based on local branch | 08:53 | |
| 126 | Update tracking statuses of the branches | 08:00 | |
| 127 | Remove remote branch using local terminal | 03:53 | |
| 128 | Git show-ref | 04:25 | |
| 129 | Section 11 Introduction | 01:04 | |
| 130 | Collaboration between contributors | 04:30 | |
| 131 | What is pull request? | 02:36 | |
| 132 | Why pull request was named pull request | 06:12 | |
| 133 | Pull request or Merge request | 04:56 | |
| 134 | Pull request step-by-step | 07:50 | |
| 135 | Create new repository at GitHub | 06:54 | |
| 136 | Changing author of the last commit | 02:33 | |
| 137 | Pushing branch to remote | 05:01 | |
| 138 | Open pull request | 07:31 | |
| 139 | Adding comments and approving pull request | 09:25 | |
| 140 | Creating and publishing new branch using GitHub Desktop | 05:30 | |
| 141 | Signing in to GitHub in the GitHub Desktop | 01:25 | |
| 142 | Creating and merging pull request | 09:14 | |
| 143 | Adding new collaborator under GitHub | 03:56 | |
| 144 | Exploring own GitHub account | 04:50 | |
| 145 | Opening and merging PR by collaborator | 06:37 | |
| 146 | By default merging is allowed without approvals | 02:24 | |
| 147 | Configure protected branch rule | 04:19 | |
| 148 | Merging after required approve | 02:57 | |
| 149 | Exploring pull requests in the public repositories | 05:59 | |
| 150 | Working with issues at GitHub | 11:31 | |
| 151 | Section 12 Introduction | 00:51 | |
| 152 | Creating Fork | 04:47 | |
| 153 | How to sync changes from the parent repository | 05:14 | |
| 154 | Adding new upstream remote repository | 02:05 | |
| 155 | Fetching changes from upstream | 02:27 | |
| 156 | Synchronizing changes from upstream | 10:56 | |
| 157 | How to open pull request from the forked repository | 02:33 | |
| 158 | Plan for creating pull request from the forked repository | 02:00 | |
| 159 | Removing repository collaborator | 02:08 | |
| 160 | Forking repository | 03:01 | |
| 161 | Committing changes in the forked repository | 03:18 | |
| 162 | Open pull request from the forked repository | 04:32 | |
| 163 | Approving and merging pull request from the forked repository | 11:44 | |
| 164 | Section 13 Introduction | 00:55 | |
| 165 | Git tags overview | 03:17 | |
| 166 | Staging vs Production | 06:53 | |
| 167 | Semantic versioning | 11:09 | |
| 168 | Lightweight vs Annotated tags | 04:24 | |
| 169 | Creating lightweight tags | 09:33 | |
| 170 | Creating annotated tag | 02:51 | |
| 171 | Exploring git tag object | 03:05 | |
| 172 | Pushing tags to remote | 10:20 | |
| 173 | Section 14 Introduction | 01:27 | |
| 174 | Introduction to Rebasing | 01:34 | |
| 175 | Merging vs Rebasing | 05:14 | |
| 176 | How to perform rebasing | 01:57 | |
| 177 | Rebasing - STEP 1 | 02:49 | |
| 178 | Rebasing - STEP 2 | 02:40 | |
| 179 | Creating new repository | 02:16 | |
| 180 | Creating feature branch and making changes | 04:51 | |
| 181 | Rebasing feature branch on top of master branch | 03:06 | |
| 182 | Completing rebasing by performing merging | 01:56 | |
| 183 | Exploring graph and commits in SourceTree | 05:10 | |
| 184 | Deleteing feature branch and pushing to remote | 01:39 | |
| 185 | Section 15 Introduction | 01:12 | |
| 186 | Introduction go Git ignore | 02:19 | |
| 187 | Git file statuses - untracked, tracked and ignored | 02:08 | |
| 188 | Basic gitignore rules | 08:02 | |
| 189 | Pushing repository with ignored files to remote | 02:37 | |
| 190 | Committing previously ignored file | 02:54 | |
| 191 | Ignore previously committed file | 04:09 | |
| 192 | Git ignore common practices and templates | 05:32 | |
| 193 | Section 16 Introduction | 01:24 | |
| 194 | Detached HEAD state | 04:23 | |
| 195 | Making experimental commits in detached HEAD state | 08:28 | |
| 196 | Retaining changes made in the detached HEAD state | 08:04 | |
| 197 | Section 17 Introduction | 00:51 | |
| 198 | Cloning one of the public repositories | 03:14 | |
| 199 | Git log options - oneline, graph, stat | 05:42 | |
| 200 | Git shortlog | 01:44 | |
| 201 | Filtering commits by author or keyword | 02:52 | |
| 202 | Pretty formatting of git log | 03:07 | |
| 203 | Filter out merge commits in git log | 03:05 | |
| 204 | Git reset | 10:18 | |
| 205 | Git revert | 08:33 | |
| 206 | Modifying last commit using amend option | 03:52 | |
| 207 | Cherry-picking commits | 05:53 | |
| 208 | Reflog - log of all Git operations | 07:13 | |
| 209 | Stashing changes using terminal | 05:26 | |
| 210 | Stashing using GitHub Desktop | 02:25 | |
| 211 | Garbage collection | 03:20 | |
| 212 | Squashing of commits at GitHub | 07:59 | |
| 213 | Interactive rebasing with squashing in the local repository | 07:40 | |
| 214 | Git development workflow | 06:20 | |
| 215 | Section 18 Introduction | 01:33 | |
| 216 | Creating simple website using GitHub Pages | 04:22 | |
| 217 | Hosting any Repository using GitHub Pages | 08:27 | |
| 218 | Creating basic React application | 09:50 | |
| 219 | Preparing React application for publish to the GitHub Pages | 08:43 | |
| 220 | Fixing error with cached credentials by using SSH instead of HTTPS | 10:43 | |
| 221 | Verifying React GitHub Page | 07:27 | |
| 222 | Configuring custom domain for GitHub Pages | 10:58 | |
| 223 | Creating static GitHub Page using markdown | 04:59 | |
| 224 | Wrap Up | 00:24 |
Unlock unlimited learning
Get instant access to all 223 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.
Learn more about subscriptionRelated courses
-
Updated 3y agoThe Git & Github Bootcamp
By: UdemyThe following sentence is annoying, but also true: the best time to learn Git was yesterday . Fortunately, the second best time is today!16h 54m -
Updated 2y agoGit From Start to Finish
By: Tim CoreyMaster Git with our comprehensive course. Learn everything from core concepts and using Git in professional settings to troubleshooting and advanced command6h 1m -
Updated 2y agoGit & GitHub Full Course
By: FireshipThe Git & GitHub Full Course teaches you how to use Git and GitHub to manage your code like a professional software engineer.1h3/5
Frequently asked questions
What are the prerequisites for enrolling in the course?
The course assumes no prior knowledge of Git or GitHub. However, familiarity with basic shell commands and directory management would be beneficial as these are covered early in the course. The lessons include guides on installing Git on various operating systems and setting up terminal tools like iTerm2 on Mac, which are foundational for following along with the exercises.
What projects or skills will I build during the course?
Throughout the course, you will gain hands-on experience with initializing a Git repository, creating and managing branches, and performing operations such as commits, merging, and rebasing. You'll also learn to interact with and analyze Git objects, use GitHub for version control, and understand the internal workings of Git like hash functions and object storage.
Who is the target audience for this course?
This course is ideal for developers, software engineers, and anyone interested in version control systems. It's suitable for beginners who wish to learn Git from scratch, as well as intermediate users looking to deepen their understanding of advanced Git features like object types and hash functions.
How does this course compare to other Git courses?
The course offers a detailed exploration of both basic and advanced Git features, including a deep dive into Git's internal mechanisms such as hash functions and Git objects. With 224 lessons, it provides comprehensive coverage that may be more extensive than shorter, more introductory courses.
What specific tools or platforms will I learn to use in this course?
You will learn to install and use Git on MacOS, Windows, and Linux. The course also covers the installation and configuration of terminal tools like iTerm2 and Z-Shell on Mac. Additionally, you'll get an overview of GitHub Desktop, providing a graphical interface for Git operations.
What topics are not covered in this course?
The course focuses specifically on Git and GitHub. While it covers basic shell commands necessary for Git operations, it does not delve into other version control systems, software development methodologies, or advanced programming concepts outside the scope of Git and GitHub.
What is the time commitment required for this course?
With 224 lessons, the course is comprehensive and designed for thorough understanding. While the total runtime is not specified, allocating regular study sessions across several weeks would be practical to fully absorb the material and practice the exercises provided.