Learn the basics of Git in 100 seconds.

0:09 Initialize a git repo 
0:33 Stage files
0:39 Commit a snapshot
1:12 Branch off into an alternate universe
1:30 Merge a branch into master

Follow me on Github https://github.com/codediodeio
Git Docs: https://git-scm.com/

#git #100SecondsOfCode

Install the quiz app 🤓

iOS https://itunes.apple.com/us/app/fireship/id1462592372?mt=8
Android https://play.google.com/store/apps/details?id=io.fireship.quizapp

Upgrade to Fireship PRO at https://fireship.io/pro
Use code lORhwXd2 for 25% off your first payment. 

My VS Code Theme

- Atom One Dark 
- vscode-icons
- Fira Code Font
2024-02-04T06:21:17.286Z
nova-2
2-general-nova
2024-01-09.29447
30089e05-99d1-4376-b32e-c263170674af
3ca66881-95b5-47f9-ae82-fa5ceb9c13ed
958fd09dc5b25e1c5bd07fea4ba2634219034f923aab1ea6240d309de0e96068
67875a7f-c9c4-48a0-aa55-5bdb8a91c34a
deprecated
Git, a system for keeping track of changes that happen across a set of files.
Open a directory on your local system with an editor like Versus Code, then run git init from the command line.
You just created a git repository or repo.
It lives in this hidden git directory and keeps track of all the changes that happened to these files.
As you work on a code base, you take snapshots or commits of the current state of these files.
Every commit has a unique ID and is linked to its parent, And this means we can travel back in time to a previous version of our files.
Notice how our source control icon is lit up.
Currently, all of our files They're untracked because we need to add them to the repo.
Run git add to include or stage these files in the repo, then create a snapshot of their current State by running git commit along with a message about what you did to these files.
Congratulations, you just created the first commit on the head of the master branch in this repo.
The changed file's disappeared and you're now on a clean working directory.
The head represents the most recent commit.
If we make some changes, commit them to the repo, the head moves Forward, but we still have a reference to our previous commit, so we can always go back to it.
But, the thing about software is that it's developed in a non linear fashion.
You might have multiple teams working on Print features for the same code base simultaneously.
Git makes that possible by branching.
Create one by running git branch and then run git checkout to move into that branch.
You can now safely work on your feature in this branch without affecting the code or files in the master branch.
The commits you make here live in an alternate universe with its own unique history.
At some point though, you'll likely want to merge this history with the history in the master branch.
When you're ready, go back to the master branch by running git checkout.
Then run git merge on your alternate universe.
The tip of your feature branch now becomes the head of the master branch.
Or, in other words, our fragmented universe has become 1.
Unless, you ran into a merge conflict.
In which case, you'll just have to wait for the sequel.
This has been Git Explained in 100 seconds.
If you want to see more short videos like this, make sure to hit the like button, subscribe, and let me know what you think in the Thanks for watching and I will see you in the next one.

Speaker 0: Git, a system for keeping track of changes that happen across a set of files. Open a directory on your local system with an editor like Versus Code, then run git init from the command line. You just created a git repository or repo. It lives in this hidden git directory and keeps track of all the changes that happened to these files. As you work on a code base, you take snapshots or commits of the current state of these files.

Every commit has a unique ID and is linked to its parent, And this means we can travel back in time to a previous version of our files. Notice how our source control icon is lit up. Currently, all of our files They're untracked because we need to add them to the repo. Run git add to include or stage these files in the repo, then create a snapshot of their current State by running git commit along with a message about what you did to these files. Congratulations, you just created the first commit on the head of the master branch in this repo.

The changed file's disappeared and you're now on a clean working directory. The head represents the most recent commit. If we make some changes, commit them to the repo, the head moves Forward, but we still have a reference to our previous commit, so we can always go back to it. But, the thing about software is that it's developed in a non linear fashion. You might have multiple teams working on Print features for the same code base simultaneously.

Git makes that possible by branching. Create one by running git branch and then run git checkout to move into that branch. You can now safely work on your feature in this branch without affecting the code or files in the master branch. The commits you make here live in an alternate universe with its own unique history. At some point though, you'll likely want to merge this history with the history in the master branch.

When you're ready, go back to the master branch by running git checkout. Then run git merge on your alternate universe. The tip of your feature branch now becomes the head of the master branch. Or, in other words, our fragmented universe has become 1. Unless, you ran into a merge conflict.

