Teach on Udemy

Turn what you know into an opportunity and reach millions around the world.

Learn More

Your cart is empty.

Keep shopping

Git Mindset: Underlying Architecture of Git in Simple Terms

Name: Git Mindset: Underlying Architecture of Git in Simple Terms
Rating: 4.5 (252 reviews)

Gain a deep intuition of the Git version control system, simplified through story telling

Created byAbhin Chhabra, Sandeep Kumar Quality Gurus Inc.

Last updated 9/2021

English

What you'll learn

How to use Git to manage your project
How to collaborate with other developers using Git
The core concepts underlying Git through storytelling
How Git works under the hood
How to study the history of your project for learning and troubleshooting
Effectively use Git commands in the command line

Course content

6 sections • 50 lectures • 6h 3m total length

What you'll learn in this course4:06
Introduction1:06
In this section, I explain the usefulness of storytelling as a mechanism for learning. I introduce you to the contents of this section, which revolve around Amy and her colleagues and how they iterate on their workflow and will ultimately converge on a workflow highly resembling Git.
Introducing Ana's workflow5:57
In this lecture, we'll start with Ana's simple workflow. We'll then go over how Ana realizes the need for checkpointing and backing up her work and how a simple change to her workflow gives her both those abilities.
Basics of Hashing4:25
In this lecture, I'll explain some basics of hashing. We'll need these concepts for the next lecture.
Ana hashes out a plan to gain efficiency9:52
In this lecture, we'll go over how Ana uses hashes to reduce duplication of files across commits.
Review of concepts discussed so far
Blake joins the team5:56
In this lecture, Ana helps Blake (a new contributor to UsChat) onboard. I'll introduce the concept of diffing commits.
Diffing and Patching18:41
In this lecture, we'll learn about the core ideas behind diffing and patching. We'll also get some hands-on experience with the Unix utilities diff and patch.
Review of diffing and patching
Blake submits his first contribution4:44
This lecture details how Blake uses the diff and patch commands to get his work incorporated into the main line of work maintained by Ana.
Hashes make a second entrance9:20
In this lecture, Ana and Blake come up with a way to avoid commits getting overwritten when syncing with the SFTP server.
Review of concepts discussed so far
Ana and Blake package up their Version Control System1:50
In this lecture, Ana and Blake package up their Version Control System (VCS) to be used by others. It acquires a more mature user interface and starts to resemble Git even more.
Summary1:06

Introduction0:38
What is Git?3:22
Understand Git as a distributed version-control system that tracks every change in your codebase and beyond, enabling concurrent contributions and preserving full history of source code.
Basics about Git
How to install Git on your Mac3:54
How to install Git on your Windows PC1:43
Install Git on a Windows PC using git-scm, choose Windows download, run installer, switch the editor from Vim to a friendlier option, and verify with git --version using Git Bash.
(Optional) Overview of basic command line utilities - part 110:45
In this lesson, I'll go over some basic command line utilities and concepts that you need to know to follow the rest of the material.
(Optional) Overview of basic command line utilities - part 211:03
In this lesson, we resume where we left off in the last lesson and learn some more basic command line utilities and concepts that you need to know to follow the rest of the material.
Creating our first Git repository3:47
Adding our first commit9:52
Create your first git commit by adding a readme, staging with git add, and writing a clear commit message; configure your name and email to set the author.
Studying our first commit10:23
In this lecture, we'll inspect the commit we created in the last lecture. In the process, we'll learn a bit about how Git stores commits internally. We'll also learn some Git commands that help us inspect commits.
Adding a second commit13:22
In this lesson, we're going to create a second commit as a successor to our head commit. We'll examine that commit as well and learn a bit more about Git. Specifically, we'll learn more about Git's internal representation of commits, git show, git log and git help.
Introducing the staging area7:34
In this lesson, we're going to learn about the staging area and how it can help us be more explicit about which changes get included in our commits.
Solution: Committing the readme2:05
In this video, I provide the solution to the exercise left at the end of the last lesson.
Review of commit creation
Resetting to an older state8:51
In this lesson, we reset our repository to a state before we made the last 2 commits. This lesson will introduce us to the git reset command and to the idea of rewriting history.
Interactive adding13:49
In this lesson, we learn about git add's interactive adding capabilities. We use it to carefully stage a very precise list of changes.
Studying the staging area6:22
In this lesson, I will introduce you to the git diff command and explain how to use it to study the staging area.
Review of concepts discussed so far
Check this out!4:25
This lesson is an introduction to the git checkout command. We'll use git checkout to briefly navigate the history of our project.
Summary0:36
Build on basic git usage by crafting careful commits and studying them, while uncovering key concepts that expand the core functionality of git as the story continues.

