►
Description
In this edition of Labs and Latte, Matt dives into Part 3 of our "Introduction to Git" series, which covers the use of Git branches to parallelize your work and incorporate work from others.
If you want to follow along, you can play with this lesson right now at https://go.nrelabs.io/labs/?lessonSlug=git-version-control&lessonStage=2
Introduction to Git Series:
- Part 1 - https://www.youtube.com/watch?v=YAXWxA4x8vs
- Part 2 - https://www.youtube.com/watch?v=b203WRT_hIg
- Part 3 - https://www.youtube.com/watch?v=mOj7kCfu7TY
- Part 4 - https://www.youtube.com/watch?v=qOmQzUR5t0E
- Part 5 - https://www.youtube.com/watch?v=Bqtk0wpgl4A
A
Hello
and
welcome
to
labs
in
latte
a
show
where
we
dive
into
the
energy
Labs
curriculum,
while
sipping
on
our
favorite
bean
based
beverage
and
I
have
another
latte
here
today,
I
kept
it
simple,
because
we're
sort
of
dealing
with
a
global
pandemic
right
now
so
I'm
not
trying
to
reinvent
any
wheels
but
I
I'm
sort
of
practicing
my
latte
art
and
getting
better
at
the
craft.
You
know
it's
funny:
lots
of
art
is
actually
I,
don't
want
to
call
it
difficult
because
it
it
ends
up
being.
It
ends
up
being
a
pretty
simple
exercise.
A
Once
you
understand
the
fundamentals
of
frothing,
milk
and
and
various
other
things,
but
man,
it
took
me
a
long
time
to
get
to
that
point.
It's
kind
of
like
anything
else,
simple
is
actually
kind
of
hard
to
achieve
and
and
ya
know,
I.
Obviously
I'm,
no
artist,
but
it
is.
It
is
nice
now
that
I
can
consistently
at
least
build
like
a
little
tulip
or
something
simple
like
that.
A
It
took
a
long
time
to
get
to
that
point,
though,
because
there's
a
whole
bunch
of
things
you
have
to
that,
have
to
be
right
about
the
way
you
froth
the
milk
and
all
kinds
of
different
things
like
that.
Otherwise
it
just
doesn't
work
but
yeah
a
little
quick
note.
We
are
dealing
with
a
corona
virus
pandemic
right
now,
so
I
am
taking
the
opportunity
to
get
out
some
additional
get
content
and
today
we're
going
to
be
looking
at
part
three
of
the
get
get
series
that
we've
been
dealing
with
thus
far.
A
What
we're
gonna
be
doing
now
is
sort
of
going
beyond
that
into
the
realm
of
of
a
little
bit
of
multitasking.
Now
this
multitasking
may
just
be
multitasking
yourself,
so
like
if
you're
working
on
two
different
sort
of
aspects
of
your
git
repository,
whether
it's
you
know
maybe
you're,
storing
Network
configurations,
and
you
have
50
devices
in
in
that
repository
their
configurations,
rather
in
in
that
repository.
Maybe
you
don't
need
to
work
on
them
sequentially.
A
You
can
work
on
them
independently
if
they,
if
those
changes,
don't
impact
each
other,
and
you
can
use
branches
to
effectively
isolate
that
work
so
that
they,
you
know,
you
can
core
to
sort
of
work
on
those
things
independently,
while
still
maintaining
the
advantage
of
using
git
for
version
control
all
along
the
way,
and
then
what
you
can
do
is
you
can
reconverge
that
work
once
they're
done?
That's
sort
of
one
of
the
canonical
use
cases
of
git
branching
is
basically
like
I
have
a
piece
of
work
that
I
want
to
that.
A
I
want
to
do,
and
you
know
master.
The
the
master
branch
is
kind
of.
The
idea
of
this
is
sort
of
like
the
golden
copy
of
the
repo
it's
sort
of
its.
It
has
us.
It
has
a
special
status
when
you,
when
you
when
you,
when
you
look
at
most
repos
some
other
some
of
the
some
repos
use
a
different
branch
for
their
sort
of
their
main
branch,
but
most
get
brain.
A
Most
git
repos
used
master
as
their
like
main
branch,
and
the
idea
is
there
that
that,
what's
in
master,
is
sort
of
quote
stable,
or
at
least
it's
more
stable
than
some
of
the
other
branches,
and
so
what
you
do
is
you
do
the
work
in
those
branches
and
then,
when
you're
done
with
that
work
that
work
gets
merged
back
in,
sometimes
it
doesn't
sometimes
they're
there
plenty
of
use
cases
where
those
branches
don't
get
merged
back
in.
So
we're
gonna
be
talking
about
all
of
this
and
more
in
this
lesson.
A
The
first
thing
that
we
want
to
do
is
we
want
to
get
back
into
our
repository,
so
we'll
go
to
CD,
my
first
repo,
or
rather
we'll
CD
into
my
first
repo
get
status
just
to
see
where
we're
at,
and
you
can
see
we're
on
the
master
branch.
As
I
mentioned,
the
master
branch
is
basically
what
we've
been
working
on
thus
far.
A
It
is
the
main
branch,
if
you
do
nothing
with
branches,
you're
gonna
be
working
on
the
master
branch
and,
as
you
can
see,
our
working
tree
is
clean,
so
we
have
no
files
that
we
haven't
committed.
Yet
or
untracked
files,
all
of
that
stuff
is
all
that
stuff
is
pretty
vanilla.
Now,
if
we
scroll
down
in
the
lesson
guide,
you
can
see
a
little
bit
of
a
back
story
that
was
written
to
sort
of
give
an
example,
so
I'll
sort
of
retell
that
story
a
little
bit.
A
The
idea
here
is
we're
using
git
to
manage
a
change
to
a
network
configuration
and
so
in
this
example,
we've
opened
a
ticket
with
our
Change
review
board.
Our
change
review
board
is
is
very
friendly
with
git,
because
we
live
in
a
magical
universe,
where
that's
true,
I
being
a
little
bit
facetious
I'm
sure
that
the
times
have
changed
in
recent
years,
but
when
I
was
doing
this
change
review
boards
were
not
gets
heavy
and
we've
been
assigned
a
change
idea
of
one
to
three.
A
We've
already
started
using
git
to
track
changes
to
our
configurations,
and
so
what
we're
gonna
do
is
we're.
Gonna
use
this
change
ID
for
tracking
purposes,
just
to
keep
everything
sort
of
obvious,
and
so
what
we'll
do
is
we'll
create
a
branch
and
on
that
branch
we
will
do
our
work
and
effectively
that
work
will
represent.
It
in
git
will
actually
make
commits
on
that
branch.
A
And
that's
what
we'll
tell
the
change
review
board
that
we
want
to
commit,
or
and
and
and
and
merge
back
to
master
eventually
once
it's
approved
and
what
we
can
do
is
run
git
checkout
and
we'll
do
the
dash
B
flag?
That's
a
it's!
A
sort
of
a
shorthand
there's
as
I
mentioned
I.
Think
in
the
last
video
there
are
many
commands
and
get
that
are
actually
aliases
for
other
commands.
This
is
sort
of
shorthand.
A
A
very
common
shorthand
for
hey
I
would
like
to
create
a
new
branch,
and
I
would
also
like
to
check
it
out.
Cuz
I'm
gonna
go
do
stuff
on
it
and
that's
what
get
check
out?
B
does
well
name
the
branch
change
one
two
three
again,
because
that's
sort
of
the
ID
that-
and
this
is
obviously
something
you
could
name
on
your
own-
but
we'll
name
it.
A
We've
used
that
before
we
use
that
to
do
things
like
you
know,
sort
of
revert,
a
change
back
to
what
was
already
previously
committed,
and
in
this
case,
what
we're
doing
is
we're
saying:
look
I
I
want
head
to
point
to
this
new
branch
that
I've
that
I'm
creating
simultaneously
with
the
B
flag,
and
so
that's
what's
taking
there,
okay.
So
for
change!
One
two,
three,
let's
say
we
want
to
change
the
IP
address
of
a
m3
from
10.30
1.0
at
11:00
to
10.30
1.0
to
twelve.
A
Now,
in
the
lesson
guide,
you'll
see
that
I
used
some.
Basically
so
I
call.
It
said,
Fuu,
it's
just
using
the
said
command
to
replace
text
within
the
text
file
and
the
main
reason
is
so
that
it
could
be
a
one-liner.
You
know
just
so
you
can
click
run
this
snippet.
If
you
don't
want
to
open
a
text,
editor,
not
everybody
is
comfortable
with
a
text
editor.
So
that's
the
option
that
I
give
I,
however,
am
comfortable
with
the
text.
Editor
like
VI
and
I
am
going
to
open
it.
A
So
interface
config
and
you
can
see
em3
is
currently
set
to
31
11
and
per
the
lesson
guide.
We'll
change
that
to
12
I
think
is
what
it
says:
right,
yeah
that
12
save
and
we
will
then
run
git
status.
You
can
see.
The
change
is
now
not
staged,
but
is
is
recognized
by
get
will
see.
Git
diff
to
see
the
actual
change
looks
like
it's
there,
that's
good,
okay!
So,
let's
commit
this
so
git
add
interface
config.
This
moves
just
to
review.
This
was
covered
in
the
last
section.
A
A
There
we
go,
we've
got
our
commit
ID.
We've
got
a
little
summary
where
we've
deleted
one
row
delete
deleted
one
line
and
inserted
one
line,
and
we
can
also
run
get
show
to
see
the
last
most
recent
commit.
We
can
see
that
the
diff
is
exactly
what
we
saw
prior
to
making
the
commitment,
so
everything
looks
great
now.
This
is
where
things
get
a
little
weird,
as
I
mentioned
it
is.
A
That
things
are
happening
outside
of
the
thing
you're
working
on,
and
you
need
to
be
prepared
to
sort
of
integrate
those
kind
of
changes
into
that
environment.
And
in
this
lesson,
what
I've
done
is
I
built
a
script
that
simulates
this
taking
place,
and
so
imagine
there's
this
co-worker
of
yours
named
Fred,
we're
gonna,
we're
gonna,
know
some
things
about
Fred
and
this
after
the
end
of
it.
By
the
end
of
this
video
he's
working
on
his
own
change
ticket,
we'll
call
it
number
one,
two
four
and
what
that
does.
A
Is
it
changes
the
IP
address
of
eeehm
for
remember,
we
changed
eeehm
three,
so
he's
changing
the
IP
address
of
am
four
and
he's
using
the
branch
change
one
to
four
to
do
it.
So,
let's
say
the
change
review
board
for
some
reason
like
spread
more
than
us,
and
so
his
change
gets
approved
for
four
hours.
Obviously,
there
were
some
under-the-table
dealings
going
on
money,
changed
hands,
we're
not
gonna,
ask
questions,
but
that's
what
happened
now?
A
What
we?
What
I,
like
I,
said
what
I
did
was
I
wrote
a
script
to
basically
simulate
this
taking
place
and,
of
course,
if
you
feel
like
you
want
to
take
a
bleep,
take
a
peek
at
this
script
and
see
how
I
did
it
please
feel
free?
It's
not
really.
The
point
of
this
lesson
so
I'll
sort
of
just
run
it
and
we'll
for
now
trust
that
it
did
what
we
think
it
will
do
so
what's
happening.
What
happened
in
this
script
is
Fred
effectively
had
his
own
branch
merged
into
master.
A
They
have
commits
master
branch
has
commits
because
of
Fred's
branch
that
we
don't
have,
and
so
now
we
have
this
mismatch
and
what
we
want
to
do
is
we
want
to
catch
our
branch
up
effectively.
We
want
to
tell
our
branch:
hey.
There
are
commits
on
the
master
branch
that
you
don't
have
bring
them
in
now.
This
is
usually
okay,
because
again,
our
branch
is
still
considered
sort
of
a
work
in
progress.
We
haven't
merged
it
back
into
master
and
so
pulling
commits
into
our
branch
is
fine.
It's
that
room.
A
It's
that
final
merge
of
our
commits
back
into
master
that
needs
to
be
approved.
This
is
actually
fairly
common
in
the
world
of
software
development,
in
things
like
pull,
request,
reviews
and
things
like
that,
where
you
can
do
whatever
you
want
in
your
branch,
but
before
you
pull
it
back
into
master
and
that
by
the
way,
that's
where
the
term
pull
request
comes
from
I'm
requesting
that
people
pull
my
code
into
their
repository
and
in
their
master
branch,
so,
basically
I.
A
You
know
that
act
of
merging
back
into
master
is
sort
of
that
that
last
step,
it
needs
to
be
sort
of
vetted
either
through
tests
or
through
code
reviews,
or
preferably
both,
and
the
same
is
true
in
in
this
environment,
where
we
are
having
a
Change
review
board,
approve
the
changes
that
we're
making,
hopefully
that
wasn't
too
confusing.
Now
the
cool
thing
is,
we
ran
the
diff
command
in
the
last
exercise,
I'm
actually
sitting
my
coffee,
because
I
haven't
yet
and
I'm
starting
to
need
it.
A
I'm
kind
of
too
good
at
this
random
self,
high
five
Wow,
so
git
diff
master,
chained
one
two,
three
yeah,
so
git
diff,
is
a
command
that
we
ran
in
the
last
video
to
compare
the
difference
between
the
current
version
of
a
file
and
the
file,
and
the
version
that
we
had
previously
committed
but
get
diff
can
actually
receive
a
lot
of
different
arguments,
and
in
this
case,
what
we're
doing
is
actually
comparing
entire
branches.
And
so,
if
we
run
this,
this,
this
command
here
get
diff
master
change
book
to
three.
A
However,
many
there
are
and
aggregate
them
together
for
me
and
show
me
just
the
full
diff
between
the
two
branches
as
a
whole
and
as
you
can
see,
our
change
is
still
there
because,
obviously
that's
the
commit
that
we've
made
that
master
doesn't
have,
but
the
change
to
e
m4,
which
Fred
made
and
and
made
some
visit
under
under
the
table
business
dealings
to
get
his
change
merged
is
also
in
there.
And
so
that's
what
I
mean
when
I
say
we
have
a
commit
that
master
doesn't
have
and
then
also
vice
versa.
A
So
we
can't
do
anything
about
our
change
because
again
we
don't
want
to
merge
that
yet
it's
not
approved,
but
we
can
bring
our
come
Fred
zku
MIT,
rather
into
our
branch
fairly.
Simply
now.
The
way
we
do
that
is,
we
say,
git
merge
master,
and
this
should
be
it
because
we're
actually,
we
actually
checked
out
change
one
two
three
already
and
let's
just
verify
that
just
to
be
sure
get
status,
get
priority
on
this
champ.
A
A
Think
I
mentioned
this
in
the
last
video
you'll
find
that
by
providing
the
M
flag,
you
can
sort
of
override
gits
need
to
open
a
text
editor
because
you're
providing
the
text
and
it's
asking
for
basically
inline
that
works
for
a
lot
of
commands
commit
it
commit
as
one
of
them
get
merges
another.
It's
gonna
ask
you
for
a
effectively
a
commit
message,
because
that's
what
it's
doing
when
you're
doing
a
merge,
what
you're
doing
is
you're
creating
something
called
a
merge,
commit
and
so
you're
you.
A
A
So
I'm
not
here
to
start
a
flame
or
we
will
do
control
X
to
save,
and
you
can
see
that
that
makes
the
merge
commitment,
cool
and
then
finally
yeah.
Let's
do
another
diff
on
the
on
the
branches.
I'll
just
do
up
above
a
few
times,
and
you
can
see
now.
The
diff
only
shows
the
changes
that
we've
made.
So
again
we
haven't
merged
our
branch
into
master,
but
we
have
merged
master
into
our
branch.
If
that,
if
that
makes
sense,
the
commits
that
master
had
that
we
didn't
yeah.
A
A
It
works
on
changes
to
files,
and
so,
if
you're
making
chain,
if
two
people
are
making
changes
to
the
same
file
as
long
as
it's
to
effectively
two
different
parts
of
the
file,
it's
actually
intelligent
enough
to
be
able
to
just
resolve
that.
Just
fine
doesn't
really
matter
cuz.
It
only
works
on
sort
of
those
localized
changes,
and
so
even
though
Fred
made
a
change
to
the
same
file,
it
was
to
a
different
interface
and
therefore
both
of
those
changes
could
get
merged.
A
Just
fine
in
this
case,
however,
excuse
me
in
this
case,
however,
fred
is
making
change
to
em3.
We
don't
know
why
Fred
does
what
he
does
he's
clearly,
a
malicious
insider
threat
that
we
need
to
get
rid
of,
but
in
the
meantime,
let's
just
deal
with
him
and
in
the
in
the
world
of
get
again,
I
wrote
a
script
to
simulate
this.
A
If
you
want
to
take
a
peek
at
what
is
going
on
in
the
script,
feel
free,
but
it's
basically
a
simulation
of
what
I
just
described
fred
is
making
changes
to
the
file
into
the
into
the
same
interface
line
that
we've
been
making
changes
to
and
committing
them
and
then
merging
them
because
again
he's
paying
the
change
of
view
board.
It's
an
imaginary
scenario:
don't
don't
hate
on
it
too
much
okay,
so
we
of
course,
are
busy
working
on
our
own
change
so
before
we
just
like
before
what
we
do.
A
Is
we
see
that
there
are
new
commits
on
the
master
branch
that
we
don't
have,
and
so
we
play
catch-up
once
more,
just
like
we
did
five
seconds
ago,
we'll
do
git,
merge
and
again,
we'll
make
sure
we
read
on
the
same
branch
change
one
to
three
excellent,
so
we'll
do
git,
merge
master
change,
one
two!
Three!
A
Actually
you
don't
need
to
have
that
second
branch
in
there
again
you
just
as
long
as
you
have
git.
As
long
as
you
have
the
one
to
three
branch
checked
out,
then
you
can
just
run
git
merge,
master,
okay
and
you
can
see
it's
not
even
prompting
us
with
the
with
the
commit
message
because
it
actually
ran
into
a
conflict,
and
this
is
where
we
run
into
something
that
is
probably
one
of
the
scarier
terms
in
the
world
of
git,
and
that
is
called
a
merge
conflict.
A
What
happened
is
that
get
is
you
know,
as
I
mentioned
before,
get
is
usually
very
intelligent
and
it
can
manage
sort
of
changes
to
the
same
file
as
long
as
they're
separate,
but
if
they
start
to
overlap,
that's
what
one
of
the
things
that
causes
a
merge
conflict
and,
as
you
can
see
in
the
text,
it
just
says:
hey.
We
have
a
merge
conflict
in
the
text,
file,
interface,
config,
dot,
txt.
A
Now,
if
you
scroll
down
on
the
lesson
guide,
you
can
see
a
snippet
of
what
git
does
to
a
file
to
indicate
a
merge
conflict.
What
it'll
do
is
it'll
actually
insert
these
sort
of
markers
into
the
into
the
body
of
a
of
it
of
a
file,
and
these
are
pretty
well
recognized
people,
people
sort
of
know,
people
that
are
familiar
with
git
know
to
look
for
these.
A
In
fact,
some
CI
pipelines
actually
check
for
these
because
it's
not
uncommon
to
finally
is
actually
in
code
or
other
text
files,
because
people
when
they
resolve
merge,
commit
merge
conflicts
which
we're
about
to
do.
They
forget
to
take
these
out,
and
so
these
are
pretty
recognizable
patterns.
The
idea
here
is
basically,
this
is
what
we
are.
A
This
is
what
the
change
that
we
saw
in
the
head
right
now,
which
is
the
branch
so
we've
checked
out,
and
here's
the
change
that
took
place
on
master
right
master
branch,
and
so
it's
basically
telling
us,
hey,
I,
don't
know
how
to
resolve
this.
One
of
you
know
basically,
the
you
know.
Two
changes
tried
to
change
the
same
line
and
I,
don't
know
which
one
I
should
pick
so
what
I'm
gonna
do
and
I'm
personifying
it
now
so
keep
static.
Try
to
keep
up
with
my
with
my
clearly
saying
ideas.
A
Basically,
I,
don't
know
how
to
resolve
these.
This
situation,
you've
made
you
made
the
same
change
or
we
made
two
different
changes
to
the
same
line,
but
I
want
to
you
know:
I,
don't
know
how
to
resolve
this.
So
that's
that's
understandable,
because
git
is
not
a
decision
maker.
It's
just
under
it's
just
telling
us
that
it
has
a
conflict,
so
it
inserts
this
whole
block
of
text
into
the
lesson
or
I'm
sorry
into
the
into
the
configuration
file,
and
it's
basically
waiting
on
us
to
resolve
this.
How
do
we
resolve
it?
A
Matt
good
question:
let
us
go
into
the
file
so
again:
VI
interface,
configs
man.
Oh
it's
totally!
Fine.
If
you
want
to
use
something
else,
also
totally
fine
and
you
can
see
yep
there
we
go
right
in
the
text
file.
You
can
see
that
it
has
those
three,
those
three
new
markers
and
you
can
see
that
the
address
line
is
repeated
because
again
it
doesn't
know
which
one
that
we
want
to
pick
now.
A
The
really
cool
thing
about
using
a
text
editor,
it's
not
in
the
browser
like
if
that's
not
in
the
the
terminal
here
like
if
you
were
using
vs
code,
for
instance,
and
I
resolved,
merge
conflicts
in
vs
code
all
the
time.
A
lot
of
those
modern
text.
Editors
will
give
you
sort
of
pointers
to
help
you
resolve
this
and
VI.
A
Does
the
same
thing
too,
by
the
way
you
just
need
plugins
for
it
that
I
don't
have
in
this
environment,
but
they
can
kind
of
tell
you
and
give
you
a
little
markers
that
you
can,
that
you
can
maybe
click
with
a
button,
and
it
does
this
for
you,
but
will
do
it
manually
for
now,
because
it's
not
a
big
deal.
The
change
here
is
address
one
two,
three
one,
two,
three
one,
two,
three
one,
two,
three,
that's
Fred's
change,
and
we
don't
want
that.
A
We
know
better
because
this
is
our
interface
and
IAM
force
in
his
interface.
And
so
basically,
what
we
want
to
do
is
overwrite
his
change
with
our
own
and
the
way
that
we
do.
That
is
by
simply
taking
out
that
section.
Don't
forget
the
markers.
It's
very
important,
so
address
one
two,
three
one,
two
three
one,
two
three
one,
two
three
and
then
all
the
markers
just
take
it
out
and
don't
forget
the
top
marker,
even
though
that's
the
that's
pointing
to
the
change
that
we
want.
A
This
is
not
valid,
Juno's
configuration,
and
so
we
don't
want
it
in
there
either.
So
we
then
save
the
file
and
then,
as
I
mentioned
in
the
in
the
lesson
guide,
if
you
scroll
down
and
again,
this
is
the
one
liner
to
do
what
we
just
did
if
you
want
to
use
that
instead
feel
free
but,
like
I
said,
I
want
to
use
the
text
editor.
Let's
do
get
status
to
see
where
we're
at
now
you'll.
As
you
see
in
the
output,
this
hasn't
actually
resolved
the
merge
conflict.
A
Really
all
we've
done
is
we've
just
edited
a
text
file.
We
haven't
told
get
about
what
we've
done
gets
not
automatically
watching
for
the
changes
and
then
taking
action
accordingly.
It
needs
us
to
tell
it
that
we've
resolved
it
basically,
and
so
what
it's
doing
here
is
it's
saying
you
know
fixed
caught,
it's
actually
giving
us
some
instructions,
fix
the
conflicts
and
then
run
git
commits.
Let's
do
that.
So,
let's
do
git,
add
interface
config
and
you
can
see
all
conflicts
fixed,
but
you
are
still
merging
again
haven't
made
the
commit
yet.
A
So,
let's
do
that
and
again,
if
you
look
at
the
the
snippet
here,
you
can
see
that
I'm
providing
the
message
in
line,
but
we'll
just
do
in
a
text.
Editor
merge,
Brants
master
in
to
change
one
two:
three:
let's!
Let's
actually
change
that,
because
I
do
like
the
message
that
I
had
in
the
snippet
resolve
merge
conflict
over
right,
fred's
change,
I,
don't
need,
quotes
cuz
I'm
in
the
editor.
Okay,
there
we
go
okay,
so
yeah.
Let's
do
git
log
one-line
just
to
see
where
we're
at
cool
so
change
one
to
four.
A
If
you'll
remember,
that
was
Fred's
original
change
that
would
didn't
cause
any
conflicts.
That
was
his
original
change.
That's
still
existing.
We
haven't
deleted
that
branch
or
Fred
hasn't
deleted.
That
branch.
You
could
say
you
can
see.
We
also
changed
the
IP
address
of
em3.
We
also
caught
our
branch
up
with
the
latest
commits
from
master.
You
can
see.
A
So
yeah,
that's
basically
what
took
place
over
the
last
couple
minutes
now.
The
last
thing
that
we
do
and
again
this
is
this
is
gonna
vary
based
on
the
platform,
as
I
mentioned,
if
you're
like
in
github
or
something
like
that
which
we'll
get
to
in
a
future
section,
there
are
actually
buttons.
You
can
click
to
do
what
we're
about
to
do.
But
the
good
news
is
you.
A
We
also
have
the
ability
to
just
simply
merge
the
branch
here
locally,
and
this
is
probably
something
that,
like
a
Change
review
board,
would
do
again,
maybe
not
via
the
command
line,
maybe
some
maybe
via
something
like
a
web
UI.
It's
not
uncommon
to
do
it
that
way,
but
at
the
end
of
the
day
web
UI
or
not,
it
still
boils
back
to
what
we're
about
to
do
on
the
Commandment.
So
if
we
do
get
checkout
master,
you
see
we're
on
the
master
branch.
Now
we'll
do
a
git
merge
change
one
to
three
again.
A
Remember
the
last
syntax
we
were
on,
we
had
change,
23
checked
out
and
we
said
git
merge
master.
What
that
meant
was
hey.
Give
me
the
commits
that
are
in
master
and
bring
them
into
my
branch.
Now
we're
doing
the
reverse.
Now
we're
saying
hey
change.
One
two
three
has
approved
the
change.
Review
Board
loves
it
they're
they're,
approving
that
we
bring
those
commits
into
the
master
branch,
and
so
we're
gonna
merge
those
commits
here.
So
we've
checked
out
master
branch
and
we
are
now
merging
changed
one
two
three
into
it.
A
Excellent
all
done,
except
our
branch,
still
exists.
Now,
there's
a
couple
ways:
you
can
do
this
I
like
to
use
the
of
the
lower
the
lowercase
D
flag,
forget
branch
I,
don't
think
I
mentioned
this
in
the
lesson
guide.
You
can
also
do
with
the
uppercase
D.
The
difference
here
is
that
if
you,
if
you
run
git
branch,
D
and
then
say
change
one
two
three,
what
it'll
do
is
it'll
actually
check
the
commits
in
that
branch
and,
if
any
art
already
on
master,
meaning
it's
not
fully
merged,
it
will
actually
reject
that.
A
So
it
so
it's
a
nice
way
to
protect
against
an
undesired
deletion
to
be
accidentally
deleted,
a
branch
that
has
work
that
you
didn't
merge.
It's
a
nice
protection
against
that.
Of
course,
you
can
override
that
with
the
high
of
the
uppercase
D,
which
is
not
uncommon.
If
you
wanted
to
just
get
rid
of
like
a
release
branch
or
something
like
that,
that's
very
old.
A
There
are
various
reasons
why
you
might
want
to
do
that,
but
I
would
say:
stick
with
the
lowercase
D,
because
it
does
protect
you
against
accidentally
deleting
a
branch
that
you
did,
that
you
didn't
want
to
delete.
Okay
and
yeah
we'll
run
that
yeah
deleted
branch
change,
one
two:
three:
okay,
so
yeah!
This
was
again
whirlwind
tour,
as
many
of
these
are
in
to
get
branching
I
hope
it
was
enjoyable.
A
I
hope
you
learn
something,
please
feel
free
to
check
out
entering
labs
if
you
go
to
any
labs
Daioh
we've
got
a
lot
of
lessons,
not
just
this
one,
and
if
you
want
to
go
to
this
particular
lesson
and
follow
along
again
the
links
in
the
description
and
I
encourage
you
do
that
until
next
time
keep
drinking
coffee
and
stay
safe
out
there
with
the
coronavirus
seriously.
It's
kind
of
scary
these
days,
but
you
know
what
we're
gonna
get
through
this
as
long
as
we
all
stay
home
so
be
safe.