►
From YouTube: What’s Wrong With Git? - Git Merge 2017
Description
Santiago Perez De Rosso is a PhD student in the Software Design Group at MIT. In this talk, he will apply a new theory of design that focuses on the purposes and concepts underlying software, to explain well-known difficulties with Git---and suggest ways in which Git could be made easier to learn and use.
About GitMerge
Git Merge is the pre-eminent Git-focused conference: a full-day offering technical content and user case studies, plus a day of workshops for Git users of all levels. Git Merge is dedicated to amplifying new voices in the Git community and to showcasing the most thought-provoking projects from contributors, maintainers and community managers around the world. Find out more at git-merge.com
A
A
Now
none
of
these
claims
have
been
disputed,
but
one
that
is
easy
to
learn
and
I'm
going
to
show
you
some
results
from
from
surveys
conducted
by
other
researchers
and
by
the
geek
community
that
dispute
this
claim
that
git
is
easy
to
learn.
For
example,
the
authors
of
this
paper
conducted
a
study
in
which
they
interviewed
engineers
at
Google
and
Autodesk
to
study
the
effect
of
hidden
dependencies
on
version
control
and
the
term
heal
dependency
comes
from
the
cognitive
dimensions
framework.
A
So
first
they
found
that
users
had
low
confidence
in
gear
were,
for
example,
even
one
of
the
most
experienced
get
users
requested
that
someone
else
perform
an
operation
on
the
repo
because
he
or
she
was
scared
about
the
consequences
of
running
the
git
command.
Now,
if
you
argued,
Pro
you'd
probably
find
this
bossing,
but
how
could
someone
be
uncertain
of
the
consequences
of
running
a
good
command
when
it
is,
after
all,
very
clear
what
commands
do
from
the
documentation
right
I
mean
take
the
documentation
for
git.
A
A
Or
this
one
get,
this
single
street
distinguish
a
few
non
clean,
remove
trees
inside
various
red
listed
up
streams,
and
this
is
my
favorite,
and
this
one
is
very
useful.
Maybe
if
you're
working
with
some
models,
you've
used
it
before
decontrol
stash
control,
some
non
bundles,
stay
stashes
or
over
any
chance
of
modules.
A
Alright,
so
maybe
by
now
you
view
you
might
have
realized
I've
been
tricking
you
under
the
list.
The
last
three
comments
were
fake
and
maybe,
if
you're
a
good
expert-
and
we
based
make
sense
to
you,
but
to
most
users,
especially
novices-
it
probably
makes
as
much
sense
as
key
control
stash
now
going
back
to
the
observations
on
that
study.
A
A
So
this
also
evidence
that
get
is
not
easy
to
learn
it.
Surveys
conducted
by
the
key
community,
for
example,
there
was
a
question
in
the
2012
get
user
survey
that
asked
what
do
you
hate
about
git
and
if
you
look
through
the
responses,
you'll
find
things
such
as
the
the
fact
that
is
too
complex
for
many
users,
that
it
requires
a
steep
learning
curve
for
new,
with
dark
corners
and
so
on.
Here's
another
question.
A
Why
people
why
many
people
find
it
scary
and
hard
to
learn
in
use?
So
now
has
been
researchers.
We
really
wanted
to
get
to
the
bottom
of
this
and
put
forward
a
hypothesis
for
what's
wrong
with
kid
and
hopefully
extract
larger
lessons
about
software
design
in
the
process.
So
I'm
going
to
show
you
some
more
show
you
three
examples
of
problems
encountered
by
gig
users,
and
these
are
related
to
switching
branches,
the
detached
head
state
and
then
tracking
or
ignoring,
attract
filing
it.
A
A
So
it
apparently
all
makes
sense
if
you
think
of
branches
as
n-dimensional
membranes
mapping
the
spatial
loci
of
successive
commits
onto
the
projected
manifold
of
each
clone
repo.
Okay.
So
maybe
this
explanation
of
branches
make
sense
to
some
of
you,
but
for
the
rest,
I'm
going
to
keep
a
quick
overview
of
how
branching
working
it.
So
a
branch
is
a
pointer
to
a
commit,
for
example,
in
this
repo
we
have
master
branch
suppose
to
commit
to
write.
A
You
can
now
create
a
new
branch,
develop
and
switch
to
it,
and
if
you
make
a
new
commit,
then
this
new
commit
belongs
to
branch,
develop
only
awesome,
okay.
Now,
here's
a
problem
with
switching
branches,
as
exemplified
by
this
stack
overflow
question
and
basically
what's
going
on
here-
is
that
the
user
wants
to
switch,
but
uncommitted
changes
in
the
working
directory
and
or
staging
area
prevent
the
user.
From
doing
so,
the
project
has
sensors
only
one
working
directory
on
staging
area.
Any
uncommitted
changes
are
conflict
with
what
on
the
destination
branch
will
prevent
a
switch.
A
So
what
could
you
do
if
you
find
yourself
in
the
situation?
Well,
you
could
create
a
new
commit
with
and
finish
work,
but
this
committee
will
not
represent
a
logical
group
of
changes
since
for
similarly
you're
in
the
middle
of
doing
some
work
right.
So
if
you
actually
care
about
having
a
tidy
coming
history,
I,
probably
should
you
come
to
amend
this
committee
afterwards.
A
Another
Tara
tip
is
to
stash
your
changes,
and
this
is
probably
what
most
of
you
may
be
doing
the
situation
and
it
works
well
in
most
cases,
but
if,
for
example,
you're
shuffling
between
multiple
tasks,
it
gets
hard
to
remember
and
apply
the
correct
stash
that
corresponds
to
the
ranch
you're.
Switching
to
you
can
start
naming
them
and
so
on
by
gets
quite
hairy,
and
even
so,
if
you're
in
the
middle
of
a
merge,
then
stashing
doesn't
work.
A
A
A
A
So
that
is
what
happens
if
you
have
a
file
is
commit
in
the
repo
which
you
now
want
to
ignore
and
track.
Well,
so,
as
you
also,
as
the
author
of
this
question,
did
you
can
try
to
modify
the
get
ignore
file,
but
that
doesn't
work
and
a
solution
to
this
problem.
At
least
one
of
the
potential
solutions
to
this
problem
is
to
mark
the
file
as
assumed
then
change.
Actually,
the
current
advice
is
to
use
a
skip,
work
through
flag,
but
anyways
to
most
people
uses
human
change
instead.
A
Okay,
so
to
determine
how
closely
these
problems
I
talked
about
some
others
that
we
identified
in
our
in
the
study.
We
conducted
much
the
problems
our
users
experiencing.
In
practice,
we
performed
a
manual
analysis
of
Stack
Overflow
posts,
so
we
tell
you
by
finding
all
questions
tagged
with
a
keyword
gear.
A
We
then
filter
out
all
questions
except
those
with
more
than
30
uploads,
and
we
then
examined
by
hand
all
the
remaining
questions
to
determine
whether
or
not
the
issue
being
asked
about
was
related
to
one
of
the
problems
we
identify
and,
for
example,
for
switching
branches.
We
found
three
questions
with
over
500,000
views
for
detached
head.
We
found
seven
questions
with
over
1.1
million
views
and
one
tracking
file.
We
found
15
questions
with
over
1.5
million
views.
A
We
did
this
in
a
few
months
ago,
so
numbers
are
probably
higher
now,
but
you
hopefully
get
an
idea
of
how
real
this
bonus
appeared
to
be.
So,
let's
try
to
understand.
What's
going
on
here.
First,
let
me
point
out
that
I've
actually
never
talked
about
the
UI.
I've
never
talked
about
I,
never
said
anything
about
a
flag
being
inconsistent
or
a
command
having
a
weird
name
or
so,
although
all
of
the
points
I
mentioned
are
related
to
this
concept,
such
as
branch
head
and
so
on,
and
how
they
interact
with
each
other.
A
A
So
a
key
aspect
of
the
theory
is
the
notion
of
a
concept
which
is
something
you
need
to
understand:
to
use
it
as
an
application
as
something
a
developer
needs
to
understand
to
work
effectively
with
its
code,
so,
for
example,
for
Twitter
the
notion
of
I
use
and,
and
it
would
be
concept
while
class,
assuming
that
they
use
say
some
object
or
in
the
languages.
So
we
know
the
a
concept
is
the
user
of
Twitter
doesn't
need
to
be
concerned
with
that
at
all?
A
On
the
other
hand,
the
notion
of
a
class
would
be
a
concept
in
Python,
because
it's
a
user
of
Python.
You
need
to
understand
what
a
class
is
in
order
to
use
the
language
same
for
module,
but
other
notions
such
as
up
code.
The
implementation
details
will
not
be
constants,
I
call
such
custom
motivating
purpose,
which
is
a
reason
why
it's
there
in
the
first
place.
So,
for
example,
for
the
trash
can
in
your
house,
the
purpose
is
to
serve
as
a
staging
area
for
trash.
A
You
don't
want
to
have
to
every
time
you
need
to
throw
something
away.
You
know,
go
out
of
your
house
and
put
in
the
bins
outside,
so
you
collect
trash
in
the
trash
can,
and
then
you
take
it
out
one
of
yourself.
On
the
other
hand,
the
purpose
of
the
trash
can
in
your
operating
system
is
to
allow
deletions
to
be
undone.
So
if
you
delete
a
5
a
mistake,
you
can
recover
it
easily
an
operational
midst.
A
The
mystery
would
be
that
if
you
delete
a
file
by
mistake-
and
you
cannot
remember
its
name-
then
there
is
not
a
noisy
way
to
find
the
file
you
have
to
scroll
through
all
the
files
to
find
it.
So
it
may
not
be
possible
to
a
story
now
in
some
cases
I
miss.
It
might
be
remedied
by
a
small
change
in
the
design
of
the
concept
and
actually
in
recent
versions
of
Mac
OS.
It
doesn't
happen
anymore.
A
They
fix
the
misses
by
adding
the
deletion
data
sort
of
metadata
but
misses
my
also
singer
signal.
A
deeper
issue
dies
now
is
easily
resolved
and
ideally
you'd
like
to
identify
these
misfits
as
early
as
possible
and
which
lead
us
to
this
criteria
for
concert
design,
and
this
represents
situations
you
would
like
to
avoid
and
an
arrow
here.
The
note
relates
a
concept
with
its
motivating
purpose
and
the
arrow
simply
denotes
that
there's
an
interference
between
them.
A
Ok,
so
now,
let's
apply
the
theory
to
get
to
attempt
to
provide
an
explanation
of
what's
going
wrong
with
getting
the
situation's.
So
the
first
step
is
to
establish
a
set
of
key
purposes
for
version
control,
and
the
goal
here
is
to
establish
a
kind
of
benchmark
for
a
generic
version.
Control
system
against
which
beat
can
be
evaluated,
and
hopefully
it's
kind
of
make
sense
to
use,
by
the
reasons
why
you
use
version
control
system.
A
Ok,
so
let's
go
back
to
our
misfit
and
use
the
theory
to
explain.
What's
going
on
the
message:
switching
branches
is
caused
by
the
violation
of
the
coupling
criterion
between
the
working
by
the
working
directory
staging
area
and
branch,
because
the
working
directory
and
staging
area
are
interfering
with
the
fulfillment
of
the
motivating
of
purpose
of
the
concept
of
a
branch
that
is
to
support
parallel
development.
You
want
to
switch
to
some
other
parallel
tasks
and
you
cannot
and
to
so
the
workaround.
This
problem.
Many
people
have
said
you
stashing.
A
A
So,
if
you're
the
creator
of
the
software,
then
you
simply
no,
but
in
this
case
since
we
are
evaluating
an
application
that
was
created
by
others,
we
need
to
rely
on
sources
such
as
the
official
documentation
and
popular
grid.
References
like
the
gate
book,
so
here's
the
description
of
stashing
and
if
we
look
at
the
good
stash
documentation,
you
see
that
it
quickly
points
out
the
saving
of
the
of
the
changes
and
cleaning
of
the
working
directory
and
stationery.
A
A
You
could
argue
that
it
is
a
sub
purpose
of
of
making
a
set
of
changes
persistent.
But
what
is
issue
that
you're?
Indeed,
saving
changes
the
ones
in
your
working
directory
in
staging
area
are
being
stashed.
This
doesn't
account
for
the
cleaning
of
the
uncommitted
changes
which,
as
we've
seen
it's
a
crucial
aspect
of
stashing.
A
You
could
argue
that
I
should
be
a
sub
purpose
of
supporting
parallel
development,
because
fashion
is
letting
you
switch
and
later
can
synchronize
between
two
implicit
lines
of
development,
one
that
represent
one.
That
essentially
has
the
incremental
changes
you
want
to
save
and
the
other
one
that
consists
of
any
new
changes
that
to
be
pooled
or
developed.
But
these
are
hardly
genuine
lines
of
development
and
I
said
more.
A
Like
ad
hoc
states
of
branches,
maybe
you'd
say
that
this
clean
up
the
working
directory
was
saving
the
uncommitted
changes
should
be
right
up
there
as
a
high-level
purpose
for
version
control,
but
this
seems
wrong
too,
when
you're
selling
version
control
to
someone
you're
not
going
to
say
that
you
should
use
a
version
control
system,
because
you
have
stashing
that
lets
you
clean
up
your
working
directory.
While
save
your
uncommitted
changes
right,
most
people
are
most
people.
Reactions
may
be
like.
Why
would
I
even
want
that
in
the
first
place
right?
A
A
We
have
a
coupling
problem
since
the
head
and
detached
from
a
branch
and
point
directly
to
a
commit.
The
user
can
create
a
new
line
of
development
and
there's
no
reference
by
any
branch,
and
that
is
hard
to
switch
back
on
from
two-for-one
tracking
file.
The
problem
is
that
assume
line
change,
an
ignored
violate
the
non
division
criteria.
The
same
purpose
is
to
prevent
the
accidental
commit
of
a
fire
motivate
for
the
concept
of
an
ignored
file
and
as
human
change
file.
A
So
the
user
needs
to
learn
another
concept
and
a
separate
set
of
commands
to
the
same
thing
that
in
or
mechanism
provides
now.
This
is
actually
not
what
assumed
and
change
was
initially
designed
for.
It
was
intended
to
use
as
a
performance,
optimization
right-back
achieves
been
attributed
by
users
as
a
way
to
ignore
track
5.
A
A
So
it's
a
version
control
system
built
on
top
of
in
another
portion
of
cane.
It
presents
a
different
console
model
to
the
user
and
I'd
like
to
clarify
that
that
I
said
before
it
is
an
experiment
that,
if
you
don't
claim
Gillis
occupies
an
ideal
point
in
the
concert
design
space.
There
are
actually
many
different
ways
in
which
you
can
fix
a
message,
but
I'll
show
you
what
we
did
in
Gillis.
A
So
let's
talk
about
branching
in
business,
so
in
business,
a
branch,
it's
a
completely
independent
line
of
development.
Each
branch
includes
the
working
version
of
files.
That
is,
it
is
as
if
there's
one
working
directory
per
branch
and
also
maintains
the
information
of
any
sync
operations
in
sync
operation,
such
as
a
merge
and
so
in
progress.
So
even
during
merges
that
the
resolving
conflicts,
the
user
is
still
working
on
the
original
branch
and
can
switch
to
another
branch
and
then
go
back
to
fixing
concepts
later.
A
A
We
have
we
have
flexible
commits
we
have
sexual
commit
commander,
has
flags
from
most
of
these
common
use
cases,
so
we
have
like
a
peace
flag
like
it's
coming,
be
our
concept
of
branch
eliminates
the
need
for
stashing,
so
there's
no
stashing
in
business,
because
essentially,
you
can
switch
between
the
branches
without
any
any
interference
and
for
the
touch
head.
We
so
so
basically
gives
us.
There
is
no
possible
way
of
getting
in
that
detached
head
state
at
any
time.
A
So
we
conducted
a
small
user
study
and
each
of
the
eleven
participants
we
recruited
did
a
session
using
it
and
another
one,
using
goodness
note
that,
while
all
of
the
participants
have
used
git
before
they
were
encountering
giblets
for
the
first
time,
so
the
task
we
asked
them
to
perform
are
listed
there
on
the
right.
All
the
tasks
were
in
the
context
of
a
result
so,
and
we
measured
a
bunch
of
things
but
I
like
to
focus
on
the
results.
A
Comparing
kid
with
kid
less,
and
if
you
want
to
learn
about
the
other
results
you
can
go.
Google
paper
I
have
a
link
to
it
in
the
end
of
the
representation.
Okay.
So,
at
the
end
of
the
second
session,
also
we're
done
doing
session
using
gear
and
the
other
one
using
kid
less.
Sometimes
they
started
using
get
learns
and
so
on.
A
We
ask
them
to
complete
a
question
and
comparing
Gillis
with
kit
and
overall
participants
enjoyed
using
goodness
and
found
it
easier
to
learn
and
use,
but
when
asked
if
they,
but
when
asked
if
they
will
continue
using
Gillis,
if
they
could,
the
results
are
somewhat
split.
So
some,
for
example,
show
concern
about
its
power,
which
is
not
surprising,
since
Gillis
is
just
a
prototype
while
give
has
been
used
for
over
ten
years
right.
So
there's
a
lot
of
functionality
built
in
there.
A
A
So,
of
course,
it
doesn't
mean
you
know,
get
less
is
better
than
get
the
study
focused
only
on
misses
and
only
on
this
problems
that
we
identified
and
did
so
in
a
controlled
environment.
A
full
evaluation
of
a
version
control
system
would
require
testing
in
the
context
of
darks
projects
with
complex
requirements
and
so
on.
Yet,
at
the
very
least,
the
resource
formal
study
provides
some
empirical
evidence
that
our
redesign
efforts
were
fruitful
and
that
this
approach
of
focusing
on
purposes
and
concept
might
be
a
good
way
of
making
it
easier
to
learn
and
use.
A
So
I've
shown
you
how
we
can
use
the
theory,
this
theory
of
concert,
design
to
really
sign
gear,
so
this
issue
to
learn
and
use,
but
the
same
approach
could
be
used
to
design
new
gig
postings
that
look
more
like
a
different
version
control
system
rather
than
a
new
gig
client.
There
are.
There
are
many
good
clients
right
from
those
that
have
a
graphical
user
interface
to
those
with
a
command-line
interface,
which
includes
your
aliases
and
so
on,
but
for
the
most
part,
these
make
largely
cosmetic
changes.
A
They
have
the
same
concept,
for
example,
a
branch
being
appointed
or
commit
or
having
the
concept
of
stash
and
so
on,
but
they
presented
differently
and
I
believe
there's
an
opportunity
to
go
deeper
and
develop
new,
get
forces
that
are
really
more
like
a
new
version
control
system,
rather
than
a
new
UI
to
get
I've
talked
about
what
we
did
with
kids.
Less,
but
that's
just
one
way
of
fixing
the
problems.
Maybe
you
have
a
better
idea
of
how
to
rework
the
concepts
to
fix
the
problems.
A
I've
talked
about
and
I
think
there's
also
an
opportunity
to
create
version
control
systems
built
on
top
of
k2
have
a
set
of
concepts
that
are
specialized
to
a
particular
domain.
For
example,
what
would
a
version
control
system
that
is
designed
for
writing?
Research
papers?
Writing
research
papers.
Look
like
what
concepts
would
such
a
system
have
or
what
about?
If
you
want
something
that
is
specifically
tailored
to
your
company's
needs?