►
From YouTube: Git Tips & Tricks - GitHub Satellite 2017
Description
Presented by:
Matt Desmond, GitHub
Come git better at Git with GitHub Trainer, Matt Desmond! Terrible puns aside, this session will empower you to get out of some of the sticky situations you ... or your coworkers might find themselves in when working with git.
At Satellite 2017, attendees came to exchange cutting edge practices on how to bring together the people and tools you need to build great software. Watch the recordings to find out what GitHub's been working on, and hear how other teams use the GitHub ecosystem to customize the way they work.
We'll be getting together again in San Francisco on October 10th-12th for GitHub Universe. We hope you'll join us for three days filled with the creativity and curiosity of the largest software community in the world.
For more information, go to githubuniverse.com.
A
Alright,
hey
everyone
welcome
back
from
lunch.
My
name
is
Matt
Desmond
and
I'm,
a
trainer
here
at
github,
so
normally
I'm
a
lot
so
I'm,
probably
at
an
airport
I'm
a
huge
Bob's
Burgers
fan
I,
don't
I'm,
really
hoping
that
that's
something
that's
over
here!
I
like
made
this
slide.
Zack
have
a
bunch
of
Bob's
Burgers
references
and
then
I
realize,
like
oh
man.
They
no
idea
so
we'll
see.
A
Hopefully
it's
good,
if
not
hopefully
they're
funny
for
you
and
then
before
working
to
get
hub,
I
documented
a
bunch
of
stuff
from
software
to
single
sign-on
stuff,
so
yeah,
let's
get
into
this.
So
what?
If
I
could
tell
you
that
I
could
make
getting
easier
so
today
we're
going
to
review
some
helpful
aliases
that
will
kind
of
allow
you
to
work
quicker
or
more
efficiently.
A
We're
going
to
talk
about
some
commands
that
you
might
already
know
about
or
that
you're
not
using
or
maybe
you're,
not
using
correctly
and
then
we'll
kind
of
dive
into
like
really
briefly
just
work
loads,
just
kind
of
identify
like
how
you
could
be
working
more
effectively
or
collaborating
better
with
your
team.
So,
looking
very
quickly
at
like
a
workflow,
we
can
see
like
all
of
these
crazy
dots
and
you
have
no
idea
what's
happening
so
at
the
top
we
have
what's
called
the
github
workflow.
A
That's
where
you
just
kind
of
have
like
one
long
long
term
branch
or
long-lived
I,
guess,
and
so
that
branch
is
where
your
new
features
would
come
up
from.
So
you
would
branch
off
of
that
great
commits,
make
some
changes
and
then
merge
into
your
master
your
deployed
code.
If
we
look
at
the
bottom,
that's
more
of
a
git
flow.
So
that's
when
you
have
like
multiple
lines
that
last
for
a
long
periods
of
time.
So
you
have
things
like
your
master
or
that
is
your
deployed
or
like
available
code.
A
Maybe
it's
like
a
website,
that's
live
and
then
every
new
feature
gets
built
off
of
the
develop
branch
right
so
really
quickly.
I
kind
of
like
to
just
talk,
kinda
gets
pretty
advanced,
so
I
wanted
to
start
off
with
some
really
basic
stuff,
so
people
don't
get
lost
too
quickly,
but
let's
kind
of
look
at
what
we're
going
to
cover
so
right
now
we're
going
to
dive
into
kind
of
like
there
are
these
four
areas
that
I
identified
when
it
comes
to
working
in
git
or
just
development
in
general.
A
So
right
now
we're
going
to
kind
of
look
at
configuring,
your
computer
or
your
setup,
so
that
you're
able
to
work
more
optimally
and
then
we'll
start
looking
at
what
you
can
do,
while
you're
actually
working
or
making
changes
to
your
project,
what
you
can
do
during
like
the
staging
or
the
commit
process
and
then
how
you
can
modify
the
history
of
your
project
right.
So
the
first
thing
that
we
can
look
at
is
the
idea
of
an
alias,
so
aliases
are
really
just
shortcuts.
A
Where
you
take
a
command
that
you
normally
run,
let's
say
check
out
dash
B
and
you
can
make
it
shorter,
so
something
like
CEO
right
so
I'm,
assuming
there
are
a
lot
of
people
in
this
room
that
probably
have
an
alias
or
two.
So
we
have
something
like
git
status
as
well,
so
you
could
change
status
with
like
an
app's.
Some
other
examples
would
be
like
using
reset
head.
A
So
now,
let's
look
at
something:
that's
not
as
simple
as
you
know,
changing
git
checkout
to
dot
CR
to
see
oh,
so
this
is
a
alias
that
will
open
up
the
current
repository
that
you're
in
in
the
browser.
That's
like
your
default
browser
in
your
computer
or
on
your
computer
right.
So
this
is
taken
from
a
blog
post
by
Phil
hat.
The
link
is
at
the
bottom.
A
So
if
we
run
excuse
me
as
we
run,
get
browse
or
get
open
in
this
case,
this
will
actually
open
up
the
repository
that
we're
currently
in
on
our
browser,
so
it'll
like
open
up
github.com
and
you
can
kind
of
navigate
your
browser
from
there
look
at
issues,
pull
requests,
etc.
As
opposed
to
like
looking
at
your
files
jumping
over
to
your
browser
going
to
github.com
and
then
trying
to
remember
what
what
repository
you're
in
so
yeah,
we
can
use
that.
A
So
we
can
actually
look
at
this
one
as
well.
So
this
is
another
alias
that
I
found
while
browse
the
Internet,
and
this
will
allow
you
to
create
either
checkout
to
a
branch
that
already
exists
using
git
checkout,
but
using
the
number
of
the
dollar
sign
1
or
the
dollar
sign
too.
So
we
have
our
variables.
We
can
actually
either
checkout
a
branch
that
already
exists
using
git
in
this
case
CHF.
A
But
if
you
don't
have
that
like,
if
the
branch
doesn't
exist
and
you
wanted
to
create
a
new
branch,
you
can
run
get
CH,
SB
it'll,
create
a
new
branch
and
then
immediately
afterwards
it
will
run
git
status
and
it
will
identify
what
changes
like
what
changes
files,
whether
it's
untracked
modified
whatever
and
that'll,
be
displayed.
This
could
be
kind
of
useful
if
you
typically
jump
from
you
know,
you're
working
on
feature
to
feature,
and
maybe
you
didn't
commit
the
last
changes
you
made
before
jumping
to
a
new
branch
right.
A
So
again,
this
just
kind
of
shows
us
what
we
can
do
inside
of
an
alias
file,
and
this
kind
of
brings
me
over
to
what
we
can
do
when
we
identify
how
we
can
use
like
a
dot,
git
ignore
file
and
then
we'll
actually
kind
of
combine
that
with
an
alias.
So
like
quick
show
of
hands
who
knows
what
a
get
ignore
file
is
how
many
people
are
grabbing,
get
ignore
files
from
github
com
instead
of
making
their
own?
Ok.
A
So
what
if
I
told
you
that,
instead
of
making
get
ignore
files,
you
could
just
get
them
for
free
from
other
projects,
other
open
source
projects?
And
we
can
do
that
so
there's.
Actually
a
repository
on
github
com,
github,
slash,
get
ignore
that
has
a
laundry
list
of
ignore
files
already
created
for
a
bunch
of
different
languages.
However,
not
all
of
the
languages
are
covered
there
and
that's
where
I
like
to
point
people
to
github.com
slash
trending.
A
So
this
is
just
the
trending
projects
for
all
of
the
different
languages
that
are
on
github
calm
and
you
can
actually
find
you
know
something
like
say
like
MATLAB
or
something.
That's,
not
necessarily
a
git
ignore
file
that
a
lot
of
people
are
using,
but
there
are
plenty
of
open
source
projects
that
have
MATLAB
files,
so
they're
a
good
ignore
files
already
exist,
so
you
can
actually
jump
around
and
grab.
You
know
get
ignore
file
from
a
project
with
pretty
much
any
language
that
you
might
be
working
with.
A
Sorry,
I
don't
know
why
their
throats
dry.
Alright,
so
I
created
this
alias
file.
Well,
I
took
some
Rob,
Cooper
invent
I,
created
it
and
then
I
made
some
changes
to
it.
So
what
this
is
is
a
alias
file
that
will
automatically
download
a
specific
languages,
get
ignore
file
from
another
repository
and
automatically
add
it
and
then
commit
it
to
your
project.
A
So
in
this
case
we
have
like
we
would
run
get
ignores,
and
this
will
go
out
to
the
git,
ignore
repo
on
github
comm
and
then
it'll
grab
our
visual
studio,
git
ignore
file
and
then
it'll.
Add
it
and
then
do
a
git
commit
em
with
the
fact
that
we're
adding
like
the
nougat
ignore
file,
we
could
change
visuals,
Visual
Studio
get
ignore
to
any
of
the
other
languages
that
are
on
github,
comm
or
another
repo.
So
basically
we
can
run
this
like
we
create
a
new
repository
right.
A
A
Yeah,
so
now
that
we
kind
of
set
up
our
system,
we
can
actually
start
working
on
our
files
right.
We
can
start
making
changes
and
go
from
there.
So
the
first
thing
that
we
can
look
at
is
the
idea
of
add
P,
so
everyone
in
the
room
is
probably
really
familiar
with
using
git,
add
to
take
a
file
that
they've
made
changes
to
and
move
it
from
their
working
directory
to
their
staging
area,
and
then
they
make
it
commit.
A
When
we
look
at
P
or
patch,
it
allows
us
to
identify
changes
that
we've
made
inside
of
one
file
and
separate
them
out
into
different
commits
if
we
want
to
so.
In
this
case,
I
made
some
minor
modifications
to
a
really
crappy
MD
file
and
I
was
able
to
take
the
changes
that
I
made
and
apply
them
in
two
separate
commits.
This
is
kind
of
important
if
you're
trying
to
create,
what's
called
an
atomic
commit
or
take
changes
that
you've
made
make
sure
that
those
commits
are
like
related.
A
So
we
can
use
patch
to
make
sure
that,
like
you
know,
maybe
we're
modifying
or
editing
content
as
opposed
to
creating
new
content
or
creating
new
files.
So
we
can
make
sure
that
we're
taking
those
commits
and
kind
of
separating
those
out
as
opposed
to
kind
of
one
lump
sum
or
giant
cluster
of
a
commit.
A
So
moving
on,
we've
got
git
status
right,
so
everyone
in
the
room
obviously
uses
git
status
constantly
or
at
least
once
a
day,
so
some
really
quick
ones
that
I,
just
like
the
the
different
flags
that
we
can
use
with
status.
So
we
have
the
s
and
the
s
B,
and
that
kind
of
just
displays
your
status
in
a
more
succinct
or
cleaner
way.
Dot
status
is
just
going
to
show
you
like,
what's
been
modified
or
what's
been
added.
A
A
Oh,
it's
also
I
think
it's
just
a
lot
cleaner
than
the
giant
block
of
text
that
you
get
every
time
you
run
git
status
normally
so
now
that
we've
made
changes
or
we've
created
our
commits,
we
can
start
looking
at
what
we
can
do
during
the
staging
section
of
development,
or
you
know,
working
with
git
and
we're
going
to
look
at
what's
called
git
commit
amend,
which
I'm
sure
I
show
hands
in
the
room.
People
using
git
commit
amend
because
they
made
that
typo
on
that
last
commit
right.
A
So
a
handful
of
people
are
using
it,
which
is
awesome.
Git
commits
amends
a
really
quick
way
to
fix
a
commit
that
you've
made
on
your
project.
It'll
fix
the
last
one,
it'll
open
it
back
up,
so
it'll
allow
you
to
edit
it.
In
this
case,
we
can
see
I
made
a
mistake
with
my
git
commit
dash.
Em
I
said
read
mr.
A
MD,
as
opposed
to
read
me:
I
did
a
git
commit
amend
that
opened
up
my
commit
for
editing,
I
made
the
changes
inside
of
my
editor
and
then
recommitted
it
a
couple
things
to
know.
My
commit
Shaw
obviously
got
changed
because
I've
changed
the
history
of
the
project,
but
I
was
able
to
make
a
quick
modification
before
maybe
I
pushed
it
up
to
my
repository.
A
One
thing:
that's
really
cool
about
git
commit
amend
is
that
you
can
take
a
file
that
you
maybe
forgot
to
include
in
the
last
commit
that
you
made
and
by
staging
it
we
can
actually
take
it
and
put
it
into
that
last
commit.
So
in
this
case
we
can
see
that
I
have
this
file.
1Md
I
forgot
to
include
it.
In
my
commit,
I
ran
a
git,
commit,
amend
or
I'm.
Sorry,
first
I
staged
it,
so
we
can
see.
I
did
get
add
file
1
dot
MD.
A
We
ran
against
that
at
the
show
that
you
know
was
sitting
there
and
then
I
did
a
git
commit,
amend,
I
modified
my
commit
message,
and
then
it
automatically
grabbed
that
file
that
was
staged.
So
if
you
have
a
bunch
of
files
that
you
made
changes
to,
you
forgot
to
make,
you
know
bring
it
over
from
your
working
to
your
staging.
A
Before
you
made
a
commit,
you
can
run
a
git
commit
amend
after
you've
staged
that
file
change
the
commit
message
or
don't
either
way
it
doesn't
matter
and
it'll
automatically
grab
that
file
from
the
staging
area.
If
you
have
files
in
your
working
directory
that
haven't
been
modified
or
that
have
been
modified
but
haven't
been
moved
to
staging,
then
those
will
still
hang
out
so
those
won't
get
brought
over.
It's
only
things
that
are
you
know
in
the
staging
area
itself.
A
A
So
we
can
look
here,
so
this
is
rebase.
This
is
a
visualization
of
what
rebase
looks
like
using
a
tool
that
two
of
our
Adam
editors
created
our
engineers
created.
So
this
is
just
kind
of
like
what
rebase
looks
like
we
take.
You
know
commits
from
one
branch
to
them:
apply
them
on
top
of
an
existing
branch,
in
this
case
we're
moving
rebase
me
on
top
of
master
and
then
merging
master
in
using
a
fast-forward
merge,
but
we
can
also
do
something
called
rebase
interactive,
so
that's
rebase,
I
rebase.
A
A
A
So
I
take
this
gift
here,
because
it's
kind
of
dangerous,
because
you're
going
in
and
identifying
that
you
don't
want
to
know
like
what
the
pop-up
is
so
like
in
this
one
get
merged
new
branch.
No
edit
I'm,
just
saying
like
murchison
I,
don't
want
to
see
the
commit
message.
I
don't
want
to
see
the
like
any
kind
of
pop-up
I
just
want
the
merge
to
happen.
If
we
look
at
get
documentation,
it
typically
doesn't
like
talking
about
no
edit
for
that
exact
reason.
A
So
it's
kind
of
dangerous,
but
it's
also
kind
of
nice
to
not
have
to
have
like
your
text.
Editor
or
you
know,
be
I
open
up
just
to
let
you
know
that
you're
merging
right
for
something
like
get
commit
amending
right,
see
what
I
did
there.
So
here
we
can
do
a
git
commit
amend,
like
maybe
I,
don't
need
to
make
a
modification
to
the
actual
commit
that
I
made,
and
so
I
could
grab
that
file
right.
A
A
So
this
is
kind
of
the
end
of
will
stay
elected,
CLI
stuff
and
we're
actually
going
to
kind
of
talk
about
some
of
the
things
that
you
can
use
on.
Github
comm
to
make
your
project
life
easier,
or
you
know
the
work
that
you're
doing
a
little
bit
more
efficient
so
who
closes
issues
with
pull
requests
automatically
right
now:
cool
handful
of
people
in
case
you're,
not
turning
around
and
looking
back
behind
you.
A
So
when
we
create
a
pull
request,
we
can
use
a
handful
of
the
words
on
the
left,
so
fix
fixes,
etc
and
then
identify
a
issue
that
préval
ready
exists
within
that
repository.
So
in
this
case,
I
created
this,
like
example,
issue
number
one
and
when
I
close,
this
pull
request
it's
going
to
automatically
close
or
emerge.
This
pull
request.
It's
going
to
close
the
issue
and
we
can
see
that
here
at
the
bottom
left.
A
We
can
see
that
the
issue
was
closed
and
it
was
closed
because
it
was
my
pull
request,
number
to
update,
readme
OMB
was
merged
in
and
that
it
had
referenced
it
right.
So,
if
you
have
a
group
of
issues
or
you
have
a
couple
of
issues
that
you
know
made
it
made
a
PR
happen,
you
can
get
those
issues
to
automatically
close
once
you
merge
your
pull
request
in
so
you're
kind
of
keeping
your
repository
clean,
you
don't
have
a
bunch
of
random
issues
that
no
longer
really
matter,
because
you've
already
closed
out.
A
That
pull
request
right.
It's
one,
less
thing
that
you
need
to
work
on
or
clean
up
after
the
end
of
like
a
development
cycle,
some
other
things
that
you
can
do
inside
of
an
issue
or
a
pull
request
is
the
idea
of
checklist.
So
this
the
checklist
on
the
left
hand,
side
is
just
an
example
of
how
you
could
make
a
giant
checklist
with
insane
issuer
pull
requests
to
identify
what
you
need
to
work
on.
So
this
is
actually
a
checklist
that
I
created
when
I
built
one
of
our
courses
on
services,
github.com
quick
plug.
A
So
here
we
can
see
like
I,
have
a
checklist
and
then
what's
really
nice
about
the
UI
on
github.com.
Is
it
takes
a
checklist
that
exists
and
then
it
will
display
it
inside
of
the
list
of
issues
or
pull
requests
in
your
repository.
So
here
we
can
see
like
26
out
of
32
were
finished
and
we
still
merged
it,
probably
because
it
was
done
and
then
I
forgot
to
check
things
off.
The
other
thing
that
we
use
issues
for
is
to
vote.
So
on
the
right
here
we
can
see
that's
kind
of
blurry,
sorry.
A
So
on
the
right,
we
identified
a
list
of
cities
that
we
wanted
to
visit
and
we
used
voting,
which
are
the
we
used
of
reactions
inside
of
an
issue
to
automatically
like
create
this,
like
list
of
things
that
we
could
vote
on,
and
then
it
great
creates
its
like
quick,
visual
visualization
of
like
who's
interested
in
going
where
a
spoiler
alert'
nashville
tennessee
won
but
yeah.
I
don't
like
one
person
here,
yes,
but
we
were
looking
at
a
bunch
of
other
places.
A
Typically
north
america
related
just
because
it's
a
little
bit
cheaper
for
us
to
stay
on
that
side
of
the
pond.
But
it
would
be
nice
to
come
back
here,
okay,
so
so
yeah.
So
that's
like
issues
and
pull
requests
and
and
checklists
and
whatnot.
And
then
the
last
thing
that
I
wanted
to
cover
is
the
ability
to
use
get
reset
to
bring
files
back
to
life
all
right.
A
So
in
this
example,
I
took
a
bunch
of
files
and
used
get
reset
to
bring
like
go
back
in
history
to
where,
before
I
made
a
bunch
of
changes.
So
if
we
look
at
this
image,
I
created
the
repository
right
with
a
meanwhile
one
added
hello
to
MD
and
then
I
added
a
new
branch
to
MD
as
well,
and
then
I
did
a
get
reset
hard
back
to
before
I
added
hello
MD
for
the
new
branch
MD
file
and
then
using
git
ref
log,
which
is
a
log
of
all
of
the
times.
A
That
head
has
moved
within
your
repository
on
your
local
machine,
its
local.
Only
so
you
can't
ask
someone
on
your
team
to
look
at
their
rep
log
and
get
the
exact
same,
commit
history,
because
it
won't
happen.
So
we
can
look
at
this
and
see
that
I
was
unable
to
identify
like
when
I
made,
that
that
change,
which
is
the
9
2
3
8
sha,
so
it's
kind
of
at
the
top
there
did
a
get
reset.
That's
hard
back
to
before.
A
I
did
that
first
reset
hard
and
I
brought
all
of
my
files
back
to
life.
It's
got
like
a
pretty
unique
use
case,
but
this
would
kind
of
allow
you.
If
you
made
some
changes
to
files,
maybe
did
it
get
reset
hard
and
then
weren't
a
huge
fan
of,
like
maybe
the
changes
that
you
made
or
the
fact
that
you
deleted
some
of
the
files.
You
can
kind
of
go
back
in
time
back
before
you
even
started
working
on
those
files
that
day
right.
A
So
it's
like
pretty
unique,
but
it's
something
that
you
could
do
as
opposed
to
say,
maybe
creating
a
new
branch
off
of
the
branch
who
you're
working
on
and
then
experimenting.
So
if
you
kind
of
gone
down
the
path-
and
you
realize
that
like
I,
should
have
made
a
new
branch
here,
you
can
always
reset
or
reset
mix
there
and
then
create
that
new
branch.
A
Ok,
so
again,
I
just
kind
of
wanted
to
create
this
slide
here
to
again
go
over
the
fact
that
we
covered
a
bunch
of
stuff
I
think
the
multi
command
aliases
are
really
interesting.
The
ability
to
kind
of
automate
a
lot
of
the
things
that
you
already
do,
using
like
really
quick
commands,
is
really
awesome.
A
A
I,
really
like
being
able
to
just
look
at
a
commit
and
identify
if
like
get
revert,
is
going
to
completely
screw
me
over
or
if
it's
just
going
to
make
that
one
small
change
that
I
committed,
you
know,
go
back
right,
so
yeah
and
then
commit
amend.
I
like
commit
amend,
especially
for
adding
a
file
like
after
I've,
maybe
forgotten
it
because
I
do
it
all
the
time
and
it's
something
that
a
lot
of
people
don't
realize
that
they
can
do.
A
You
can
use
git,
commit
amen,
obviously
edit
or
fix
the
commit
message
that
you
maybe
made
a
typo
in.
He
typed
you
fast.
Your
brain
brings
a
little
bit
faster
than
your
fingers,
but
then
you
can
also
just
take
a
file
or
group
of
files
and
then
add
them
to
that
last
previous
commit
especially
if
you
haven't
pushed
yet
and
then
obviously
rebasing-
and
you
know
no
edit
for
really
quick,
merge
commits
all
right
so
yeah
my
name
is
Matt
Devon.
You
can
find
me
on
github
as
at
beer
to
VDU.
A
You
can
also
email
me
at
beer,
2v2
you
at
github
comm,
and
if
you
have
any
questions
from
these
for
the
services
team
at
github,
you
can
find
us
at
services,
github.com
or
email
us
questions
at
services
at
github
comm.
We
also
have
a
booth
here
today
called
the
app
services.
Oh
wow,
I
can't
tell
please
feel
free
to
come
by.
Ask
us
any
question.
There
are
plenty
of
us
to
pretty
much
answer
anything
whether
it's
workflow,
maybe
admin
stuff,
maybe
just
identifying
how
you
can
train
your
users
a
little
bit
easier.
A
Another
thing
is
on
our
services:
github
comm
site.
We
have
a
whole
laundry
list
of
free
online
classes
that
you
can
take
or
share
with
other
people
that
are
interested
in
learning,
git
or
github
that
are
open
source
as
well.
So
if
you
feel
like
contributing
or
building
a
class
with
us,
you
can
do
that
as
well.