►
Description
Presented by Stephen Hathaway, User Experience Designer, Effective Inc.
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
So
hopefully
by
that
in
bliss,
you
guys
will
kind
of
know
what
that
is,
but
with
that
I
also
kind
of
want
to
know
like
from
a
development
perspective
like
whenever
you
do
get
deliveries
like
it
can
be
kind
of
cumbersome
right
and
often
or
not.
You
have
components
that
mismatch
or
don't
you
know,
look
coherent
together
and
that
might
look
something
like
this
right
like.
A
So
these
are
all
just
different
features
that
we
have
to
build
out
right
and
then,
with
that
we
have
numerous
designers
in
these
files.
So
we
have
like
blaine
over
here
on
the
left,
and
then
we
have
like
patricia
in
the
middle
over
on
the
right
and
were
siloed
out
into
these
individual
design
files,
and
whenever
we
do
that,
we
also
have
to
then
audit
all
of
our
design
systems
and
see
which
buttons
are
right
and
which
ones
are
wrong.
And
then
we
have
to
go
through
and
say
all
right.
A
The
button
on
the
left
hand
side.
That's
the
button
that
we
want
in
our
whole
design
system,
and
then
we
have
to
do
that
through
all
of
our
files.
So
we
go
through
every
file
we
find
which
button
is
wrong
and
then
we
change
all
of
those
buttons.
And
then
we
have
to
merge
those
into
a
master
file,
and
this
master
file
is
what
we
typically
hand
off
to
a
development
team.
A
A
It's
like
it's.
You
know
a
lot
quicker,
it's
it's
a
better
process
for
us
to
go
ahead
and
hand
off
to
development
teams,
and
some
of
you
might
be
thinking
like
congratulations,
designers,
you're.
Finally,
starting
to
automate
your
work
like
it's,
you
know,
taking
you
20
years
to
do
it
and,
like
I,
am
happy
that
we
are
starting
to
do
it,
but
we
didn't
stop
there.
A
So
that's
kind
of
an
issue
right,
and
so
we
started
to
go
over
to
my
file
and
say:
hey
Blaine,
here's
the
button
that
you
should
have
in
there
and
please
swap
that
out,
like
for
the
sanity
of
myself
and
for
the
development
teams,
and
then
we
can
merge
that
into
the
master
right
like
it's
still
we're
not
automating,
yet
we're
kind
of
automating.
It's
like
a
pseudo
automation
and
then
libraries
came
out
and
what
libraries
did
is
to
say.
A
We
had
that
current
workflow
of
taking
each
one
of
these
individual
files
and
then
merging
that
into
the
master
to
hand
off.
We
decided
to
turn
that
on
its
head,
so
a
library
what's
stored
in
the
library
is
all
of
the
different
instances
of
a
button
or
a
navigation
piece,
a
card,
and
what
that
does
is
once
we
have
all
of
that
information
inside
of
the
library.
We
can
then
disperse
that
to
the
different
feature
files.
So
it's
no
longer
going
back
into
the
master
library.
A
It's
now
the
the
library
is
pushing
all
the
information
back
out
and
whenever
we
make
a
change,
it
actually
visually
shows
what
is
being
changed
so
over.
Here
we
have
on
the
left-hand
side,
the
old
button
and
then
different
instances
of
that
button.
So
we
have
a
default:
an
active
state,
a
disabled
state,
a
hover
state,
all
the
different
states
right
and
we've
made
changes
to
each
one
of
those.
Then
we
can
input
the
new
one
and
update
all
those
symbols
across
all
of
our
files.
A
So
it
looks
something
like
this
Blaine
over
here.
He
constantly
doesn't
update
his
symbol
library.
So
now
we
can
just
instantly
say
like
Blaine
you're,
getting
that
update
like
you,
you
constantly
don't
keep
up
with
our
you
know
current
design
system,
but
now
we're
automating
it
to
say
like
nope,
you're
gonna
be
inline
with
it
and
I'm
sure.
A
Some
of
you
have
felt
some
of
this
pain
of
asking
a
designer,
hey,
where's
where's,
the
latest
file,
or
what
is
the
latest
button
style,
for
example,
and
you
might
have
a
face
like
this,
while
you're
asking
for
it,
because
you
need
to
get
your
work
done
and
I
apologize,
it's
cumbersome
and
a
lot
of
that
is
because
we
get
really
creative
about
our
file
names.
So
we
have
like
a
new
sketch
file
a
new
file.
A
We
have
that
master
file
or
the
library
file
and
then
underneath
that
we
have
the
different
features
and
then
within
that
features
folder
we
have
a
features
name
folder
select
be
like
the
law,
game,
folder
exam,
for
example,
and
then
within
that
feature,
folder
we
have
what
is
considered
the
feature
name.
So
this
could
be
a
login
or
something
like
that
and
we
kind
of
realized
okay.
A
Well,
maybe
we
need
to
version
control
that,
like
maybe
we
can
add
that
the
back
of
it
and
then
maybe
we
can
add
the
editor
of
the
person
who
actually
built
this
file.
Okay,
maybe
we're
getting
somewhere
and
then
within
that
we
you
start
to
realize
that
we
have
different
people
that
touch
these
files
right.
A
So
we
have
me
a
co-worker
another
co-worker
and
within
that
you
could
have
like
v-0
that
one
is
H
or
V
zero
dot,
one
dot
s
M,
and
what
that
actually
ends
up
looking
like
is
this
is
a
file
format
or
a
filesystem
on
a
previous
project.
As
on
tour,
we
have
like
our
design,
folder
and
then
within
that
we
have
all
the
different
features
and
then
to
add
some
more
complexity
to
it.
We
have
which
platform
at
lib
done
so
Android
iOS
web
desktop
web
mobile.
A
Then
we
have
an
output
and
in
that
source
file
that
I
recently
showed
an
archive
just
to
hide
all
of
the
different
versions
that
we
have
touched
and
then
the
current
file
that
we're
building.
So
yet
that's
terrible
right
like
why.
Why
do
we
have
500
files
and
it's
it's
a
disaster,
and
with
that
like
I
I
mean
this
is
where
get
is
like
I'm
sure
one?
Some
of
you
are
wondering
like
when
are
we
gonna
get
to
get?
This
is
where
get
can
actually
help
right
so
over
the
last
year.
A
The
question
that
I
have
constantly
been
asked
myself
is
what,
if
designers
you
know,
could
build
a
design
system
within
one
file.
So
what
if
our
final
output
was
just
one
one
final
delivery
to
our
clients
or
to
our
product
team,
and
what
that
would
actually
mean
is
it
be
a
drastic
shift
in
the
design
community?
A
So,
as
some
of
you
probably
are
wondering,
okay,
whenever
you
get
an
illustrator
file
or
sketch
file,
it's
binary
right
and
how
do
you
version
control
binary?
Well,
you
can't,
but
sketch
changed
that
so
within
sketch
it
actually
now
is
just
a
compilation
of
JSON
files.
So
once
you
break
down
that
sketch
file,
it's
just
JSON
and
then
once
you
can
do
with
that,
JSON
is
you
can?
A
Then
we
have
what
that
file
actually
looks
like
so
it's
you
know
images
pages
and
then
all
the
different
JSON
files
and
then
once
it
actually
is
into
a
repository.
And
so
how
did
we
do
this
I
created
this
shell
script
that
actually
breaks
down
that
sketch
file
it?
Essentially,
what
this
is
doing
is
it's:
it's
unzipping,
sketch
grabbing
all
of
the
JSON
files
and
then
removing
like
the
sketch
format
and
then
putting
them
into
nice
little
documents
for
us
or
a
folder
format
in
here.
A
This
is
kind
of
just
showing
what
it
looks
like
in
a
terminal
which
you
guys
are
very
familiar
with,
as
a
designer
I
was
not
incredibly
familiar
with
it.
It's
a
very
powerful
tool
that
I'm
not
used
to
like
I
am
now,
but
it
was
not
at
first
and
that
final
output,
like
I
said,
is
these
JSON
files
and
then,
when
we
need
to
recreate
that
sketch
file,
we
essentially
reverse
what
we
did
before.
A
So
we
take
that
JSON
data
and
make
a
sketch
file
for
us
and
again
this
is
kind
of
what
it
looks
like
in
that
terminal
mode,
and
we
get
now.
You
can
see
that
there's
two
little
folders
up
there,
so
we
have
the
features,
live,
features
folder,
our
library,
folder,
and
then
you
can
see
we
now
have
to
sketch
files.
So
those
sketch
files
is
where,
like
designers
or
your
design
team
can
actually
jump
in
make
edits
and
change.
A
Then
we
can
then
take
that
data
and
send
it
back
up
to
github,
and
this
is
what's
great
about
this-
is
instead
of
using,
like
a
library,
format,
we're
still
using
libraries
to
kind
of
oversee
a
lot
of
our
process.
But
what
ends
up
happening
is
in
that
features
file
we
have
all
of
our
logins
and
then
we
also
have
all
the
like
back
data
from
that's
now,
living
on
github
to
recreate,
say
a
version
0.1,
which
is
you
know,
pretty
cool
for
us.
A
A
A
So
here
we
have
our
master
branch
and
we
can
kind
of
pull
off
of
that
into
a
separate
design
branch.
And
then,
within
that
you
know,
you
can
start
to
branch
out
to
your
specific
feature,
file
or
feature
branches,
and
what
that
really
kind
of
to
illustrate
what
that's
doing
in
within
our
files
is
say.
We
have
Blaine
over
here
in
a
feature
file.
A
He
can
go
ahead
and
start
to
create
this
graphic
and,
like
great,
that's,
a
great
graphic
Blaine,
and
he
feels
like
he's
done
with
it.
He
can
actually
then
merge
that
into
what
would
be
the
single
source
of
truth
and
say:
I
wanted
to
make
changes
to
that.
I
can
then
say
hell
yeah
we're
in
the
same
file.
Finally,
which
has
never
been
done
before
and
like
design
like
figma,
has
kind
of
started
to
do
this.
A
But
it's
not
it's
not
been
done
before
it's
where
we're
actually
are
collaborating
on
one
file,
and
so
that's
pretty
exciting.
I
can
branch
off
and
do
that
and
I
can
merge
that
back
into
that
single
source
of
truth,
which
is
you
know,
a
giant
change
for
our
industry
and
to
kind
of
illustrate
that
some
more
so
we
have
all
these
different
branches
running
these
feature
branches.
A
We
can
merge
that
into
a
design
branch
which
then
gives
us
that
final
output
and
again
like
previously,
we
had
to
go
through
all
these
different
feature:
files
and
audit
each
one
individually.
Now
we
can
actually
just
give
off
one
file
instead
of
having
to
audit
each
individual
files.
Make
sure
everything
is
perfectly
fine,
then
somehow
get
that
into
the
master
file
and
hand
that
off-
and
this
disaster
now
starts
to
look
like
this,
which
is
a
lot
better
for
all
of
us
to
communicate
as
a
community
right
like.
A
If
your
designers
now
can
say
it's
in
this
file,
then
we
know
that's
where
it
lives
right,
but
I
will
say
something
within
the
design
industry
is.
This
is
going
to
be
a
really
challenging
thing.
Get
is
new
to
us,
like
so
changing
the
whole
industry
like
design
history
over
to
a
workflow
like
this.
Is
going
to
take
time
so,
please,
you
know
patience
with
us,
we're
still
really
late
to
this
party,
but
it's
it's
pretty
exciting.
A
From
my
point
of
view,
like
I
I'm
really
excited
to
see
like
now,
we
can
actually
work
on
the
same.
You
know
technologies
as
development
teams.
You
know
and
we
can
visually
represent,
what
we're
trying
to
get
done,
but
to
kind
of
reiterate,
all
of
this
was
really
new
to
my
whole
team,
like
get
a
nit,
get
branching
get
check,
outs
get
commit,
like
all
of
that.
It
even
till
this
day,
like
I'm
in
terminal
and
I'm
kind
of
like
oh
crap.
A
That's
easy,
then
check
out
that
branch
you
want
to
work
out
and
if
the
branch
doesn't
exist,
just
go
ahead
and
create
one
for
yourself
like
it's
totally
fine
or
if
there's
an
issue,
you
know
start
a
branch
from
that
issue
once
you
finish
that
commit
that
and
then
we'll
do
a
pull
request
and
we
didn't
get
to
the
pull
request
before
I
got.
This
look
like
and
right
like
this
is
a
massive
shift
in
our
industry
and.
A
Hopefully
we're
getting
there
like,
we
are,
but
like
it's
it's
definitely
it
that's
the
look
that
we're
getting
a
lot
and
over
the
course
of
the
next
year.
What
I'm
really
excited
about
is
that
we
can
actually
work
together,
and
you
know
I'm
hoping
to
lean
into
this
community
to
explain
it
like
all
these
get
workflows
for
designers,
that
this
is
new
to
us
and,
as
you
can
already
imagine,
get
a
it
can
be
difficult.
A
I
remember
last
year,
I
was
watching
a
talk
that
was
just
showing
what
was
wrong
with
git,
which
was
like
a
lot
of
self-deprecation,
which
was
kind
of
hilarious,
because
I
had
just
started
learning
it
at
that
time
and
I
was
like
man.
This
thing
sucks
and
now
I
love
the
thing
but
as
like,
as
you
can
imagine,
this
using
terminals
for
designer
is
probably
not
going
to
be
the
best
way
to
adopt
this.
For
us,
it's
very
cumbersome
and
confusing.
A
It
isn't
the
maybe
the
best
workflow
for
us
and
that's
totally
okay,
but
there's
some
exciting
things
that
come
out
of
this
right.
So
we
can
actually
start
to
QA
test
our
work.
So,
instead
of
manually
auditing,
every
single
component
or
button,
we
can
actually
run
a
test
on
that
whenever
I
introduce
this
to
our
dev
ops
team.
This
is
what
they're
most
excited
about.
They
were
like
holy
cow.
We
can
actually
look
at
that
JSON
file
and
see
like
this
textile
doesn't
match
the
one
previously
before
the
other
thing
we
can
do
is
again.
A
We
have
that
final
source
of
truth.
Hopefully,
questions
like
hey
where's
the
latest
file
or
which
component
has
changed
again,
why
this
component
is
different.
Hopefully
all
of
that
stops
to
exist
like
that
is
that's
waste
of
time.
That's
wasted
effort
in
a
lot
of
ways.
The
other
thing
is-
and
this
is
the
most
exciting
part
right
is.
We
are
now
using
the
same
technology
to
build
stuff
together
and
instead
of
having
design
and
development
siloed
out,
we
can
actually
kind
of
merge
that
together,
but,
like
I
said,
the
terminal
is
really
difficult
for
us.
A
The
other
thing
is,
we
can't
see
diffs.
So
this
is
what
add.
If
you
do
a
pull
request
and
as
you
can
tell
that's
not
readable
from
a
designer's
perspective,
we
probably
need
it
to
start
to
look
more
like
this,
so
we
can
actually
see
the
the
differences
that
are
you
know
within
our
design
system
and
I,
don't
know
where
that
lives.
Yet
I
have
some
ideas
that
I
can
potentially
live
with
in
an
actual
git
client.
A
The
other
thing
is
maybe
we
can
actually
build
it
directly
in
the
sketch
sketch
has
a
really
you
know,
open
API
that
we
could
potentially
start
to
do
all
of
this,
which
is
exciting,
like
if
I'm
just
able
to
do
all
of
that
within
my
designs,
you
know
software
that
could
be
perfect,
but
with
that
that's
kind
of
that's
kind
of
where
I
do
leave.
It
is
again
that's
my
name.
A
I
want
to
reach
out
to
this
community
to
build
what
could
be
a
new
workflow
for
the
design
you
know
community
and
the
development
community,
and
so
far
get
has
been
working
really
great
for
us.
We
definitely
are
excited
about
it,
but
it's
it's
new
and
I'm,
hoping
to
lean
in
and
see
what
you
guys
have,
as
you
know,
exciting
opportunities
for
all
of
us
to
work
together.
But
again,
that's
how
we
have
been
building
Design
Systems.