►
Description
In this edition of Labs and Latte, Matt dives into Part 4 of our "Introduction to Git" series, which covers the tools Git offers to fix mistakes, such as committing sensitive information.
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=3
EDITORS NOTE: Yes, I realize my video is a bit big in this one and is obscuring the terminal. Will find a better size/position in future episodes.
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,
am
here
with
another
video
on
the
get
series,
so
we've
been
dealing
with
get
as
a
version
control
tool
and
we're
pretty
well
into
the
series.
Actually,
this
is
gonna
be
part.
Four
I
have
one
more
part
planned
for
now,
I,
don't
know
if
that'll
be
the
last
one,
but
I
think
I.
A
Is
it's
a
very
robust
and
powerful
tool,
and
so
making
mistakes
is
actually
not
unexpected
and
I
want
to
preface
this
by
saying
this
is
not
going
to
be
the
end.
This
lesson
doesn't
cover
all
the
mistakes
you
could
possibly
make
really.
It
covers
one
kind
of
particular
kind,
that's
very
common
and
that
is
accidentally
committing
sensitive
information
or
basically
committing
things
you
didn't
intend
on
committing.
So
let's
get
started,
let's
see
the
the
lesson
guide
here
and
if
you,
if
you
want
to
follow
along
the
link,
will
be
in
the
description.
A
So
please
use
that
link
and
you
can
see
in
the
lesson
guide.
We
start
off
by
making
a
new
change.
Let's,
let's
talk
about
adding
a
new
hostname
configuration
file
to
our
repository,
and
so
you
can
see
in
the
in
the
in
the
snippet
here
I'm
running,
entering
the
my
first
repo
directory,
which
we've
seen
in
the
previous
parts
and
then
I'm
also
doing
this
sort
of
cryptic
looking
a
cat
statement,
but
this
is
actually
fairly
simple.
Really
all
this
is
doing.
A
Is
it's
adding
the
text
that
you
see
highlighted
here
to
the
file
and
it's
creating
it,
because
the
double
carats
host,
name,
config,
txt
and
I'm-
just
gonna
run
this,
because
it's
a
lot
easier
to
do
that,
but
I'll
rerun
cat
on
that
file?
Just
you
can
see
the
the
contents
are
pretty
simple.
It's
just
those
three
lines,
and
this
is
a
simple
Juno's
configuration
for
setting
the
hostname
of
a
genus
device.
A
A
Again
it
is
a
very
powerful
tool
and
it's
very
robust,
but
you
get
into
this
flow
once
you've
learned
get
well
enough
to
be
comfortable
with
it
and
I
don't
mean
necessarily
like
at
a
really
deep
level,
but
once
you're
familiar
with
it
enough
that
it's
sort
of
like
it's
just
part
of
your
workflow,
you
just
kind
of
understand
the
commands.
You
need
to
write
you
get
into
this
rhythm
and
it's
any
start
to
sort
of
make
a
lot
of
these
assumptions
and
and
anytime
you
take
shortcuts
you.
A
You
run
the
risk
of
doing
what
we're
about
to
do
and
in
this
case
we're
we're
sort
of
in
that
flow
mode.
Right.
We're
like
we're
like
okay,
we're
just
like
you
know,
maybe
maybe
we
want
to
get
out
of
the
office.
Maybe
we
want
to
get
home
to
binge
Tiger
King,
sorry,
if
you're
watching
this
like
years
from
now,
that's
a
very
topical
reference
right
now.
A
It's
a
Netflix
series
that
just
came
out
haven't
even
seen
it,
but
everyone
in
the
world
is
talking
about
it,
so
I
figured
I
should
probably
watch
it
because
I
feel
left
out
at
the
moment.
So
let's
say
we
just
want
to
leave
the
office
and
work
we're
trying
to
get
home.
So
we
really
quick
really
quickly
a
run.
Git,
add
star
wildcard,
just
say:
look,
I
know
what
I'm
doing
I'm
just
gonna
get
at
everything.
That's
fine,
get
commit,
see,
I'm,
even
in
a
hurry
right
now,
so
I'm
making
typos
on
the
command
line.
A
A
So
just
just
to
sort
of
highlight,
we've
made
the
change
to
hostname
under
a
host
name
config,
but
we
we
see
that
there's
actually
two
files
changed
here
and
there's
this
file
called
credentials
txt
and
by
the
way
this
is
usually
not
the
point
at
which
I
feel
this
sort
of
guilty
feeling
or
oh
crap,
feeling
it's
usually
once
I've
pushed
it.
We
have
it
again.
A
We've
talked
about
get
remotes,
but
it's
usually
I,
usually
don't
catch
it
until
I've
actually
pushed
this
commit
to
an
upstream
repository
like
it
github
and
then
that's
when
I
really
feel
sick
to
my
stomach,
because
then
I'm,
like
oh
crap,
I,
not
only
committed
sensitive
information,
but
I
put
it
on
the
internet,
not
to
say
that
I've
ever
done
that
with
a
slack
token
before,
but
I've
done
that
with
a
slack
token
before
so
yeah.
This
is.
This
is
not
a
not
okay
but
but
I
think
there's
something
we
can
do
to
fix
this.
A
Let's
take
a
peek.
If
we
do
a
git
show
head,
we
can
see
that
the
contents
of
the
file
that
we
created
for
the
hostname
config
are
there,
but
also
aligned
with
a
super-secret
password,
which
is
literally
super
secret
password
in
this
file
called
credentials.
Txt
not
ideal,
not
ideal,
meaning
the
committing
of
the
change,
but
also
storing
your
password
in
an
encrypted
file,
build
whatever
that's
fine.
Let's
just
move
past
it,
it's
a
hypothetical
scenario
and
I'm
sort
of
churning
those
out
lately.
A
Now,
as
you
see
in
the
lesson
guide,
I
have
all
of
these
warnings
I'm
here
the
commands
that
we're
gonna
use
to
fix
this
can
be
very
powerful
because
they're
designed
to
literally
obliterate
history,
it's
kind
of
the
point
right
like
if
you've
committed,
if
you've
committed
sensitive
information
to
get
it's
not
enough
to
just
remove
that
content
from
the
fun.
You
know,
delete
the
file
and
then
make
another
commit,
because
the
history
is
still
there.
Anybody
that
knows
how
to
use
git
is
gonna
still
be
able
to.
A
Basically,
check
out
the
commits
that
you
made
that
we
made
here
to
actually
put
the
information
there
in
the
first
place
and
they'll
be
able
to
see
it
just
plainly,
so
it's
not
enough
to
just
under
it's
not
enough
to
just
make
a
new
commit.
We
literally
have
to
undo
what
we've
done.
We
literally
have
to
take
this
commit
and
delete
it
and
sort
of
go
back
in
time
as
it
were
now.
A
The
reason
I
give
a
warning
is
obviously
that's
desired
in
this
case,
because
that's
what
we
want
to
do,
we
want
to
get
rid
of
the
information,
but
one
of
the
I
think
safety
nets
of
using
git
is
that
history,
even
if
we
were
to
like
just
commit
a
whole
bunch
of
crap
into
a
repo
we
didn't
expect
and
and
get
it
into
like
a
broken
state.
There's
always
a
way
to
go
back
and
say:
okay,
let's,
let's
make
different
changes.
A
So
that's
why
I
give
this
warning
it's
it's
important
that
you
understand
what
these
commands
do
and
that
you're
only
effectively
erasing
the
history,
not
only
that
you
want
to
put
in
the
way
that
you
want,
because
there's
actually
different
ways
to
do
this,
so
the
command
that
we're
gonna
use
is
called
get
reset.
Basically,
what
we're
doing
is
we're
saying
I
want
to
reset
the
repository
back
to
this
commit.
A
So
everything
that's
happened
since
that
commit,
and
it
could
be
one
commit-
that's
happened
since
then
it
could
be
50
commits
I
still,
no
matter
what
I
want
to
go
back
to
this
one
commit
ID
and
and
effectively
reset
the
repository
back
to
that
state.
Now,
if
you
look
at
the
snippet
over
here
on
the
left
side
of
the
screen,
you
can
see
that
there's
a
that.
There
are
two
sort
of
set
of
parameters
that
I'm
providing
in
addition
to
this
command.
The
first
one
is
soft.
A
This
is
this
is
the
sort
of
the
the
lighter
touch
of
the
that's
the
safer
option?
If
you
want
to
use
this
because
what
this
does
it
still,
it
still
can
be
potentially
harmful
because
it's
still
erasing
commit,
but,
unlike
the
command
that
will
run
at
the
very
end,
it
takes
all
of
the
changes
that
were
in
the
commit
so
like.
If
you
were
in,
you
know,
commit
ABCDE
and
you
committed
information
and
say
like
D,
so
you
want
to
go
all
the
way
back
to
C.
A
A
So
you
lose
all
of
the
version
control
history,
because
again
the
commits
are
gone,
but
the
very
least
the
the
contents
of
the
files
are
still
there
in
staging
and
then
what
you
can
do
is
you
can
edit
staging
accordingly
and
then
make
a
new
commit
once
the
information
that
you
only
the
information
you
want
is
in
staging.
So
that's
what
we're
gonna
do
now.
The
second
parameter
that
you
see
here
is
head
Tildy
one.
A
It's
the
commit
that
we
made
where
we
added
the
host
name,
configuration
and
inadvertently
added
the
credentials
file,
and
so
what
we
want
to
do
actually
is
go
to
the
commit
immediately
before
that,
because
the
commit
before
that
was
fine,
it's
just
a
regular
old
commit
is,
in
fact
it's
probably
the
last
commit
from
the
last
version
of
this
lesson.
So
we
only
want
to
go
back
by
one,
and
what
this
shorthand
allows
us
to
do
is
exactly
that.
We
want
to
go
basically
head
minus
one.
A
You
can
kind
of
think
of
a
tilde
as
a
you're
saying,
hey,
whatever
head
has
pointed
out,
I
want
you
to
insert
the
commit
ID
for
the
commit
prior
to
that
which
is
going
to
end
up,
and
we
can
even
see
what
it
is
get
long.
One
line
you
can
see
that
head
is
currently
pointing
at
for
a
1,
3,
0
0.
You
can
see
that
the
commit
prior
to
that
is
DfE
77a,
so
what
we
actually
could
do
if
we
wanted.
A
This
would
be
exactly
the
same
that
this
would
actually
result
in
the
exact
same
outcome.
We
could
do
get
reset
soft
and
then
this
commit
ID
same
exact
thing.
I
like
this
shorthand,
because
again
it
gives
the
first
time
it's
easier
and
second
off.
We
know,
because
we
are
looking
at
this
particular
scenario
that
we
want
the
commit
right
before
the
one
that
we
just
made
now.
This
may
not
work
for
you.
A
Now,
now
we're
back
to
what
we
were
doing
two
lessons
ago
or
two
to
two
chapters
ago,
where
we
were
effectively
dealing
with
changes
that
were
in
staging,
so
we
we
know
we
want
the
host
name,
config
dot,
txt
file
to
be
committed.
That
was
the
whole
point
of
the
commit,
but
we
don't
want
the
credentials
txt
file
committed,
so
let's
actually
do
a
git
reset
on
that
file
and
again,
in
the
second
chapter,
we
looked
at
this
how
to
how
to
remove
things
from
staging
and
we'll
do
a
git
status.
A
You
can
see
that
now
the
change
for
host
name
configures
in
staging
and
the
credentials
txt
file
is
now
an
untracked
file,
because
it's
not
in
staging
anymore
and
get
doesn't
intend
on,
including
it
because
it's
untracked
now
we
could
delete
this
file,
but
honestly
you
it
could
be
that
this
file
still
needs
to
be
here
and
what
we
instead
want
to
do
is
just
protect
against
committing
this
file
accidentally
in
the
future.
The
best
way
to
do
that
is
to
add
it
to
something
called
a
GUID
ignore.
A
A
Another
example
is
like,
if
you're
working
on
a
Python
project,
you
want
the
dot,
py
files
to
be
committed
because
it's
the
source
code,
but
you
don't
want
the
dot
pyc
files
to
be
created
because
that's
that's
the
bytecode,
it's
the
interpreted
bytecode
from
that
original
source,
and
so
you,
you
don't
want
that
committed
at
all
because
it
gets
generated
by
Python,
and
so
that's
another
example.
And
then
in
that
case
you
would
just
say
star
dot,
pyc
to
ignore
all
pyc
files.
For
us,
it's
it's!
It's
easy
enough.
Just
to
say!
Look!
A
We
we
just
want
you
to
ignore
this
credentials,
txt
file.
So
let's
append
this
text
to
a
new
file
called
get
ignore
and
we
will
also
add
that
file
to
our
to
staging
another
thing:
that's
pretty
common!
This
kind
of
sounds
like
a
sounds
confusing,
but
it's
actually
it's
actually
a
good
idea
to
commit
this
file
to
commit
the
get
ignore
file,
because
then
everybody
can
benefit
from
it.
A
So
now
it's
not
just
me
that
gets
this
protection
against
committing
the
credentials
txt
file,
but
it's
everybody
that
uses
this
repository
as
long
as
they
have
the
most
recent
version
of
the
repo.
Let's
do
a
get
status
just
see
where
we're
at
yep
looks
like
both
of
these
files
are
now
in
staging
and
we
will
run
the
commits
yeah
get
to
commit
s
M,
adding
hostname
config
that
my
stupid
boss
wanted
excellent
okay.
A
A
In
fact,
I'll
just
do
it
LS,
LH,
a
and
just
see
the
local,
the
actual
files
and
outside
of
get
you
can
see
that
file
is
still
there,
but
because
it's
in
it's
listed
in
the
GUID
ignore
file
get
is
ignoring
it
like,
as
you
might
expect
so
very
useful.
The
file
is
still
there,
but
it's
not
in
git,
and
it
can't
be
unless
we
override
it,
which
is
possible,
but
we,
but
it's
you'd,
have
to
really
really
want
to
commit
it.
A
If
you,
if
you
did
that
okay,
so
we
are
good,
we've
made
a
commit
and
and
a
good
commit.
We
don't
have
any
sensitive
information
in
there
positive
or
E
next
thing
is
we
accidentally
besmirched
the
good
name
of
our
of
our
superior
and
that's
not
good
either.
So
we
can
actually
change
this
as
well,
and
that's
using
the
amend
flag
for
the
git
commit
command.
A
The
text
editor
to
get
opened
looks
like
it's
opening
here
we
open
Nano.
You
can
see
the
previous
commit
message
is
already
provided
for
us,
because
that's
that's
what
we
that's
what
we
put
in
last
time,
but
we
can
edit
it
here
by
just
simply
taking
it
out
and
sang
adding
hostname
config
there
we
go
now,
as
you
can
see.
If
we
do
get
log,
you
can
see
that
the
commit
is
here
and
it's
a
new
commit
ID
from
the
one
that
we
had
before
and
it's
and
it's
it's
directly
as
it's
a
direct
child.
A
Commit
of
this
of
this
merge
conflict
resolution
commit
that
we
made
in
the
previous
section,
and
so
we've
really
only
still
made
one
commit.
Even
though
we've
run
the
git
commit
command
like
three
or
four
times.
We
still
only
have
this
one
commit.
So
it's
just
that's
what
happens
when
you
change
it
now,
let's
say
for
some
reason:
our
boss
comes
by
and
says,
look
art
seaport
are
super
super
secret
hostname
configuration
is,
is
it
shouldn't
be
committed
either?
A
So
what
we
want
to
do
is
we
just
want
to
undo
the
entire
record
in
this
commit.
What
we
want
to
do
is
get
back
to
this
commit
and
blow
away.
This
commit
entirely,
don't
even
care
about
the
changes.
Don't
care
about
the
contents.
I
just
want
you
to
get
rid
of
everything
a
little
bit
overkill,
but
sometimes
need
it.
Sometimes
you
just
need
to
get
rid
of
the
last
commit
or
more
than
one.
A
Sometimes
you
get
me
to
get
rid
of
a
lot
of
commits
and
again
I
want
to
say
this
is
this
is
where
things
can
get
dicey,
because
what
we're
doing
here
is
we're
using
a
flag
hard
which
is
similar
to
the
to
the
git
reset
command
that
we
were
in
before.
But,
unlike
the
last
command,
it's
not
going
to
place
anything
in
staging.
A
It's
simply
going
to
delete
all
of
the
commits
up
into
the
point
that
you
specify
I
mean
so,
if
you
specify
say
if
we
were
to
specify
let's
scroll
down
on
this
commit
list,
if
we,
if
we
were
to
specify,
say
this
commit
in
this
command,
it
would
just
destroy
all
these
other
commits,
maybe
just
be
gone
all
their
contents,
all
that
history,
all
of
it
would
be
gone.
So
definitely
wield
this
with
some
caution.
A
What
we'll
do
again
is
we
want
the
last
commit
to
be
gone
and
so
will
rerun
that
alias
of
head
till
d1
so
get
reset
again
hard
very
dangerous,
but
in
this
case
we
know
what
we're
doing
so
head
Tildy
one
and
you
can
see
head
it
even
says
head
is
now
at
that,
commit
where
it
says,
resolved,
merge,
conflict,
overwrite,
Fred's
change,
that's
the
commit
message
for
that:
DF
e
7b
7a,
DF
e
7b
7a.
There
we
go
so
yeah
and
then
get
log.
A
You
can
see
that
our
commit
is
no
longer
there
and
effectively
what
we're
back
to
is
before
we
even
started
this
lesson.
This
is
what
the
repo
looked
like,
because
we've
effectively
undone
everything
that
we've
done
this
far
okay
and
then
yeah
like
I,
said
in
in
in
this
in
last
section
of
this
lesson.
I
do
cover
this
a
little
bit
there
there
are.
This
was
easy
enough
for
us
to
resolve,
because
we
we
we
have
we're
working
in
a
local
environment
like
the
the
the
repo
that
we're
working
with
here
is
only
here
this.
A
The
idea
of
changing
history,
whether
it's
through
the
get
a
git
commit
amend
you
know,
amend
flag
or
through
the
git
reset
commands,
has
broader
implications
when
you're
working
with
others
using
something
called
remotes
like
if
you're
working
with
github,
where
you
are
collaborating
on
a
repo
with
people
all
around
the
world
where
they
have
their
own
copies
of
the
ancestry.
And
then
your
changes
have
to
get
merged
together.
A
In
some
way,
playing
surgery
on
your
git
repository
can
have
some
implications,
kind
of
bad
implications,
if
you're,
not
careful,
and
so
what
we're
gonna
talk
about.
Just
I'm
teasing
this
a
little
bit
because
I
think
it
makes
a
lot
more
sense
once
we've
covered
remotes
first,
but
there
will
be
a
section
in
the
next
part
of
the
lesson
where
we
cover
effectively
fixing
problems
when
using
git
remotes,
because
there's
some
etiquette
that
needs
to
be
observed
when
doing
that,
just
to
make
sure
that
you
don't
break
the
the
ancestry
for
people.
A
Okay,
so
that
is
it.
Hopefully.
This
was
useful
again
if
you
want
to
follow
along
with
these
videos.
The
the
links
to
everything
that
you
want
are
in
the
description
below
NRE
labs.
Io
is
the
main
site.
If
you
go
there
and
you
click
on
hit
lesson
catalog
it'll
give
you
it'll,
give
you
a
full
list
of
all
the
lessons
that
we
have
this.
This
lesson
on
git
is
just
one
of
them.
We've
got
a
lot
of
other
lessons
and
we're
adding
to
them
all
the
time,
because
it
is
a
community
driven,
contribute
curriculum.