►
From YouTube: Let's git started together!
Description
For the first in my series of #Git15 videos, I talk with a few GitLab team members about the basics of git, the terminology involved, how to commit your first code to a repository and how the git command line works.
For more #Git15 videos for this 15th anniversary of Git, check out https://git15.labwork.dev/
A
A
You
can
share
your
screen
and
we
can
flavor
different
things,
but
because,
unfortunately,
a
lot
of
the
easiest
ways
to
learn
get
is
to
make
all
the
mistakes
and
use
it
like
many
applications
in
the
world,
but
just
kind
of
give
you
some
context.
First,
I
put
together
this.
It's
like
five
or
ten
slides.
So
we
talk
about
that.
So
first
like
what
is
get
so
get
is:
what's
called
a
source
code
management
tool,
right
SCM,
you
might
hear
sometimes
short
for
source
code
management
and
what
a
source
code
management.
A
It's
something
you
might
need
answer
before.
You
know
what
git
is,
so
you
know,
source
code
for
a
website
or
an
application,
or
even
you
know,
for
a
publication
like
documentation
of
of
some
application.
You
can
basically
think
of
source
code
as
a
collection
of
a
bunch
of
text
files
right
for
all
intents
and
purposes,
it
can
get
a
little
more
complicated
than
that,
but
just
basically
think
it
was
a
pile
of
text
files
like
we
see
here.
A
A
File,
a
and
D
right,
and
so
combining
all
of
those
changes
together
is
is
kind
of
can
be
a
very
complicated
thing
to
do,
and
it's
hard
for
a
human
to
do
it
on
their
own,
especially
when,
like
I
said,
if
Emily
and
I
are
both
editing
or
Jessica
and
I
are
both
editing
file,
a
it's
gonna
be
complicated
for
us
to
figure
out
wait.
How
do
we
merge
these
merge?
These
changes
together,
which
is
Ariel
here
a
lot
and
yet
and
so
source
control
management
tools.
A
Do
that
kind
of
heavy
lifting
of
bringing
code
together
from
different
people,
which
again
is
just
text
files
text
files
together
from
different
people
into
one.
You
know
final
product
if
you
will
and
traditionally
source
code
management
tools
were
very
like
client-to-server
based,
so
that
is
there'd
be
some
server
somewhere.
That
was
like
the
source
of
truth,
and
this
is
you
know
where
the
repository
is,
and
if
you
want
to
change
something
you
better
be
connect
to
that
server,
so
that
your
client
knows
what
you're
changing
at
all
times.
A
It
differs
a
little
bit
in
the
fact
that
it's
what's
called
a
distributed
version
control
system.
Dvcs
is
another
acronym,
you
hear
a
lot
and
what
that
means
is
while
there
can
be-
and
of
course,
since
we
all
work
at
get
lab,
we're
very
much
a
fan
of
centralized
servers
that
help
people
collaborate.
It
doesn't
necessarily
need
to
be
that
way
and
get
actually
has
a
copy
of
everything
on
everyone's
computer.
A
A
They
can
make
changes
kind
of
on
their
own
kind
of
down
their
own
path
without
a
really
heavyweight
way
to
get
back
in
to
the
main
path,
and
so
that's
kind
of
what
get
enables
and
so
digging
a
little
like
a
mile
deeper
into
what
git
is.
The
other
thing
is:
is
it's
an
open-source
tool
so
get
right,
the
get
in
get
lab
or
github.
A
You
know
talks
about
the
open
source
tool
get
which
both
you
know
both
of
our
companies
were
kind
of
based
around
there's
a
couple
other
companies
that
have
get
solutions
as
well,
and
so
the
fact
that
it's
open
source
means
all
those
companies
are
contributing
to
get
and
and
changes
around
it
and
anybody
that
wants
to
use
it
can
use
it
without
you
know,
without
going
to
a
company
to
get
get
I'm
gonna,
try
not
to
say
get
kid
again.
Okay,
the
other
thing
is
okay.
A
We
talked
about
distributed
versus,
centralized
right,
it's
a
distributed
system,
it
can
it
records
every
change
and
the
whole
history
of
every
file.
That's
ever
changed,
and
it
has
a
very
simple
and
lightweight
branching
workflow.
So
when
I
say
light-weight,
branching
workflow,
what
I
mean
is
it
doesn't
take?
It
doesn't
actually
copy
the
whole
repository
every
time,
I
make
a
branch
and
want
to
propose
a
change.
It
only
actually
notates
the
changes
I'm
making
right.
A
So
that
makes
it
super
easy
to
have
lots
and
lots
of
branches
versus
some
older
source
control
systems
would
say:
oh
you
want
to
make
a
change.
Brendon.
Okay,
here's
a
whole
copy
of
everything
and,
and
every
time
you
make
a
change,
we're
gonna
make
another
copy
of
it.
Get
is
very
lightweight
and
a
lot
faster
because
it
only
is
notating
in
the
background,
the
changes
and
that's
able
to
then
compile
into
okay.
This
is
the
current
state
of
a
given
file.
Then
it's
also
can
be
used
in
the
command
line.
A
We'll
talk
about
that
a
little
bit
today.
It
also
had
there's
also
a
number
of
native
applications
like
and
when
I
say
native
application,
I
mean
an
application.
That's
made
to
run
on
your
computer
to
interact
with
git,
so
there's
a
few
of
those
out
there.
There's
some
that
are
associated
with
companies
like
github
has
one
called
github
desktop
and
there's
some
that
are
independent
from
any
of
the
gate.
A
Companies
like
tower
forget
and
then
there's
also
web-based
app,
so
github
get
lab
those
things
that
that
enable
get,
but
you
know
I
kind
of
have
a
web-based
front-end
alright.
So
let's
start
about
talk
about
starting
out
so
I
think
we
I
sent
this
all
to
you
but
ahead
of
time.
But
if
not
now
is
your
time
to
go,
install
git
and
for
those
of
you
that
might
be
watching
I
include
this
as
well,
so
there's
a
different
way
to
install
it
depending
on
which
operating
system
you're
running
on
your
computer
here
get
lab.
A
We
all
run
Mac,
so
you
may
have
get
installed
already.
If
not,
it
should
magically
prompt
you
to
install
it
when
you
type
git
and
hit
enter
and
oh
in
a
terminal
window.
So
if
you
don't
know
how
to
open
a
terminal,
the
quickest
way
I'd
know
to
do
it
is
to
hit
command
space
which
brings
up
spotlight,
search
and
then
I
type
terminal.
That's
how
I
still
do
it
to
today.
A
There's
probably
some
way
to
get
to
it
through,
like
the
Applications
folder,
but
I'm
lazy,
and
just
want
to
do
that,
and
so
now,
let's
talk
about
some
of
the
concepts
around
get
so
I
made
this
very
complicated,
actually
very
simplified
diagram
and
then
we're
gonna
look
at
a
more
complex
version
of
this.
So
again
the
concept
of
get
is
you
just
have
a
folder
of
files
right
so,
on
the
left
hand,
side
we've
got
our
computer
on
that
computer.
We
have
a
folder
full
of
text
files
right
for
lack
of
a
better
word
right.
A
There
might
be
HTML,
there
might
be
JavaScript,
there
might
be
some
other
programming
language,
but
in
the
end
it's
text
for
the
most
part,
maybe
there's
some
images
but
again
Morgan
or
those
for
now,
and
that
folder
is
where
I'm
gonna
be
making
my
changes
and
that
folder
then
has
within
it
what's
called
the
local
repository.
So
in
a
in
a
hidden
folder
inside
that
folder,
it's
keeping
track
of
all
of
the
changes
I'm
making
automatically
and
comparing
those
to
what's
been
added
to
the
repository
already
like.
What's
the
latest
state
of
the
repository
versus?
A
What's
in
my
folder
and
then
my
folder
is
called
the
workspace
and
then
my
local
repository
is
called
the
local
repository.
So
when
I
make
a
change
and
I
decide,
I
want
to
move
forward
with
it.
I'm
gonna
put
it
in
my
local
repository
and
then
I'm,
probably
gonna
do
what's
called
pushing
it
again.
We're
gonna
go
into
more
detail
in
another
slide
here
to
the
remote
repository.
A
So
when
we
say
remote
repository
again,
that
typically
refers
to
a
git
server
like
get
lab
or
github,
but
it
could
be
a
native
get
remote
repository
so
again,
get
itself
can
host
this
as
a
little
more
command
line.
Driven
doesn't
have
a
nice
doesn't
have
as
nice
of
a
pretty
interface
as
as
the
other
gate,
companies
do
and
then
other
folks
are
gonna
have
their
own
entire
copy
of
everything
in
the
repository.
A
So
even
if
I've
got
something,
that's
a
work
in
progress
that
I'm
pushing
up
to
my
remote
repository
other
people
can
look
at
it.
So
if
Emily
is
working
on
something
or
or
stuck
on
something
she
can
push
it
up
to
get
lab
and
I
can
actually
pull
it
down
and
have
everything
that
she
has
changed
and
committed
up
into
that
point
on
my
computer
and
how
about
maybe
so
to
kind
of
go
a
mile
deeper
into
that.
A
Let's
talk
about
this,
so
here
we
have
those
kind
of
four
areas
I
was
talking
about
before
so,
but
but
there's
actually
a
middle
area
here
called
staging
area.
So
let's
talk
about
that
so
working
directory
right
that,
on
the
left
hand,
side
is
just
my
local
file
system
right,
my
local
set
of
files
and
then
let's
skip
skating
for
a
second
local
repo,
is
what
I
was
just
talking
about.
That's
a
local
repository
and
then
remote
repository,
remote
repo.
A
A
It
suggested
change
to
it
when
I
start
by
doing
what's
called
a
clone
and
a
check
out
and
so
clone
will
bring
the
entire
repository
again
all
of
the
history
of
every
change
ever
down
to
my
computer
and
then
check
out
we'll
check
out
a
specific
version
of
that.
So
typically
there's
a
mainline
kind
of
branch.
Traditionally,
that's
called
the
master
branch
and
get
and
get
in
general,
and
so
that
branch
is
kind
of
like
this
is
the
production
version
of
the
website,
for
instance.
A
So
normally,
when
I
do
a
clone,
it
actually
does
a
clone
and
check
out
in
one
step.
But
it's
it's
good
to
kind
of
understand
the
difference
clone
has
given
me.
The
whole
repository
check
out
is
bring
me
to
a
specific
branch
or
let's
say
that
I
had
just
have
a
new
folder
that
I
want
to
start
source
controlling
with.
B
A
So
I've
got
a
folder
I've
got
some
files
in
it.
Maybe
and
I
love
get
so
much
that
I
want
to
add,
get
to
it
or
I
want
to
collaborate
with
someone
on
it.
So
I
want
to
add,
get
to
it
if
I
say
get
an
it
in
a
folder
that
hasn't
had
get
before.
That's
gonna
create
a
new
empty
local
repository
for
me
to
use
so
again.
I
could
use
that
completely
on
my
computer
and
do
my
own
source
control
locally,
but
that's
how
you
can
kind
of
start
from
okay.
A
I've
got
something
on
add
it
to
get
so
from
there
again.
It's
not
you're
not
doing
anything
that
different
than
just
changing
what
you
want
to
change
so
I'm
changing
things,
and
that's
changing,
of
course,
my
working
directory
right,
so
the
working
directory
again
just
the
directory
on
my
computer
as
I'm
saving
files
to
that
it's
making
changes.
I
can
then
say
and
there's
a
missing
command
here.
I
can
say
get
status
and
when
I
run
get
status,
it's
going
to
compare
the
local
repository.
A
The
most
recent
commit
to
the
local
repository
to
what's
in
my
working
directory
and
show
me
what
I've
changed.
What's
different,
then
there's
this
concept
of
a
staging
area
when
I'm
like
when
I'm
ready
to
commit
some
or
all
of
those
changes,
I
say
get
add,
and
that
adds
them
just
to
kind
of
a
you
know:
a
conceptual
staging
area
before
I've
committed
all
of
them,
so
I
can
decide
to
add
some
or
all
of
those
things.
A
I'm
changed,
maybe
I'm
done
with
two
of
the
files,
but
I
don't
want
to
add
the
third,
so
I
choose
which
ones
I
add
and
then
commit
just
basically
takes
a
snapshot
of
the
files
as
they
exist
at
that
time.
All
right
so
and
and
puts
that
in
our
local
repository.
So
again
it
doesn't
have
to
necessarily
be,
and
normally
shouldn't
be,
a
finished
product.
A
A
That's
gonna
change
a
bunch
of
stuff,
so
I
want
to
take
a
take,
a
snapshot
now
and
then
I
can
send
it
to
my
remote
repository
would
get
pushed
so
that's
kind
of
that
add
commit
push,
is
a
very
common
part
of
the
workflow
that
basically
takes
all
the
commits
of
my
local
repository
that
aren't
in
the
remote
repository
and
pushes
them
up
there.
So
the
remote
repository
has
them.
Then
the
ink
kind
of
inverse
of
a
git
push
would
be
a
git
fetch.
So
this
would
be
hey.
A
Give
me
all
the
commits
that
are
in
the
remote
repository
that
aren't
in
my
local
repository
and
then
again.
I
can
check
out,
like
let's
say,
I
did
get
fetch
and
I
got
a
new
branch
of
Emily's
it
that
she
was
working
on,
I,
couldn't
say,
get
check
out,
Emily's
branch
and
that
would
change
my
working
directory
to
actually
be
her
branch,
not
whatever
I
had
been
working
on
and
then
at
the
very
end,
I
can
decide
to
merge
two
branches
together.
So
you'll
talk
about
merging
a
lot.
A
Gitlab
calls
it
in
the
user
interface
a
merge
request
before
get
lab,
existed,
github
existed
and
I
call
it
a
pull
request
but
they're
conceptually
the
same
thing
they're,
both
the
requesting
a
get
merge,
which
is
why
I,
like
our
name
better,
but
that's
a
different
story
and
when
you
do
a
git,
merge
it's
taking
two
branches
and
bringing
the
changes
from
the
one
branch
into
the
other
branch.
This
is
a
great
place
for
questions,
because
that
was
a
lot.
Does
any
of
that
make
sense.
A
A
Great,
so
that's
that's
a
lot
if
you,
if
you
get
this
mastered-
or
you
become
an
expert
at
this
rather
like
you're
you're,
ahead
of
the
curve
for
sure,
but
this
is
kind
of
a
great
overview
of
what
the
workflow
is
so
I.
There's
a
couple
other
terms,
I
wanted
to
talk
about
and
then
I
think
we'll
use
dive
right
into
to
actually
touching
files.
So
we
talk
I've,
said
branch.
A
couple
of
times
like
you
would
know
what
it
is,
but
should
probably
define
it.
A
You
know
a
branch
is
just
an
independent
line
of
development.
So
again,
there's
typically
kind
of
a
mainline
branch
like
it's
a
production
branch
them
again
traditionally
and
get
called
the
master
branch.
So
that's
where,
like
we
think
of
this,
is
the
code
that
we're
shipping
at
the
door.
Now
some
folks
have
more
complex
workflows
where
there
may
be
multiple
of
those
two
kinds
of
branches.
Maybe
I
have
different
branches
for
different
releases.
A
I
can
get
really
complicated,
it's
easier
to
think
of
it
in
kind
of
like
a
git
lab
flow
methodology
where
there's
one
kind
of
main
branch
and
then,
when
I
want
to
make
a
change.
My
branch
off
of
that
branch,
which
basically
just
means
hey
I,
want
to
make
a
copy
called
Brendan's
change
and
make
my
changes
on
that
branch.
So
I'm
not
making
changes
to
the
production
system
and
then
I'm
gonna
request
to
merge
that
branch.
Brendan's
branch
into
the
master
branch
and
then
similar
to
that
is
a
is,
what's
called
a
tag.
A
So
a
tag
basically
marks
a
specific
point
on
time
on
a
branch.
So
again,
let's
say
I'm
in
that
workflow,
where
there's
kind
of
one
main
branch
and
we
go
and
we
release
version
1.7
I
might
tag
that
point
in
time
and
that
branch
as
one
point
seven
and
now
I
know
I,
can
always
go
back
to
exactly
what
the
code
was
like
back
then
check
out
again
and
we
define
that
a
little
bit
earlier.
That's
hey
I
want
to
get
a
specific
branch
and
and
make
some
changes
to
it.
A
Commit
takes
your
changes
that
you
have
made
and
stage
and
adds
them
to.
The
repository
push
sends
those
changes,
the
remote
repository
and
then
again
workspace.
We
talked
about
it's
the
directory
on
Europe
on
your
computer,
where
the
repository
is
and
then
there's
a
couple
other
things
we've
talked
about,
some
of
them
untracked
files.
So
there
is
a
concept
of
like
I,
add
a
new
file.
It
doesn't
know
about
it,
yet
that
is
called
an
untracked
file.
A
Sometimes
that
means
oh,
hey,
I,
want
to
add
this
new
file
to
get
so
I
can
track
it,
but
there
also
are
some
files
that
you
might
not
want
to
track
so
like
if
I
have
a
file
that
contains,
like
secret
keys,
that
I'm
using
to
connect
to
some
server
I
might
not
want
to
commit
those-
or
you
know
it's
common
in
many
programming
languages
to
have
what's
called
a
package
manager
that
brings
in
other
open
source
packages,
and
then
you
only
want
to
commit
hey.
These
are
the
packages.
A
I
need
not
here's
all
of
the
files
from
all
the
package,
because
it
could
be
hundreds
of
thousands
of
files,
and
so
you
might
even
you
you
those
types
of
things
you
use.
What's
called
get
ignore
to
say:
hey
yeah.
This
is
in
the
folder,
but
don't
think
about
it.
Get
because
I
don't
want
you
to
commit
it,
the
working
areas
or
any
files
that
have
been
changed,
but
not
committed.
So
anytime,
I
change,
something
in
my
folder.
A
It's
called
it's
a
change
in
the
working
area,
the
staging
area,
then
our
files
that
I've
modified
or
added
and
I've
marked
hey
next
time,
I
commit
them.
Add
these
changes
to
the
repository
local
repository
again
will
say
repo
some
time
to
be
short,
is
the
local
copy
of
your
entire
upstream
repository?
So
upstream
is
another
term
you
might
hear
for
a
remote
repository
and
that's
a
hoster
repository
typically
on
a
shared
server
like
get
lab
and
that's
the
same
I'm
going
on
wrong
direction,
which
will
do
that
every
time
and
that's
it?
A
A
B
A
A
Awesome,
okay,
cool,
so
I'm
gonna
get
a
repository
up
and
I'm
gonna
get
that
diagram
up
so
that
I
don't
lie
and
go
away
that
I
haven't
and
okay.
So
let
me
share
my
screen
again
real
quick.
Please
stop
me
with
questions,
though,
because
this
is
the
unrehearsed
on
planned
part
of
this,
so
so
this
is
the
kind
of
thing
that
I'm
gonna
do
so
I'm
gonna
clone
an
existing
repository.
So
in
our
case,
a
repository
that
we
use
a
lot
of
get
lab.
A
Is
this
ww
get
lab
comm
repository,
so
here
I'm
on
get
lab
I'm
in
a
group
called
get
lab
comm.
So
we
can
see
this
up
at
my
bar.
You
probably
can't
see
it
on
the
video
at
all,
but
I
can
zoom
in
here
so
get
lab
as
a
remote.
Has
the
concept
of
groups
so
I'm
in
a
group
called
get
lab
comm
that
basically
is
get
lab
commercial
there's?
Also
a
get
lab
org
where
we
store
our
open
source
code
like
forget,
lab
itself
and
then
WW
get
lab.
A
Comm
is
our
way
of
saying
this.
Is
our
website
right?
So,
if
I
go
to,
if
I'm,
not
logged
in
to
get
lab
and
I
go
to
get
lab,
comm
I
get
this
right
our
marketing
website,
so
you
can
see
when
I
come
I
log
in
I'm.
Actually
a
member
of
this
repository
so
I
can
clone
it
directly.
If
I
wasn't,
I
could
make
a
what's
called
a
fork
of
it.
A
Forking
is
not
a
workflow
that
we
talk
about
a
lot
of
good
lab
because
we
like
the
concept
of
everyone
contributing
on
branches,
but
for
kinas
our
workflow.
You
hear
a
lot
about
on
github
because
it's
some
open-source
tool
and
we
don't
want
a
bunch
of
people
that
may
not
be
in
our
organization
committing
all
over
the
place.
So
we
might
say:
okay,
you
fork
it
to
your
own.
A
fork
is
like
an
entire
copy
of
the
remote
repository.
A
So
we
talked
about
the
local
repository
to
be
an
entire
copy
of
the
remote
forking
would
be
on
the
remote
make
me
a
whole
nother
copy
of
this
repository.
That's
just
a
quick
thing
on
forking
sorry,
but
I'm,
just
gonna
clone!
So
here
you
can
see.
I've
got
two
options:
I
can
clone
with
HTTP
or
SSH,
so
there's
just
different
ways
of
authenticating
to
get
lab
or
I
get
remote
in
general.
This
works
for
github
as
well.
A
A
A
There's
this
key
pair
called
ID
RSA,
an
ID
RS
a
pub,
and
so
that
uniquely
identifies
my
computer
and
then
my
ID
underscore
RSA
is
what's
called
a
private
key.
So
that's
something
I'll
never
share
with
anyone
ever,
but
the
public
key
I
can
share
with
everyone,
and
so
this
is
the
public
key.
That's
on
my
gate,
lab
profile
and
then,
when
I
do
an
says,
H
command
to
ask
it
lab
for
something
that
knows
that
I'm
Brendon
and
lets
me
pull
it
down.
A
So
again,
this
is
just
the
directory
that
I
want.
My
repository,
live
in,
so
I'm
gonna
say
get
cloned
and
then
I'm
just
gonna
paste
this.
This
button,
I
didn't
explain
this
button
copied
that
URL
to
my
clipboard
and
I'm,
just
gonna
hit
command
V
to
paste
it.
So
that's
gonna
go
out
and
get
the
whole
err
buzzer.
It's.
A
Images
and
all
kinds
of
other
fun
marketing
stuff
didn't
pick
the
great
repository
to
start
with,
because
it's
big,
but
you
can
see
it's
taking
it's
bringing
down
all
of
these
objects.
So
it's
doing
a
lot
of
work
because
I'm
actually
getting
the
entire
history
of
the
gate
lab
website
ever
right.
So
every
blog
post,
every
image-
that's
ever
existed
all
of
that's
coming
out
of
my
computer.
So
that
seems
like
a
crazy
thing
like.
Why
would
you
want
all
that
Brendon?
A
Well
again,
it
gives
me
the
benefit
of
being
able
to
look
at
at
any
point
in
time
on
my
local
computer
and
the
news
get
the
newest
versions
of
get
support.
What's
called
a
partial
clone
or
I,
don't
have
to
clone
the
entire
thing
if
I
don't
want
to
which
like
for
our
website
would
make
sense.
I
don't
only
need
the
most
recent
few
changes.
I
don't
need
everything
and
in
true
Julius,
Child's
fashion,
I'm,
just
gonna
open
the
oven.
That
already
has
the
cook
turkey
in
it,
because
I
have
a
repository
right
here.
A
So
here
I
have
my
WW
get
lab
comm
repository.
So
again,
this
is
the
whole
copy
of
the
repository.
Now
this
one
isn't
updated
right.
So
here
we'll
look
at
something
different,
so
the
last
time
I
updated.
This
was
I'm
not
sure
when,
but
I
want
to
pull
all
of
the
changes
from
the
last
time,
I
updated
it
to
now
so
I'm
going
to
say,
git
pull
and
that's
gonna
be
a
lot
faster
process.
A
A
A
That
exists
on
the
current
master
version
of
the
get
lab
web
page
once
it's
done,
it
is
done
great
and
so
I
can
go,
make
a
change.
So,
for
instance,
maybe
I
want
to
change
my
bio
and
I
happen
to
know
where
that
is
you
know
it's
a
math
like
I
said
lots
and
lots
of
text
files.
So
half
the
battle
is
knowing
where
something
is.
Did
you
want
to
change,
but
I
know
that
Brendan's
right
here
and
I
might
want
to
say
change.
My.
A
So
maybe
I
want
to
say,
burn
as
a
passion
for
software
development
and
get
or
get
and
it
or
and
process
right.
So
now,
I've
just
suggested
this
change
where
I'm
gonna
add
three
things
in
a
list
which
is
better
than
two
and
I'm:
gonna
hit
click
Save,
and
so
now,
if
I
go
I'm
going
to
show
you
two
places
one
and
the
command-line.
If
I
say
get
status,
will
see
up.
A
A
They
also
integrate
with
get
so.
You
can
see
here
this
lit
this
little
guy
lit
up
this
little
person
friend
lit
up
when
I
made
a
change
and
if
I
click
on
that
I
actually
get
a
visual
view
of
the
difference.
So
many
many
IDs
allow
me
to
do
that
and
then
I
can
commit
from
here,
but
on
the
command
line.
I
would
say,
get
add
and
I
can
say
period
to
add
every
change
that
I've
made
right.
So
this
would
be
if
I
made
more
than
one
change.
I
could
add.
A
A
You
can
see
it
gave
me
this
crazy
hash
thing.
That's
the
thing
that
uniquely
identifies
that
commit
and
I
can
say,
get
push
and
it's
going
to
go
up
to
the
gate,
lab
server
and
push
that
this
new
branch
to
get
lab
server
and
then
many
get
servers
then
will
let
you
create
the
merge
request
or
the
pull
request
r/a
from
there
and
get
labs
not
alone
in
that.
A
A
A
Yeah,
no,
it
could
be
pretty
intimidating
at
first,
but
you
know
it's
again:
you
have
to
have
something
you
want
to
do
step.
One
step.
Two
is
just
know
that
you
can't
break
anything
the
beauty
of
git.
Is
you
can't
like
the
way
it's
designed
you?
Even
if
you
broke
everything
you
can't
break
everything
right
like
the
worst
that
you
could
possibly
do
is
make
a
change.
The
website
that
breaks
the
entire
website
a
we
use,
git
lab
CI,
so
that
won't
even
get
pushed
live
right.
A
A
It's
not
exactly
there's
a
family-friendly
version.
Dang
it
get
is
the
family-friendly
version
of
it.
There's
there's
a
less
family-friendly
version,
that's
easier
to
remember
but
harder
to
put
in
the
video
when
you're
going
to
publish
it.
That
shows
you
how
you
can
like.
Oh,
if
I
committed
something
and
realize
I
needed
to
make
a
small
change.
Oh
guess
what
you
can
amend
the
commits
can
make
an
amendment.
Oh,
no
I
made
a
commitment
to
put
a
message
in
up
again.
You
can
amend
it.
Oh
no
I
committed
something
on
master.
A
Instead
of
my
new
branch,
good
news,
you
can
fix
it,
I
committed
to
the
any
of
the
wrong
branches.
Well,
here's
the
commands
to
fix
it
and
what
else
you
need
to
undo
a
commit
from
five
days
ago.
I
need
undo
the
changes
I
made
to
a
specific
file,
and
then
the
best
is
forget
all
this
I
give
up,
which
is
just
delete
the
file
and
folder
and
start
again,
which
is
not
unheard
of
and
get
so.
Yes,
it
is
a
magical
time
machine.