►
From YouTube: Repo factoring, Charles Bailey - Git Merge 2016
Description
In this talk, Charles will cover analyzing objects within the git repo, rewriting history, and tools & techniques for migrating your team to a healthier repository.
He'll show how to use a new option to 'git cat-file' to analyse what is taking up the space in your repository and how effective Git's delta compression is in your repository. Charles will also demonstrate one way to rewrite history, and talk about the merits of a number of the other options, including migrating to a solution such as git-lfs. He'll also cover techniques and tools for letting all team members easily migrate their work in progress to the new history.
Charles Bailey is a programmer and Git advocate. He is at home in C++, Bourne shell, Perl, Sinclair BASIC, Python, C, and various assembly languages. He works for Bloomberg in Developer Experience, helping teams implement optimal practices and workflows.
About Git Merge:
Git Merge is the pre-eminent Git-focused conference: a full-day offering technical content, user case studies and training workshops for Git users of all levels.
Visit: http://git-merge.com/
A
This
is
great
because
the
lights
are
so
bright.
I
can't
see
quite
how
many
there
are
of
you,
which
is
a
which
is
good
cool.
So,
yes,
as
as
mentioned,
I
I
work
in
developer
experience
and
one
of
the
things
I
do
is
help
people
with
the
issues
that
they
have
with
their
repositories,
and
sometimes
it's
amazing
how
bad
things
get
before
they
kind
of
kind
of
come
and
say
right
things
really
aren't
working
for
us.
You
know
everything
so
slow
what
the
hell's
gone
wrong
and
how
can
we
fix
it
or
usually
rephrase
it?
A
How
can
you
fix
it,
but
you
know
so:
I
occasionally
contribute
to
get
I'm
still
trying
to
get
my
first
c
patch
in
every
time
I've
put
in
a
c
patch.
It's
it's
been
kind
of
like
massage,
improved
upon
completely
rewritten
by
somebody
else,
so
inspired
last
year
by
git
merge
when
it
was
in
Paris,
so
I
actually
kind
of
proposed
this
term
new
get
command,
get
list
all
objects
and
Jeff
King
very
kindly
contributed
to
the
review
totally
rewrote
it
as
an
option
to
cap
file
with
many
more
features,
much
more
useful.
A
Much
more
performant
and
so
I
was
kind
of
quite
glad
to
throw
my
command
away
and
use
that
in
preference,
so
I'm
going
to
talk
a
bit
about
them.
They're
kind
of
principal
causes
of
performance
issues
in
repositories
errs
tend
to
be
a
large
object,
got
committed
at
some
point
in
history
and
every
else
is
kind
of
like
suffering
since
then,
because
now,
every
time
anybody
clones
it's
incredibly
slow,
and
these
days
people
do
kind
of
thrown
clones
the
kind
of
her
fresh
environments.
A
You
know,
they're
kind
of
this
whole
kind
of
containers
and
continuous
delivery
and
stuff
means
that
people
kind
of
tend
to
try
and
do
that
quite
a
lot.
So
I'm,
one
of
the
things
that
people
sometimes
say
to
me
is
it
doesn't
handle
binary
objects
and
I
kind
of
wonder
what
they
mean
by
that
you
know
what
already
is
a
binary
object?
Well,
what
is
handle
actually
so
pretty
much.
Every
file
that
we
deal
with
those
developers
is
its
binary.
It's
a
sequence
of
bytes.
That's
the
way
file
systems
work.
A
So
so
what
do
people
mean
when
they
say
you
know
it's
a
binary
file?
Well,
basically
mean
there
isn't
something
more
specific:
you
know
it
isn't
a
text
file,
it
isn't
source
code.
It
isn't.
You
know
something
that
you
kind
of
expect
her
on
a
diff
on,
and
it's
not
actually
true
that
gate
doesn't
handle
binary
objects
in
the
same
way
it
handles
text
objects
because
it
it
pretty
much
treats
all
files
as
binary
files,
so
I
decided
to
form
an
experiment
to
kind
of
test.
A
This
and
I
thought
so
what
it
was
a
typical
binary,
as
in
normal
text,
file,
I
thought.
Well,
libraries,
you
know
libraries
with
compiled
code
they're
there
they're,
definitely
binaries.
So
I
I
tried
to
find
one
on,
though,
on
my
system
and
I
found
this
thing,
which
is
the
static
version
of
the
C
library.
A
Usually
you
do
it
with
blobs,
although
normally
with
blobs
you
just
use
git
show
because
it's
kind
of
easier
to
type
and
remember,
but
there
are
other
options
to
cap
files,
so
so
batch
check
means
you
can
actually
print
some
properties
of
an
object.
You
can
check
it
exists
in
your
database
and
you
can
kind
of
list
out
what
the
properties
are
and
then
batch.
All
objects
goes
one
step
further
and
says
here
are
all
of
your
objects
and
you
can
kind
of
choose
what
properties
to
to
list.
A
A
That's
that's
something
that
can
kind
of
challenge
get,
and
so
libraries
are
just
archives,
so
they're
like
tape,
archives,
but
just
not
on
tape.
So
so,
like
the
tar
command
you
come
in.
If
you
like
components,
you
can
use
the
our
command,
so
I
thought
a
dl
load.
Oh
that's,
not
very
useful.
I
mean
this
is
the
static
c
library
I'm
not
going
to
use
dl
load
in
invite
us.
A
So
I
can
remove
that
and
then
I
can
add
the
file
again
and
so
now
I've
got
a
new
version
of
this
file
and
just
by
adding
it
to
the
index
it
gets
stored
in
the
object
repository.
So
I
can
kind
of
list
out
all
of
my
objects
again
and
we'll
see.
That's
a
brand
new
version
of
Lib
C
delay
and
it's
pretty
much
about
the
same
size
as
the
old
one.
A
And
then,
if
I
run
GC
again,
get
will
try
and
put
things
on
to
a
single
pack
file
and
it
will
try
to
film
some
compression.
And
what
you
can
see
here
is
that
the
file
is
now
only
5k
when
it
was
about
a
megabyte
before
so
that's
a
compression
of
a
lot
and-
and
that's
really
good.
So
so
it's
not
the
the
non
text
property
of
a
file.
That
means
that
get
can't
kind
of
do
efficient
and
effective
compression.
It's
much
more.
A
A
If
you
have
an
encryption
scheme
that
that
makes
two
similar
files
encrypt
to
two
similar
files,
it's
usually
not
a
very
good
encryption
scheme
because
that's
kind
of
leaked
information,
but
also
compression,
which
is
kind
of
not
an
objective
or
compression,
but
it's
kind
of
a
byproduct
of
that
if
you
compress
files
so
so
yeah.
This
is
a.
This
is
something
that
kind
of
irritates
me.
A
A
kind
of
here
people
go
yeah
I,
wasn't
sure
about
adding
this
file
to
get
because
it
was
quite
large,
but
then
it
zipped
quite
well
so
I
zipped
it
first
and
then
adds
it
to
get,
and
that's
just
ate
this
really
horrible,
and
especially
if
it's
kind
of
like
a
big,
a
log
file
or
something
which
you
kind
of
add
a
few
things
to
and
then
change
it
again.
You
just
like
total
your
own
gets
ability
to
do
a
kind
of
efficient
compression
on
it.
So
yeah.
Please
don't
do
that.
A
So
one
of
the
things
you
can
do
is
like,
with
this
a
bachelor
object
side,
you
can
have
a
look
at
all
of
the
or
objects
in
your
repository
and
have
a
look
at
which
one's
use
up
the
most
space
and
one
of
the
dangers
of
this
is
you
can
kind
of
look
at
it,
and
so,
if
you
look
at
the
top
ones,
also
using
the
most
space.
So
if
I
was
to
filter
out
this
really
big
object.
A
I
might
expect
that
my
repository
gets
significantly
smaller,
but
that's
not
actually
the
case,
because
if
this
very
large
object
is
actually
the
base
object,
that
Delta
is
use
that
get
is
using
to
do
delta
compression
against
other
objects.
So
if
I
remove
that
top
object
and
then
I
might
clean
up
everything
that
refers
to
it
and
by
experimentation,
it's
it's.
It's
the
various
things
that
you
kind
of
forget
about
you
need
to.
A
A
A
It's
going
to
be
disruptive,
there's
kind
of
no
two
ways
about
that.
So
I
want
to
make
sure
that
if
I'm
going
to
do
this,
that
the
the
choices
I
make
are
going
to
be
effective.
So
so
one
of
the
things
we
want
to
do
is
kind
of
analyze.
You
know:
where
is
the
space
used
in
the
repository?
Is
it
just
using
objects
that
are
that
are
not
needed?
A
Not
you
know
not
meaningful
to
be
kept
around
a
day,
objects
that
I
could
kick
out
to
a
large
file,
storage
or
a
separate
to
some
sort
of
external
storage.
If
I,
if
I
form
this
freebase
am,
am
I
going
to
get
win,
so
we
need
to
analyze
where
the
usages
in
our
repository
so
using
our
favorite
command
cat
farm
and
de-
back
for
all
objects.
Mind
if
I
batch
check
minus
minus
buffer,
but
for
really
ought
to
be.
A
Maybe
I'll
do
a
patch
for
this,
but
for
really
ought
to
be
a
kind
of
like
automatic
for
virtual
object
so
anyway,
so
that
this
large
symbol
at
the
bottom
of
the
slide.
That's
a
big
eunuch
spike
because,
like
I'm
going
to
kind
of
do
this
in
stages,
so
psycho
know,
I
can
get
to
the
size
on
disk
of
all
of
my
objects
and
then
I
can
choose
the
ones
that
are
blobs.
A
Sometimes
people
have
problems
with
really
large
commit
objects
or
really
large
pre
objects,
so
that
tends
to
be
kind
of
a
bit
of
a
separate
corner
case
and
tidying
that
up
it
can
requires
different
choices.
So
I'm
just
going
to
look
at
the
blob
case,
so
I
can
take
the
blobs
and,
and
then
what
I
can
do
is
I
can
choose
a
way
to
analyze
the
disk
size
and
take
into
account
the
fact
that
some
objects
have
been
dealt
with
compressed
against
other
objects
and
the
heuristic
that
term
that
I've
chosen,
which
kind
of
works.
A
Ok,
is
if
you
take.
If
you
take
an
object
and
then
look
up
to
if
it's
delta
compressed
what
objects
it's
been
delta
compressed
against.
If
that
object
is
using
delta
compression,
you
can
go
down
a
chain
and
find
a
route
object
that
is
just
stored
in
its
entirety,
and
you
can
say
well,
let's
take
all
the
objects
that
are
ultimately
derived
from
this
non
Dale
to
compressed
objects
and
consider
them
to
be
one
set
of
objects
and
to
each
of
the
objects
in
this
set.
A
I'll
just
assign
the
mean
of
the
all
of
the
on-disk
sizes-
and
this
is
kind
of
quite
useful.
It's
kind
of
it's
a
bit
of
a
sort
of
finger
in
the
air
heuristic,
but
it
term
it
gives
you
sort
of
various
nice
features.
So
if
it's
just
one
big
object,
it
kind
of
rises
to
the
top.
If
you've
got
one
big
object,
but
it's
actually
enabling
you
to
retain
a
large
number
of
objects
very
efficiently
because
of
the
depth,
because
it
because
you've
got
a
lot
of
other
objects
which
are
just
Delta
pressed
against
it.
A
A
Now
that's
a
total
lie.
It's
a
reasonable
size,
perl
script,
but
it's
still
not
not
too
tricky,
and
then
you
can
kind
of
choose
a
threshold.
What
what
the
average
on
disk
size
of
the
repositories
that
you're
kind
of
interested
in
just
kind
of
cut
it
down
to
stuff
that's
kind
of
a
really
going
to
make
a
difference,
and
then
what
you
can
do
is
you
just
get
up
a
list
of
ID's
and
it's
kind
of
like
okay
I've
got
a
list
of
ID's,
maybe
it's
safe
to
get
rid
of
these?
A
Maybe
it's
not
I've,
no
idea
what
you
find
is
actually,
rather
than
finding
out
what
the
file
name
and
where
it
is,
it's
actually
even
simpler
to
just
kind
of
look
at
the
file
type,
and
this
can
be
kind
of
pretty
useful
if
it
says
you
know,
if
file
says
that
this
object
is
like
an
elf
binary
and
that
you
know
that
your
source
code
repository
just
should
just
contain
source,
then
then
here's
an
idea
that
thing
I
can
get
rid
of
straight
away.
I
had
another!
Guy!
A
Writing
another
gate
command
to
find
an
ID
and
what
its
file
name
is
as
efficiently
as
possible.
I
didn't
end
up
with
any
interface
I
like
so
I
didn't
come
up
with
anything
better.
That's
just
pausing
the
output
of
vlog,
so
you
can.
Actually,
if
you
use
the
raw
log
format,
you
get
the
full
ID
of
an
object
that
you
can
kind
of
grateful.
This
is
this
is
kind
of
the
output
you
get.
It
doesn't
quite
match
the
previous
slide,
because
I
stof
know
a
breve
just
because
otherwise
the
slide
is
too
wide.
A
So
you
get
something
like
this
and
if
you
look
at
the
last
column
of
ID's,
you
can
kind
of
see
the
commits
that
introduced
a
large
object
and
what
the
name
is.
None
of
these
are
large
objects.
This
is
just
a
sample
commit.
So
so,
once
you've
got
a
list
of
object,
ids,
you
can
go
right,
excellent!
Actually,
all
of
these
some
mistakes.
A
You
know
somebody
added
them
and
then
realize
the
mistake
and
they
remove
them,
and
then
we
kind
of
carried
on,
but
we
still
left
with
this
crust
in
our
craft
in
our
history,
which
we
want
to
remove.
So
there
are
a
number
of
techniques
and
kind
of
this
is
there.
This
is
the
kind
of
middle
stage
which
there's
no
it's
quite
a
lot
of
knowledge
about.
A
It's
kind
of
like
people
have
kind
of
talk
less
about
the
kind
of
analysis
and
also
the
full
of
final
stage,
which
is
kind
of
like
helping
your
team
members
move
to
the
next
history,
so
so
rewriting
history.
There
are
kind
of
a
two
common
approaches:
there's
filter
branch.
Many
of
there's
been
at
least
two
comedy
slides
with
filter
branch
up
here
this
conference
so
far
today,
so
my
ones
are
not
supposed
to
be
comedy,
so
it's
it's
a
native
part
of
get.
A
So
if
you've
got
get,
you've
got
filter
branch
you
can
quote
what
useful
thing
to
do
for
later
on
is
to
save
the
commits
map,
so
the
map
of
what
a
pre
Rio
I
commit
was
and
what
the
post,
the
corresponding
post
rewrite
commit
was,
and
that
could
be
quite
useful
if
you've
got
kind
of
other
stuff.
You
know
is
wrong
with
the
repository.
This
is
a
kind
of
great
time
sort
of
tidy
things
up.
A
A
Sometimes
you
can
find
that
large
amounts
of
history
can
collapse
away.
Maybe
you
had
a
kind
of
episode
in
the
past
where
somebody
imported
a
third-party
repository
kind
of
binaries
at
all,
and
you
decide
that
actually
that
whole
thing
should
have
been
somewhere
else.
You
can
kind
of
get
kind
of
large
chunks
of
history
just
disappearing,
which
is
kind
of
quite
nice
and,
of
course,
the
other
tool
that
people
know
a
lot
about
is
the
bfg
repo
cleaner
and
it's
very
very
fast.
A
It
is
a
separate
tool
and
it
run
it
cause
Jerry,
but
shouldn't
be
an
issue
because
you
just
have
to
kind
of
run
it
once
somewhere
on
a
clone
on
a
on
a
machine
very,
very
fast
one.
One
difference
is
it
never
removes
empty
commits
or
any
commits,
so
the
so
the
shape
of
the
commit
graph
that
you
passed
to
the
repo
pft
repo
cleaner.
It
is
exactly
the
same
as
you
get
out
of
it
and
that's
that's
kind
of
quite
useful.
A
So
one
thing
I
wasn't
aware
of
which
I've
since
been
aware
made
aware
of
yesterday
is
the
FG
repo.
Cleaner
will
also
record
a
commit
map.
If
you
need
it,
I'm
not
sure
the
details
of
where
it
keeps
it,
but
in
there
is
a
directory
where
it,
where
it
kind
of
record
zipser.
If
you
need
to
consult
it
later,
ok,
so
if
you're
using
filter
branch,
you
can
use
a
little
commit
filter.
A
Something
like
this
to
record
the
commit
map
now,
sometimes
so
in
this
particular
example,
I'm
only
kind
of
recording
it
where
there's
an
actual
change,
so
we're
a
rewrite,
has
happened,
I'm
also
using
file
descriptor,
seven
one
of
the
slightly
cool
things
about
filter
branch.
Is
it
it's
basically
like
a
shell
snippet
execution
environment?
A
You'll
find
that
a
filter
branch
takes
a
long
time
for
big
repositories.
So
one
of
the
things
that
you
might
want
to
do
is
like
run
a
long-running
filter
branch
over
most
of
the
stuff
kind
of
in
the
background
on
a
separate
clone
and
then
at
some
later
point
in
time
you
might
want
to
kind
of
say
well.
Can
we
just
like
filter
or
the
activity?
A
That's
been
pushed
to
the
main
repository
since
I
did
my
big
batch
filter
branch-
and
you
can
do
that
so
the
one
the
one
kind
of
a
gotcha
is
that
typically
incremental
filter
branch?
So
when
you
put
a
kind
of
a
negative
ref
in
the
in
there
in
the
respective
filter,
so
I
just
want
to
filter
from
this
point
onwards.
A
Generally,
what
that's
the
main
supported
use
case
of
that
is
when,
when
you
know
the
filter
is
only
going
to
affect
recent
history,
if
you
want
to
do
a
kind
of
big
filter
branch
and
then
filter
these
separately,
what
you
need
to
ensure
is
that
at
this
boundary
you
have
a
parent
filter
that
says
well
the
want
the
commits
that
I'm,
newly
rewriting
I
want
to
transplant
them
onto
this.
These
known
new
history
that
I
already
have
so
that's
kind
of
a
something
that
choirs
a
bit
more
work.
A
Okay,
so
once
you've
decided
to
rewrite
history-
and
you
use
one
of
these
techniques
to
rewrite
all
of
your
history
is
kind
of
like
great
I've
got
a
clone.
It's
got
rewritten
history,
so
I
kind
of
I
want
to
kind
of
force,
push
this
up
to
our
main
repository
and
then
everybody
who
does
a
new
plane
will
have
a
like,
really
lightweight
stuff
and
if
you've
got
a
team
of
any
reasonable
size.
One
of
the
issues
is:
how
do
I?
How
do
I
get?
A
Now
now
wary
you
kind
of
run,
this
thing's
kind
of
depends
a
bit
on
your
own
environment,
it's
kind
of
nice
if
you
can
put
some
checks
in
a
hook
on
the
server,
but
many
people
are
kind
of
running
a
some
sort
of
server
tool
that
it
doesn't
doesn't
allow
them
to
do
that
sort
of
stuff.
So
so
often
you
need
to
kind
of
create
some
tools
that
developers
are
can
run
that
can
just
kind
of
give
them
a
simple
answer.
You
know:
have
I
got
bad
history.
Can
you
move
me
to
the
new
history?
A
Is
it
okay
to
push
so
one
of
the
questions
that
needs
answering
is
them?
Does
this
branch
need
migrating
and
I
kind
of
use,
this
concept
of
virtual
roots
in
the
simplest
case
possible?
You
might
have
so
consider
the
old,
bad
history
of
top
red
and
grey
history.
You
might
have
started
with
a
root
commit
the
red
commit
that
already
introduced
as
a
really
large
object
that
you
want
to
get
rid
of.
So
when
you
rewrite
history,
everything
will
have
this.
A
This
bad
commit
in
its
history
and
when
you
rewrite
history,
all
have
a
kind
of
a
clean
route
commit
which
doesn't
have
anything,
and
everything
will
be
reread
from
based
on
that.
So
you
have
two
disjoint
histories
and
that's
kind
of
really
easy
to
tell
the
difference.
You
can
just
use
a
merge
basis.
Ancestor
and
say:
is
this
route
commit
an
ancestor
of
the
current
branch?
A
If
it
is
needs
to
be
writing
if
it's
not,
it
doesn't
in
your
okay
and
but
usually
you
have
a
case
where
the
projects
had
some
history
and
it's
gone
fine
for
a
while
and
then
somebody
is
later
introduced
a
large
object.
And
so
when
you
rewrite
the
history,
it's
only
it's
only
the
more
recent
portion
of
history.
That's
that
that's
been
rewritten
and
so
that
the
red
commit
in
this
graph
is
like
it's
like
a
virtual
route.
So
it
so
it's
a
root
of
the
bad
part
of
the
history.
So
so
you
can
get.
A
You
can
get
the
the
set
of
commits
that
have
a
bad
history
by
kind
of
doing
a
a
rev
list
of
all
of
the
good
stuff,
and
then
you
kind
of
put
not
and
then
all
of
the
things
that
have
kind
of
bad
stuff
in
the
history.
They've
you've
got
a
set
of
good
stuff
and
you
can
kind
of
identify
the
roots,
and
sometimes
you
have
a
kind
of
more
complex
case
where
somebody
is
kind
of
like
separately
imported
a
bit
of
history,
or
maybe
they
merge
some
stuff
and
so
you've
got
term.
A
Some
can
I
genuine
root
commits
are
bad
or
that
got
big
objects
and
you've
got
kind
of
other
commits
which
are
not
genuine
roots,
but
they
have
also
introduced
bad
commits
anyway.
Whichever
way
you
do
it
you
can.
You
can
find
these
these
these
virtual
roots,
by
doing
sort
of
a
rev
list
recipe.
Where
you
look
at
all
of
the
kind
of
old
bad
history.
A
You
exclude
everything,
that's
new,
so
that's
where
you
get
rid
of
the
common
history,
which
is
that's
okay
to
have
in
your
history
and
then
you
can
kind
of
walk
this
in
reverse
order,
and
you
just
retain
any
commit.
If
so,
you
retain
the
kind
of
first
commits
you
come
across
in
this
Rev
list,
and
you
just
discard
anything
if
you've
already
got
one
of
the
parents
of
a
new
commissioned
and
usually
what
you
find.
A
Until
you
hit
something
that's
in
the
commit
map,
you
know
you're
going
to
hit
something
because
you've
already
got
had
that
question
you
know.
Is
there
bad
history
in
the
square?
You've
already
answered
that
in
the
affirmative?
If
you
know
that
you
are
going
to
hit
something
in
the
commit
map
at
some
point
and
then
you
can
kind
of
have
a
look
and
say
well
what
does
this
some?
You
know
what
I
want
to
move
this
local
history
to
this
local
branch
to
new
history.
What's
the
corresponding
new
commit
that
I
move
it
to?
A
If
you
don't
have
a
commit
map,
but
you've
used
bfgs
you've
got
exactly
the
same
shape
of
the
repository.
If
you
do
a
sorry,
one
thing
I've
got
to
mention
earlier
when
you
do
the
rewrite
it.
So
it's
a
really
good
idea
to
tag
all
of
the
tips
before
rewrite
and
all
of
the
tips
after
me
right
if
you
lose
a
kind
of
recipe
like
you
know,
if
you
give
all
of
the
pre
rewrite,
history
is
quite
a
pre-filter
dash
branch
name.
A
Then,
if
you
use
describe
minus
minus
contains
you
can
kind
of
get
this
like
recipe
of
what
this
merge
base
is
relative
to
one
of
the
tips,
because
local
branches
aren't
always
conveniently
based
on
the
kind
of
latest
version
of
mass
that
you
tries
to
rewrite
and
if
you've
kept
exactly
the
same
shape
of
history.
You
can
just
take
the
kind
of
like
this,
so
this
some
tilde
10
thing,
which
is
kind
of
just
like
telling
you
like
how
to
walk
the
history,
to
find
a
merge
base.
A
A
That
doesn't
need
to
be
moved
and
the
other
way
you
can
do
is
you
can
actually
give
your
users,
hopefully
wrapped
up
in
a
script,
something
that
just
runs
exactly
the
same
filter
branch,
but
just
on
the
limited
history
since
the
old
one
and
the
good
thing
about
this
is
like,
even
if
the
they've
kind
of
merged
in
some
other
stuff,
so
that
so
the
the
graphs
a
bit
funny.
If
you
actually
do
rewrite
something,
that's
already
been
written
because
filter
branch
is
completely
deterministic.
A
It
will
just
kind
of
map
to
a
commit
that
sir,
that
already
exists.
So
so
it's
actually
kind
of
safer
than
it
might
seem
giving
your
evening.
I
uses
the
power
of
filter
branch,
so
I've,
actually
just
a
got
permission
to
open
sort
of
some
of
the
tools
that
that
make
some
of
this
a
bit
get
a
little
easier
going
to
write
me
off
in
a
few
scripts.
So
you
can
find
that
on
github
com,
/,
Bloomberg,
/,
repo
factor,
sorry
that
doesn't
appear
in
a
slide.
I
was
only
kind
of
finalized.
A
Got
that
information
after
my
made
by
Floyd's,
slides
fine,
and
hopefully
these
are
some
of
the
ideas
in
this
talk,
and
some
of
these
tools
should
help
you
kind
of
a
with
these
sort
of
three
things.
So
finding
large
objects
in
repositories
and
therefore
enabling
you
to
make
that
decision
is
a
rewrite
of
history
worthwhile.
Is
it
going
to
get
me?
A
Is
it
going
to
get
me
performance?
Is
it
going
to
kind
of
help?
People
complain
less
when
they
kind
of
clone
and
stuff,
then
there's
sort
of
tools
to
help.
You
actually
do
that.
Raptor
rewrite
get
a
new
version
of
your
repository,
it's
going
to
eliminate
it
a
whole
lot
of
craft
and
then
finally,
we've
got
some
kind
of
a
tools
to
help
users
kind
of
migrate
to
the
new
stuff.
A
One
thing
that
I
haven't
actually
mentioned
and
I
was
going
to
mention-
was
a
git
LFS,
so
the
bfg
repo,
cleaner
kind
of
natively
now
allows
you
to
kind
of
take
large
objects
in
your
history
and
and
convert
them
to
point
files
and
push
the
push
the
corresponding
stuff
out
to
an
NFS
store.
You
can
also
do
that
with
filter
branch.