Introduction3:34
In this video, I recap the story from section 2, so we can pick it back up.
Ana and Blake git back to work10:43
Ana and Blake take Tig out for a test drive after all those tweaks and analyze problems with it.
Don't git it twisted - Blake discovers branching23:40
Blake explores a multi-reference workflow with a refs directory, heads, and remotes, and extends tig to visualize the dag and support branching.
Git back in line - Ana discovers merging20:32
I git by with a little help from my friends4:37

Introduction1:11
What's the "master branch"?4:41
Explore the master branch as the default refs/heads/master that HEAD points to, and note git init's option to name the initial branch, with awareness of term changes.
Nobody likes a "dangling head"7:48
Creating branches9:20
Exploring git-log more13:11
Explore how to navigate git history with git log, using graph, --all, and file-level filters, to locate changes, understand ancestry, and study diffs.
Fast-forward merging6:30
Explore fast-forward merging in git by simply updating the master branch to the head of add-idiom-puns when master has no new changes.
Creating a merge commit4:51
Dealing with conflicts10:48
Tagging (We git to play tag!)10:28

Introduction0:54
Cloning1:56
Clone a repository with git clone to copy from the sftp server to your computer, creating a hello git clone directory with the same files as the original.
Git remotes6:46
Git fetch9:27
Git pull15:31
Git push - part 19:09
Learn how git push updates remote refs and transfers commits from your master branch to the origin, and understand the default push behavior and the centralized workflow.
Git push - part 27:46

Requirements

The ability to install software on your computer

Description

This course is designed to help you gain The Git Mindset. Using mechanisms like storytelling, hands-on-labs and quizzes, you'll gain a deep intuition about Git. To follow this course, you don't need any prior knowledge.

The course uses a story to explain not only what Git does, but also how it does those things and why it was designed that way.

Note: This course is up-to-date and uses the newer commands (switch and restore) introduced in Git 2.23.

Gitting the hang of it - Building intuition about Git

This section goes over the story of the smallest team with the simplest workflow - a lone developer named Ana who's working on her software project on her personal machine. Over time, we'll introduce additional requirements like the need to manage historical versions, the need to create backups, the need to collaborate with additional team members etc. Each of these requirements will lead to a change in the version control system and eventually this fictitious version control system (Tig) will have evolved into something very much resembling Git. This section will help you internalize the core concepts of Git with ease.

Gitting our hands dirty! - studying Git basics

We'll take a break from learning the core concepts of Git and try using Git ourselves. This entire section is a series of labs where you'll follow along and get hands on experience with Git. You'll find that the previous section has prepared you with enough core concepts that you'll find everything quite straight forward. By the end of this section, you'll know how to craft commits with care and how to study them.

The team Gits going again!

This section will resume the story of Tig. This time, we'll use storytelling to arrive at the concepts of branching and merging. The story will help you not only understand what branching and merging are, but also how they work and what kinds of problems they help us solve.

Let's Git back into it - resuming our study of Git

This section takes the concepts illustrated through a story in the last section and shows you how they apply to Git. By the end of this section, you'll be comfortable with branching and merging in Git. You'll know how to navigate the history of your project with ease. This will help you greatly with navigating new codebases and in troubleshooting bugs.

Dealing with remotes

This section shows you how to manage Git remotes and how to transfer information between them. The concepts covered in this section are essential for effectively managing your repository through source code hosting providers like Github, Bitbucket, Gitlab etc.

By the end of the course, you'll truly understand Git and you'll be able to use it like it's second nature.

This course comes with a 30-day money back guarantee. No questions asked.

--------------------------------------------------------------------------------------------------

All emojis designed by OpenMoji – the open-source emoji and icon project. License: CC BY-SA 4.0

Who this course is for:

Anyone new to Git
Anyone who uses Git already, but interested in gaining a deeper intuition about Git
Anyone who interacts with the software development lifecycle
Anyone interested in managing historical versions of their project

Git Mindset: Underlying Architecture of Git in Simple Terms

What you'll learn

Explore related topics

Course content

Gitting the hang of it - Building intuition about Git11 lectures • 1hr 7min

Gitting our hands dirty! - Studying Git basics17 lectures • 1hr 53min

The team gits going again!5 lectures • 1hr 3min

Let's Git back into it! - Resuming our study of Git9 lectures • 1hr 9min

Git me the remote - Dealing with remotes7 lectures • 51min

Bonus Section1 lecture • 1min

Requirements

Description

Who this course is for: