►
From YouTube: Git LFS Training - GitHub Universe 2015
Description
Allen Smith conducts a short training that walks through a typical workflow with exploration at each step of what is happening to your large files and your repository when using Git Large File Storage (LFS).
About GitHub Universe:
Great software is more than code. GitHub Universe serves as a showcase for how people work together to solve the hard problems of developing software.
For more information on GitHub Universe, check the website:
http://githubuniverse.com
A
We
have
one
more
present,
so
they're
gonna
bring
up,
and
this
is
Alan
Smith
and
he's
one
of
our
trainers
here
at
github.
He's
gonna
walk
us
through
some
live
demo.
So
if
you
want
to
take
notes,
bring
out
your
computer's
feel
free
to
do
so
now.
Some
fun
facts
about
Alan.
If
you
want
to
go
ahead
and
join
me
on
stage,
Alan
lived
in
Nashville
for
a
while,
also
very
musical,
as
part
of
my
speaker,
montage
up
here.
A
B
B
B
So
you'll
notice
that
it
puts
this
filter
in
your
dot,
git
config
file.
So
you
have
your
clean
and
your
smudge
the
filters
in
it
run
and
we'll
talk
about
those
filters
here,
just
in
just
a
little
bit
here,
but
I
wanted
to
point
out
that
this
is
something
that
changes
in
your
git
config
when
you
install
git
LFS.
B
So
the
first
thing
I
like
to
do
when
I
have
a
repository,
so
I
just
have
a
repository
here
called
large
assets,
I've
already
cloned
it
down
to
my
machine,
but
it
also
exists
on
github.com
and
if
you'll
notice,
I
have
a
few
images
here.
So
these
are
all
PNG
images.
I've
already
installed
get
LFS
on
this
machine.
B
So
what
I
can
do
in
a
repository
if
I
want
to
initialize
it
for
that
repository
I
could
type
get
LFS
in
it
or
I
could
actually
just
start
by
typing,
get
LFS
tract
and
then
I
can
specify
anything
that
I
would
necessarily
want
get
LFS
to
manage.
So
that
could
be
individual
files
that
could
be
file
pads,
any
type
of
glob.
You
could
specify
on
the
command
line.
B
B
But
if
we
go
over
to
our
repository
here
or
I'm,
sorry
to
our
yes,
we
are
technically
in
our
repository.
I
want
to
point
out
some
things
that
have
changed
so
when
we
ran
git
LFS
track,
a
couple
of
new
things
were
added
to
the
dot
git
folder,
that's
in
your
repository,
so
the
first
thing
I
want
to
point
out:
is
you
have
under
your
dot
git
folder?
You
now
have
this
LFS
folder.
That
is
underneath
that
dot
git
folder,
and
this
is
where
all
of
your
local
storage
happens.
B
B
The
other
thing
here
is
that
when
you
initialize
get
LFS
in
your
posit
ori
you'll
notice
that
you
have
a
pre
push
hook,
get
hook,
that's
actually
installed
for
you,
and
so
this
is
a
kind
of
a
pre-check
that
runs
anytime
before
you
push
assets
up
to
github,
then
last
thing.
The
thing
that
I
want
to
point
out
here
is
that
you
have
this
get
attributes
file.
B
So
this
is
one
of
the
things
that
I
really
really
love
about
get
LFS
is
that
it's
just
built
on
top
of
the
functionality
that
you
already
have
and
get
so
we
use
this
get
attributes
file
to
specify
that
for
all
these
PNG
files
that
we
want
to
track
we're
gonna
run
that
LFS
filter.
So
I
said
we
talked
about
that
filter
here,
and
so
let's
talk
about
and
get
filters.
So,
if
you
don't
know,
if
you
used
haven't
used,
get
filters
a
whole
lot.
The
basic
concept
is
that
you
have
two
commands.
B
You
can
specify
you
have
a
clean
command
and
you
have
a
smudge
command
and
depending
on
which
way
the
files
are
moving
in
your
repository,
one
runs
or
the
other
runs,
so
the
clean
command
runs
anytime.
You
check
files
in
or
you
may
know.
This
is
maybe
adding
it
to
your
index
or
your
staging
area.
So,
anytime,
you
stage
a
file.
We
can
say
that
these
PNG
files
are
going
to
run
through
a
clean
filter
that
we've
specified.
B
B
B
B
B
Now
that
we've
staged
these
files
get
LFS
has
created
those
pointers,
those
Tex
pointers
and
stored
those
as
objects
here
in
the
actual
git
repository.
But
then
it
took
the
content
of
those
assets
and
now
they're
in
the
local
storage
here
and
so
the
great
thing
about
being
built
on
top
of
git
like
this.
Is
it
just
fits
right
into
the
workflow
that
we
already
use
so
now
that
everything
is
added.
B
B
There
goes
so
when
we
push
our
files,
get
LFS,
actually
intercepts
them
and
sends
the
actual
content
of
the
files
to
the
LFS
server,
which
is
in
this
case
it's
an
endpoint,
that's
listening
on
github.com
and
once
it's
done
that
it
takes
those
text,
pointers
and
it
actually
pushes
the
repository
up
to
github,
like
you
normally
would
during
a
regular,
get
push.
But
the
great
thing
about
it.
B
Is
if
we
view
these
assets
on
github
they're
rendered
out
and
then
Rick
would
demonstrate
this
earlier,
but
we
don't
see
those
text
pointers
on
github.
We
actually
see
the
content
of
the
files
that
we
want
to
see,
which
I
think
is
really
nice
and
if
you're,
using
the
github
flow,
for
instance,
if
you're
doing
a
pull
request
right
now,
you
can
use
all
of
the
rich
diff
tools
that
you
have
for
images
and
things
like
that
so
rendering
these
images
out,
even
though
what's
stored
in
your
repository,
is
that
pointer
file.
B
B
So
get
LFS
fetch
lets
you
download
assets
from
the
get
the
get
LFS
server
to
your
local
storage
so
that
you
can
switch
branches
more
easily.
But
what
I
love
is,
if
you
have
a
lot
of
different
Flags,
where
you
can
specify,
maybe
certain
files
to
include
or
certain
files
to
exclude
so,
for
instance,
if
you
work
on
a
project
with
a
lot
of
different
team
members-
and
maybe
your
subspecialty
just
deals
with
audio
right,
you
could
specify
that
you
want
to
just
fetch
those
audio
files.
So
you
could,
you
can
include
certain
paths.
B
You
can
exclude
certain
paths
if
you
don't
want
certain
files.
So
I
love
this
new
feature
because
it
lets
you
do
things
when
you
have
time
and
then,
when
you're
actually
working,
you
can
switch
between
your
branches
much
more
quickly
because
you
already
have
that
data
locally
and
you
don't
have
to
worry
about
pulling
it
when
you're
ready
to
work
and
one
more
thing
to
point
out
here.
So
there
is,
we
also
have
a
command
which
is
get
LFS
pull.
And
what
that
does?
B
Is
it's
a
combination
right,
so
it
it
fetches
from
the
git
LFS
server,
but
then
it
checks
those
files
out
to
your
working
directory
as
well.
So
there's
kind
of
a
mirror
between
the
language
that
you
typically
use
in
a
git
workflow
and
a
get
LFS
workflow,
so
they
kind
of
pair
well
together
at
least
I.
Think
so.
B
So
a
one
thing
I
wanted
to
point
out
before
before
I
finish
it
up
here.
I
know
everybody's
probably
ready
for
lunch
here,
but
one
question
that
I
think
a
lot
of
people
often
ask
is
ok.
Well
I
have
this
project
that
I
have
been
managing
through
git
and
there
are
large
assets
in
this
project
already,
but
now
I
want
to
convert
it
to
lfs
right.
B
I
guess
that
I
I
saw
run.
Maybe
a
git
repository
went
from
close
to
seven
hundred
Meg's
down
to
about
32.
So
there
is
some
definite
room
for
shrinking
the
size
of
your
repository,
so
it
doesn't
take
as
long
to
clone
and
people
can
work
with
it
a
little
bit
more
easily
there.
So
I
would
be
around
if
anybody
has
questions
I'm
happy
to
talk
to
people
one
on
one,
if
you
wanted
to
kind
of
go
through
a
more
complex
workflow.
Also
I
wanted
to
point
out
that
our
services
team
is
over
here
available.