In which case, you'll just have to wait for the sequel. This has been Git Explained in 100 seconds. If you want to see more short videos like this, make sure to hit the like button, subscribe, and let me know what you think in the Thanks for watching and I will see you in the next one.
Git, a system for keeping track of changes that happen across a set of files. Open a directory on your local system with an editor like Versus Code, then run git init from the command line. You just created a git repository or repo. It lives in this hidden git directory and keeps track of all the changes that happened to these files. As you work on a code base, you take snapshots or commits of the current state of these files. Every commit has a unique ID and is linked to its parent, And this means we can travel back in time to a previous version of our files. Notice how our source control icon is lit up. Currently, all of our files They're untracked because we need to add them to the repo. Run git add to include or stage these files in the repo, then create a snapshot of their current State by running git commit along with a message about what you did to these files. Congratulations, you just created the first commit on the head of the master branch in this repo. The changed file's disappeared and you're now on a clean working directory. The head represents the most recent commit. If we make some changes, commit them to the repo, the head moves Forward, but we still have a reference to our previous commit, so we can always go back to it.
But, the thing about software is that it's developed in a non linear fashion. You might have multiple teams working on Print features for the same code base simultaneously. Git makes that possible by branching. Create one by running git branch and then run git checkout to move into that branch.
software development
software
programming
You can now safely work on your feature in this branch without affecting the code or files in the master branch. The commits you make here live in an alternate universe with its own unique history. At some point though, you'll likely want to merge this history with the history in the master branch. When you're ready, go back to the master branch by running git checkout. Then run git merge on your alternate universe. The tip of your feature branch now becomes the head of the master branch.
Or, in other words, our fragmented universe has become 1. Unless, you ran into a merge conflict. In which case, you'll just have to wait for the sequel. This has been Git Explained in 100 seconds. If you want to see more short videos like this, make sure to hit the like button, subscribe, and let me know what you think in the Thanks for watching and I will see you in the next one.
youtube
cosmology
Git, a system for keeping track of changes that happen across a set of files. Open a directory on your local system with an editor like Versus Code, then run git init from the command line. You just created a git repository or repo. It lives in this hidden git directory and keeps track of all the changes that happened to these files. As you work on a code base, you take snapshots or commits of the current state of these files. Every commit has a unique ID and is linked to its parent, And this means we can travel back in time to a previous version of our files. Notice how our source control icon is lit up. Currently, all of our files They're untracked because we need to add them to the repo. Run git add to include or stage these files in the repo, then create a snapshot of their current State by running git commit along with a message about what you did to these files. Congratulations, you just created the first commit on the head of the master branch in this repo. The changed file's disappeared and you're now on a clean working directory. The head represents the most recent commit. If we make some changes, commit them to the repo, the head moves Forward, but we still have a reference to our previous commit, so we can always go back to it. But, the thing about software is that it's developed in a non linear fashion. You might have multiple teams working on Print features for the same code base simultaneously. Git makes that possible by branching. Create one by running git branch and then run git checkout to move into that branch. You can now safely work on your feature in this branch without affecting the code or files in the master branch. The commits you make here live in an alternate universe with its own unique history. At some point though, you'll likely want to merge this history with the history in the master branch. When you're ready, go back to the master branch by running git checkout. Then run git merge on your alternate universe. The tip of your feature branch now becomes the head of the master branch. Or, in other words, our fragmented universe has become 1. Unless, you ran into a merge conflict. In which case, you'll just have to wait for the sequel. This has been Git Explained in 100 seconds. If you want to see more short videos like this, make sure to hit the like button, subscribe, and let me know what you think in the Thanks for watching and I will see you in the next one.
Git,
git
a
a
system
system
for
for
keeping
keeping
track
track
of
of
changes
changes
that
that
happen
happen
across
across
a
a
set
set
of
of
files.
files
Open
open
a
a
directory
directory
on
on
your
your
local
local
system
system
with
with
an
an
editor
editor
like
like
Versus
versus
Code,
code
then
then
run
run
git
git
init
init
from
from
the
the
command
command
line.
line
You
you
just
just
created
created
a
a
git
git
repository
repository
or
or
repo.
repo
It
it
lives
lives
in
in
this
this
hidden
hidden
git
git
directory
directory
and
and
keeps
keeps
track
track
of
of
all
all
the
the
changes
changes
that
that
happened
happened
to
to
these
these
files.
files
As
as
you
you
work
work
on
on
a
a
code
code
base,
base
you
you
take
take
snapshots
snapshots
or
or
commits
commits
of
of
the
the
current
current
state
state
of
of
these
these
files.
files
Every
every
commit
commit
has
has
a
a
unique
unique
ID
id
and
and
is
is
linked
linked
to
to
its
its
parent,
parent
And
and
this
this
means
means
we
we
can
can
travel
travel
back
back
in
in
time
time
to
to
a
a
previous
previous
version
version
of
of
our
our
files.
files
Notice
notice
how
how
our
our
source
source
control
control
icon
icon
is
is
lit
lit
up.
up
Currently,
currently
all
all
of
of
our
our
files
files
They're
they're
untracked
untracked
because
because
we
we
need
need
to
to
add
add
them
them
to
to
the
the
repo.
repo
Run
run
git
git
add
add
to
to
include
include
or
or
stage
stage
these
these
files
files
in
in
the
the
repo,
repo
then
then
create
create
a
a
snapshot
snapshot
of
of
their
their
current
current
State
state
by
by
running
running
git
git
commit
commit
along
along
with
with
a
a
message
message
about
about
what
what
you
you
did
did
to
to
these
these
files.
files
Congratulations,
congratulations
you
you
just
just
created
created
the
the
first
first
commit
commit
on
on
the
the
head
head
of
of
the
the
master
master
branch
branch
in
in
this
this
repo.
repo
The
the
changed
changed
file's
file's
disappeared
disappeared
and
and
you're
you're
now
now
on
on
a
a
clean
clean
working
working
directory.
directory
The
the
head
head
represents
represents
the
the
most
most
recent
recent
commit.
commit
If
if
we
we
make
make
some
some
changes,
changes
commit
commit
them
them
to
to
the
the
repo,
repo
the
the
head
head
moves
moves
Forward,
forward
but
but
we
we
still
still
have
have
a
a
reference
reference
to
to
our
our
previous
previous
commit,
commit
so
so
we
we
can
can
always
always
go
go
back
back
to
to
it.
it
But,
but
the
the
thing
thing
about
about
software
software
is
is
that
that
it's
it's
developed
developed
in
in
a
a
non
non
linear
linear
fashion.
fashion
You
you
might
might
have
have
multiple
multiple
teams
teams
working
working
on
on
Print
print
features
features
for
for
the
the
same
same
code
code
base
base
simultaneously.
simultaneously
Git
git
makes
makes
that
that
possible
possible
by
by
branching.
branching
Create
create
one
one
by
by
running
running
git
git
branch
branch
and
and
then
then
run
run
git
git
checkout
checkout
to
to
move
move
into
into
that
that
branch.
branch
You
you
can
can
now
now
safely
safely
work
work
on
on
your
your
feature
feature
in
in
this
this
branch
branch
without
without
affecting
affecting
the
the
code
code
or
or
files
files
in
in
the
the
master
master
branch.
branch
The
the
commits
commits
you
you
make
make
here
here
live
live
in
in
an
an
alternate
alternate
universe
universe
with
with
its
its
own
own
unique
unique
history.
history
At
at
some
some
point
point
though,
though
you'll
you'll
likely
likely
want
want
to
to
merge
merge
this
this
history
history
with
with
the
the
history
history
in
in
the
the
master
master
branch.
branch
When
when
you're
you're
ready,
ready
go
go
back
back
to
to
the
the
master
master
branch
branch
by
by
running
running
git
git
checkout.
checkout
Then
then
run
run
git
git
merge
merge
on
on
your
your
alternate
alternate
universe.
universe
The
the
tip
tip
of
of
your
your
feature
feature
branch
branch
now
now
becomes
becomes
the
the
head
head
of
of
the
the
master
master
branch.
branch
Or,
or
in
in
other
other
words,
words
our
our
fragmented
fragmented
universe
universe
has
has
become
become
1.
1
Unless,
unless
you
you
ran
ran
into
into
a
a
merge
merge
conflict.
conflict
In
in
which
which
case,
case
you'll
you'll
just
just
have
have
to
to
wait
wait
for
for
the
the
sequel.
sequel
This
this
has
has
been
been
Git
git
Explained
explained
in
in
100
100
seconds.
seconds
If
if
you
you
want
want
to
to
see
see
more
more
short
short
videos
videos
like
like
this,
this
make
make
sure
sure
to
to
hit
hit
the
the
like
like
button,
button
subscribe,
subscribe
and
and
let
let
me
me
know
know
what
what
you
you
think
think
in
in
the
the
Thanks
thanks
for
for
watching
watching
and
and
I
i
will
will
see
see
you
you
in
in
the
the
next
next
one.
one
success
The speaker explains how to use Git to keep track of changes across a set of files, including creating a git repository and running git add to include or stage files in the repo. They also explain how the software is developed in a non linear fashion and how it can be difficult to merge multiple changes into one commit at a time. The speaker provides short videos and encourages viewers to subscribe to their channel.
Git Explained in 100 Seconds
Git, a system for keeping track of changes that happen across a set of files. Open a directory on your local system with an editor like Versus Code, then run git init from the command line. You just created a git repository or repo. It lives in this hidden git directory and keeps track of all the changes that happened to these files. As you work on a code base, you take snapshots or commits of the current state of these files. Every commit has a unique ID and is linked to its parent, And this means we can travel back in time to a previous version of our files. Notice how our source control icon is lit up. Currently, all of our files They're untracked because we need to add them to the repo. Run git add to include or stage these files in the repo, then create a snapshot of their current State by running git commit along with a message about what you did to these files. Congratulations, you just created the first commit on the head of the master branch in this repo. The changed file's disappeared and you're now on a clean working directory. The head represents the most recent commit. If we make some changes, commit them to the repo, the head moves Forward, but we still have a reference to our previous commit, so we can always go back to it. But, the thing about software is that it's developed in a non linear fashion. You might have multiple teams working on Print features for the same code base simultaneously. Git makes that possible by branching. Create one by running git branch and then run git checkout to move into that branch. You can now safely work on your feature in this branch without affecting the code or files in the master branch. The commits you make here live in an alternate universe with its own unique history. At some point though, you'll likely want to merge this history with the history in the master branch. When you're ready, go back to the master branch by running git checkout. Then run git merge on your alternate universe. The tip of your feature branch now becomes the head of the master branch. Or, in other words, our fragmented universe has become 1. Unless, you ran into a merge conflict. In which case, you'll just have to wait for the sequel. This has been Git Explained in 100 seconds. If you want to see more short videos like this, make sure to hit the like button, subscribe, and let me know what you think in the Thanks for watching and I will see you in the next one.
The speaker explains how to use Git to keep track of changes across a set of files, including creating a git repository and running git add to include or stage files in the repo. They also explain how the software is developed in a non linear fashion and how it can be difficult to merge multiple changes into one commit at a time. The speaker provides short videos and encourages viewers to subscribe to their channel.

        [INST]
        You are youtuber called Fireship you make engaging high-intensity and entertaining coding tutorials and tech news. 
        you covers a wide range of topics relevant to programmers, aiming to help them learn and improve their skills quickly.
        
        Given the title of the video : Git Explained in 100 Seconds 
        and a small summary : The speaker explains how to use Git to keep track of changes across a set of files, including creating a git repository and running git add to include or stage files in the repo. They also explain how the software is developed in a non linear fashion and how it can be difficult to merge multiple changes into one commit at a time. The speaker provides short videos and encourages viewers to subscribe to their channel.
        [/INST]
        
        Generate the video : Git, a system for keeping track of changes that happen across a set of files. Open a directory on your local system with an editor like Versus Code, then run git init from the command line. You just created a git repository or repo. It lives in this hidden git directory and keeps track of all the changes that happened to these files. As you work on a code base, you take snapshots or commits of the current state of these files. Every commit has a unique ID and is linked to its parent, And this means we can travel back in time to a previous version of our files. Notice how our source control icon is lit up. Currently, all of our files They're untracked because we need to add them to the repo. Run git add to include or stage these files in the repo, then create a snapshot of their current State by running git commit along with a message about what you did to these files. Congratulations, you just created the first commit on the head of the master branch in this repo. The changed file's disappeared and you're now on a clean working directory. The head represents the most recent commit. If we make some changes, commit them to the repo, the head moves Forward, but we still have a reference to our previous commit, so we can always go back to it. But, the thing about software is that it's developed in a non linear fashion. You might have multiple teams working on Print features for the same code base simultaneously. Git makes that possible by branching. Create one by running git branch and then run git checkout to move into that branch. You can now safely work on your feature in this branch without affecting the code or files in the master branch. The commits you make here live in an alternate universe with its own unique history. At some point though, you'll likely want to merge this history with the history in the master branch. When you're ready, go back to the master branch by running git checkout. Then run git merge on your alternate universe. The tip of your feature branch now becomes the head of the master branch. Or, in other words, our fragmented universe has become 1. Unless, you ran into a merge conflict. In which case, you'll just have to wait for the sequel. This has been Git Explained in 100 seconds. If you want to see more short videos like this, make sure to hit the like button, subscribe, and let me know what you think in the Thanks for watching and I will see you in the next one.
        