►
From YouTube: Empowering non-developers to use Git - Git Merge 2018
Description
Presented by William Chia, Sr. Product Manager, GitLab
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
Hey,
so
thank
you
very
much
as
they
have
mentioned.
My
name
is
William
Chia
I
do
product
marketing
at
gitlab,
and
you
can
find
me
on
twitter
with
the
handle
at
the
william
chia.
So
please
do
take
out
your
phones
and,
during
my
talk,
tweet
questions
and
comments
using
the
hashtag
get
merge
and
I
will
be
sure
to
reply
and
retweet
you
as
soon
as
I
come
off
stage,
so
to
kick
things
off.
A
What
I
would
love
to
do
is
show
an
activity
chart
of
a
few
of
my
colleagues,
so
these
charts
are
for
erica
luke,
jamie
and
chad
and
it's
showing
a
summary
of
their
issues.
Their
merge
requests,
which
is
in
get
lab.
We
call
it
a
merge
request,
same
thing
as
a
pull
request,
their
push,
events
and
comments
now
based
on
their
activity
of
these
charts.
If
you
had
to
guess
what
is
their
job
function,
what
would
you
say?
Well,
you
might
look
at
it.
You
might
say
these
folks,
they
look
very
active.
A
Well,
they
clearly
must
be
software
developers
or,
you
might
say
william.
I
already
saw
the
name
of
your
talk
so
they're.
Clearly,
not
software
developers,
if
that's
true,
then
you'd
be
right.
In
fact,
erica
manages
our
content.
Marketing
team
luke
is
a
graphic
designer
jamie
is
our
legal
counsel
and
chad
is
head
of
sales.
But
if
you
look
clearly,
these
are
folks
and
non-technical
roles,
but
looking
at
the
activity
graph,
you
can
see
they
use
a
lot
of
gitlab
and
it's
not
just
issues.
They
are
using
git
in
itself
in
a
meaningful
way.
A
So
you
probably
won't
find
them.
You
know
inspecting
tree
objects
on
the
command
line,
but
you
will
find
them
doing
things
like
branching
merging
and
committing
as
a
part
of
their
everyday
workflow
and
that's
what
this
talk
is
about:
empowering
non
developers
to
use
git.
So
in
the
next
twenty
25
minutes,
I
want
to
share
with
you
some
real-world
examples
of
non-technical
folks
using
it
along
the
way,
I'll
outline
the
technology
and
the
processes
needed
in
order
to
make
this
happen
so
that
you
can
actually
put
them
into
place
in
your
organization.
A
So
I
think
we're
all
here
at
get
merge
because
we
loved
it
right
and
most
of
us
are
either
engineering
or
have
an
engineering
background.
But
think
about
the
folks,
not
in
this
room,
think
about
the
company
where
you
work
at
and
who,
in
that
company
uses,
get
probably
your
engineering
team,
maybe
as
Steven
just
mentioned
some
of
your
design
team.
But
but
what
would
it
look
like
if
everyone
in
your
company
was
actually
able
to
use
git?
A
That's
what
I
want
to
equip
you
to
do
today
so
on
your
journey
to
evangelize,
get
to
non-developers
I
have
created
a
repo
on
get
lab
comm,
and
so
you
can
actually
go
to
get
lab.
Comm,
slash,
William,
Chia,
get
merged
2018,
and
this
repo
contains
a
copy
of
this
slide
deck,
along
with
links
to
all
of
the
resources
that
I
have
in
the
talk,
that's
fun.
A
So
here's
the
key
points
that
we're
going
to
hit.
First,
if
you're
gonna
use
version
control,
you
need
something
to
version
you
need
somewhere
to
publish
and
finally
you
need
to
stop
explosions.
So
that's
what
go
through
today.
So
a
quick
note
about
the
stack
kind
of
before
I
jump
in
at
the
lowest
level.
You've
got
get
and
then
on
top
of
git.
We
kind
of
have
these
abstractions
right
and
you
have
these
get
providers
that
offer
an
abstraction
layer
on
top
of
git
and
make
things
easier
for
you.
A
In
addition
to
that,
I'll
be
sharing
some
tech
and
some
tools
that
you
can
pair
together
with
these
providers
to
get
almost
anybody
using
it.
So,
for
this,
talk,
I'll
be
showing
what
that
looks
like
on
git
lab,
because
that's
what
I
use,
but
for
the
most
part
it
should
be
vendor
agnostic
and
if
there's
something
that
is
in
fact,
like
a
gitlab,
only
thing
I'll
try
to
call
that
out
so
step
one.
If
you're
going
to
use
distributed
version
control,
you
need
something
to
version.
A
A
My
answer
is,
of
course,
markdown
and
a
little
bit
of
yeah
Mille
as
well,
and
so
what
we're
doing
is
we're
gonna,
create
a
system
where
it's
really
easy
for
users
to
create
content
and
markdown,
instead
of
putting
that
content
in
some
other
place
like
a
Google,
Doc
or
a
PowerPoint,
and
not
only
do
we
want
to
make
that
easy
for
users
to
do,
but
we're
also
going
to
make
it
beneficial
for
them,
so
that
they're
happy
using
markdown
and
they
actually
see
a
that.
It's
benefitting
them
to
use
this
system.
A
I'll
show
you
what
I'm
talking
about
the
reason
why
we
use
markdown
is
because
it
has
these
attributes
that
makes
it
perfect
for
the
task
of
empowering
non
developers
to
use
git.
So,
first
off
it's
text-based.
This
means
that
you
can
version
it
just
like
source
code.
You
can
take
advantage
of
diffs.
You
have
the
ability
for
multiple
people
to
collaborate
on
the
same
thing
in
different
places,
but
at
the
same
time
and
then
to
bring
those
changes
together.
So
that's
awesome.
Secondly,
it's
super
easy
to
read.
A
Even
if
you
don't
know,
markdown
right,
like
I,
can
give
a
markdown
file
to
my
ten-year-old
daughter
and
she
can
kind
of
figure
out
what's
going
on,
even
if
she's
never
seen
it
before,
and
that
of
course
makes
it
very
easy
to
learn.
So
it
only
takes
about
five
minutes
for
most
folks
to
become
proficient
enough
and
markdown
to
become
productive.
So
it's
really
easy
it's
great
for
this
task.
So
how
then
do
we
evangelize
markdown?
A
Because
before
we
can
drive
get
adoption,
we
need
to
evangelize
the
component
technologies
that
are
going
to
empower
the
user.
So
here's
how
we
do
that
in
git
lab.
We
actually
use
issues
for
about
everything,
so
we
use
the
git
lab
issue
tracker
as
our
product
management.
You
know
solution,
regardless
of
whether
it's
related
to
code
or
not
so,
there's
an
issue
for
everything
at
get
lab.
For
example,
this
is
literally
an
issue
to
update
the
formatting,
a
new
format
for
our
pricing
page
and
as
a
side
note.
A
We
also
have
this
very
unique
culture
at
gate
lab
where
we're
hyper,
transparent
and
everything
is
public
by
default.
So
this
is
not
an
internal
issue.
You
can
actually
see
the
overwhelming
majority
of
our
issues
publicly
live
and
on
the
web,
including
this
one
to
update
the
formatting
of
our
pricing
page.
A
So
this
kind
of
transparency
isn't
required
to
drive
good
adoption,
but
I
highly
recommend
it.
So
everyone
I
get
lab
they're
using
get
lab
issues
and,
of
course,
in
the
issue
description
and
in
the
comments
you
can
use
markdown
to
add
formatting
and
structure
and
of
course,
we've
placed
an
easy-to-find
link
that
tells
you
it's
markdown
supported.
If
you
click
on
the
link,
then
it
takes
you
to
this
nice
file
where
it
teaches
you
exactly
how
to
use
markdown.
A
So
so
all
of
this
process
it
becomes
self-service
right
users
come
in,
they
say:
ok,
I'm,
gonna,
log
submission
somebody
do
some
project
tracking,
oh
I
can
use
this
thing
called
markdown
to
format
my
stuff
and
how
do
I
do
that?
The
reference
is
right
there.
So
before
you
know
it
folks
are
kind
of
already
spun
up
and
they're
self-serving
in
their
understanding
this.
So
once
we've
got
a
system
like
that
in
place.
A
Folks
understand
markdown
what
we
want
to
then
do
is
start
having
them
build
content
in
there
using
markdown
and
storing
it
and
get
so
that
they
can
leverage
distributed
version
control,
and
for
that
we
need
a
way
to
publish
markdown
files
into
a
styled
and
consumable
format.
So
for
that
we're
going
to
use
static,
site
generator,
so
static
site
generators
are
different
from
like
a
web
CMS
tool
or
a
single
page
application,
where
the
content
is
dynamically
generated,
with
a
static
site
generator.
A
A
One
of
them
is
that
they're
really
really
fast,
and
it
makes
your
webpages
load
very
quickly,
but
a
property
that
they
have.
That
makes
it
perfectly
suited
for
our
task
is
when
you're
using
a
static
site
generator.
It
allows
your
users
to
build
web
pages
in
markdown
and
then
the
static
site
generator
will
convert
that
into
a
beautifully
formatted,
HTML
page
with
CSS
and
everything.
So
this
is
where
we're
going
to
get
our
content
solution
down.
A
So
really,
you
have
get
Plus
markdown,
plus
your
static
site
generator,
and
that
is
going
to
become
your
content
management
system.
This
is
what
gitlab
uses
today
across
our
entire
org.
In
fact,
a
good
lab
we
use
markdown
driven
static
site
generated
content
on
our
marketing
website,
on
our
blog
on
our
handbook,
which
is
like
our
the
gitlab
handbook,
it's
kind
of
like
what
every
other
company
would
put
in
there
like
internal
private
company
wiki,
but
I
get
lab.
A
We
are
radically
transparent
and
we
take
all
of
that
content
and
we
put
it
publicly
on
the
web
for
everyone
to
read
and
it's
in
our
handbook
and
then,
of
course,
our
Docs,
so
the
marketing
site,
the
wiki,
the
blog
all
of
those
run
on
a
static
site,
generator
called
middleman,
and
then
our
Doc's
run
on
nanak.
But
you
don't
have
to
use
these
same
tools.
In
fact,
there
are
static
site
generators
in
many
languages,
including
ruby
node,
although
middleman's
also
Ruby
but
Jekyll
is
as
well
node
go
in
Python.
A
So
you
have
a
lot
of
options
here
and
these
kind
of
static
site
generators
you
can,
you
can
plug
them
in
with
varying
degrees
of
ease
into
any
type,
where
they're
using
git,
lab
or
github
or
bitbucket
VST
s.
They
will
mostly
plug-in,
and
let
you
let
you
serve
those
there's
kind
of
instructions
on
how
to
do
that.
So,
similarly,
you
don't
have
to
use
the
same
technology,
and
you
don't
have
to
do
all
of
this
content
at
once.
A
A
This
becomes
very
easy
for
authors
to
write,
content
and
markdown.
So,
for
example,
let
me
pop
up
a
post
here
that
is
from
my
friend
masya,
and
this
is
actually
a
blog
post
that
happens
to
be
about
static
site
generators.
It's
a
little
bit
meta,
so
it's
a
really
good
resource.
If
you
want
to
know
about
more
about
them,
this
will
be
linked
in
my
repo
and
what
you
can
see
is
on
every
page
on
the
git
lab
website.
A
Then
you
start
to
unlock
some
magic,
because
one
person
writing
a
blog
post
is
nice,
but
basically
there's
the
the
trade-offs
between
using
a
static
site
generated
blog
versus
having
a
CMS
blog.
If
it's
just
one
person
that
has
to
write
that
blog
there's
not
a
lot
of
difference
between
the
two.
But
what?
If?
What?
If
you
have
to
write
a
blog
where
you
need
20
offers
all
to
collaborate
on
that
blog
like
how
do
you
do
that
in
a
CMS
system?
A
So
let
me
show
you
what
a
release
post
looks
like
at
gate
lab.
So
this
is
our
most
recent
one
and
you
can
see
there's
a
lot
of
features
in
here.
We
tend
to
ship,
you
know
between
20
and
30
features
and
there's
a
lot
of
content
in
here,
and
we
do
this
every
single
month
for
every
single
feature
that
ships
you
know
screenshots
and
a
lot
of
this
content,
and
so
the
way
we
do
that
is
we
actually
collaborate
in
a
merge
request.
A
So
this
is
the
merge
request
for
that
release
post
and
you
can
see
the
process
is
pretty
involved.
It
has
a
lot
of
different
check
marks.
There's
a
lot
of
things
to
do,
there's
a
lot
of
files
that
get
edited,
but
one
of
the
things
that
I
want
to
point
out
is
that
if
you
look
at
this,
there's
29
participants
right.
A
So
in
order
to
get
this
thing
out,
the
door
29
different
folks
from
around
the
org
all
collaborated
on
this
one
blog
post,
and
if
you
look
at
it,
this
was
a
significant
amount
of
content.
There
are
a
hundred
and
thirty-eight
commits
to
this,
and
if
you
look
at
this,
there's
just
a
ton
of
different
people
who
all
got
to
collaborate
on
this
and
the
idea
here
is.
This
is
not
code
right.
You
like
you,
would
look
at
this
process
and
you
would
say
oh
yeah.
A
This
is
this
is
how
we
do
code
review
or
whatnot
especially
get
lab,
but
these
are
folks
collaborating
on
the
actual
content,
the
words
and
the
images
for
a
blog
post
and
it's
not
necessarily
related
to
code
and,
of
course,
they're
doing
it
in
markdown
and
yeah
Mille
and
doing
this
type
of
collaboration.
And
so,
if
you
really
think
about
this,
there's
no
way
to
do
this.
Without
this
kind
of
in
place
right,
we
have
to
do
this
from
scratch.
A
Every
single
month
for
every
release
post,
we
need
to
get
the
the
data
from
all
types
of
different
Forks,
all
different
places
around
the
org
people
collaborating
on
this
are
we
have
engineers
we
have
marketing,
sometimes
even
sales
people
weigh
in
so
in
order
to
make
this
happen
to
have
all
of
these
people
collaborating
concurrently
on
content.
This
is
kind
of
what
you
need,
this
static
site
generator
there's
no
way.
We
could
do
it
and
get
this
out
every
single
month.
A
This
is
pretty
awesome
right.
That's
pretty
amazing.
I
would
love
to
do
something
like
that.
I
would
love
to
have
a
step-by-step
guide
on
exactly
how
you
generate
this
release
post
and
get
everybody
in
your
Oracle
a
berate
on
a
single
thing
to
talk
about
the
the
awesome
stuff
that
you've
shipped
well.
A
It
takes
five
minutes
to
learn,
and
you
start
to
introduce
these
engineering
concepts
that
folks,
that
are
not
engineers
and
it
gets
everybody
involved
in
a
really
magical
way.
So
that
kind
of
brings
us
to
that.
You
don't
want
to
blow
stuff
up
right
because,
as
soon
as
you
start
giving
non-developers
access
to
be
able
to
commit
to
your
to
your
website,
you
know
they
might
not
be
familiar
with
everything
and
you
know.
Maybe
they
stick
some
errors
in
there.
They
didn't,
they
didn't
do
it
all
correctly,
and
your
website's
gonna
look
like
this
right.
A
So,
instead
of
that,
we
want
to
put
some
safeguards
in
place,
because
this
is
a
bad
experience
right.
It's
not
just
a
bad
experience,
because
your
website
is
down
but
think
about
think
about
the
users
that
we're
trying
to
involve
right
for
them.
They're
not
going
to
have
like
a
local
development
environment
that
they're
working
from.
If
they
got
an
error
like
this,
it
becomes
very,
very
hard
to
troubleshoot.
A
So
if
we
really
want
to
evangelize
get
to
broader
community
and
get
them
involved
in
using
version
control,
we
need
to
automate
the
testing
and
we
need
to
automate
the
deployment.
And
so,
of
course,
we
are
gonna,
do
this
with
CI
CD
pipelines
and
to
show
you
how
powerful
this
is.
I
want
to
tell
you
about
a
colleague
of
mine
that
recently
joined
get
so
when
you
join
get
one
of
the
four
that
join
get
lab
when
you
join
get
lab.
A
One
of
the
first
things
that
we
have
you
do
is
we
say,
update
the
team
page,
so
this
team
page
is
our
company
directory.
You
see
it's
got
everyone's
photo
on
here
and,
in
fact,
speaking
of
meeting
the
get
lab
team,
if
you
would
like
to
meet
Maurin
who
actually
the
way
that
this
is
structured
is
the
higher
up.
You
are
on
the
page,
the
earlier
you
were
at
the
company,
so
you
can
kind
of
see.
A
A
Mort
eats
it's
like
a
five
minute
walk
from
here
and
you
can
meet
the
get
lab
team,
but
basically
what
we
do
is
we
say
you
need
to
update
this
page
when
you
join
the
company-
and
this
is
my
new
friend
Suri,
so
she
recently
joined,
get
lab
and
she's
a
Content
Marketing
associate
and
although
she's
quite
a
talented
writer,
she
doesn't
have
a
CS
or
software
development
background.
So
this
task
of
saying
go
and
update
the
website.
This
is
the
first
time
that
she's
ever
done
something
laser
worked
with
code.
A
So
this
is
the
merge
request
that
she
created
where
she
went
and
updated
the
yamo
file
to
go
and
update
the
website
and
submitted
the
MRR
and
when
she
submitted
the
mr,
the
CI
CD
kicks
off
and,
of
course,
the
build
fails
and
so
right
away.
You
know:
she's
got
some
kind
of
indication
that
something's
wrong
here
and
it's
a
little
bit
more
user
friendly
than
you
know
everything
just
blowing
up
or
having
to
try
to
figure
out
a
dev
environment.
She
literally
can
edit
these
files
right
inside
of
the
editor.
A
A
She
was
telling
me
that
she,
she
had
put
an
@
symbol
in
her
Twitter
handle
and
we
should
look
at
everybody
else's.
She
realized
they
did
not
have
an
@
symbol,
and
so
she
removed
the
@
symbol
and
her
build
past,
and
so
really
what
you
have
is
somebody
who's,
not
a
software
developer,
figuring
out
that
they
have
a
syntax
error
and
fixing
it
all
on
their
own
completely
self
service.
It
was
pretty
impressive
and
if
we
look
at
you
know
the
actual
pipeline,
we
can
see
at
a
technical
level.
A
Okay,
well,
there's
a
problem
with
the
linter
and
if
we
zoom
in
on
the
linter,
we
can
see.
Oh
okay,
there's
actually
a
token
error
that
it
couldn't
parse
in
the
mo
file.
So
that
was
exactly
the
problem
and
now
sri
is
up
on
our
page
and
she
got
that
across
and-
and
I
think
that
this
was
kind
of
a
cool
story
when
I
heard
it
because
I
think
part
of
the
reason
that
she
was
successful
here
is
because
she's
super
sharp.
A
But
I
also
think
that
part
of
the
reason
that
she's
successful
here
is
because
the
environment
was
set
up
to
make
her
successful
and
she
had
all
these
references
to
pull
from.
So
you
may
think
of
implementing
CI
CD
pipelines
for
your
application
code.
Right
and
not
necessarily
think
of
you
know,
do
I
really
need
to
automate
test
and
deploy
on
my
blog.
But
what
I
think
is
that
this
is
a
critical
component
of
empowering
non
developers
to
use
git
and
to
make
them
successful.
A
So
one
note
about
that
is
when
we're
looking
at
the
stack
the
some
of
these
tools
have
this
implemented
a
little
bit
differently
so,
for
example,
gitlab
bitbucket
and
V
STS.
They
all
have
embedded
CI
CD
as
a
component
of
their
software,
whereas
with
github
you
actually
have
to
use
a
third-party
tool
in
order
to
use
your
CI
CD.
A
But
the
good
news
is:
is
that
gitlab
is
shipping
a
new
feature
in
the
very
next
release
on
the
22nd
of
this
month,
and
that
is
get
labs,
CI
CD
for
github,
so
you
will
actually
be
able
to
use
github
as
your
code
repository
and
you
can
use
git
lab
as
your
CI
CD,
so
that
kind
of
gets
you
up
with
CI
CD
across
all
the
platform,
so
to
wrap
things
up.
Here's
the
resource
slide
that
I
promised
you
can
find
this
presentation
and
the
links
to
everything
on
get
lab.
A
Comm,
slash,
William,
chia,
git,
merge,
2018
repo
and,
let's
kind
of
summarize
what
we
covered.
So
we
want
to
empower
non
developers
to
use
git.
So
we
need
something:
a
version
I'm
going
to
use
markdown.
We
need
somewhere
to
publish
that
implement
a
static
site
generator
and
we
need
some
way
to
stop
explosions,
leverage
the
power
of
CI,
CD
pipelines,
so
I
want
to
leave
you
with
kind
of
one
last
final
story
of
how
this
all
works
and
from
for
me,
I,
just
kind
of
want
to
share.
A
This
is
a
problem
that
I
have
right
now
that
I'm
trying
to
solve
and
the
problem
is
trying
to
version
and
collaborate
on
slide
decks
right
out
of
you've
ever
tried
to
do
this,
but
it's
really
hard,
even
if
you're,
using
a
tool
like
Google
slides,
that's
kind
of
designed
for
it.
It's
really
hard
to
get
feedback.
A
It's
really
hard
to
figure
out
who
made
which
changes
it's
really
hard
to
revert,
and
it's
literally
impossible
for
two
people
to
work
on
the
same
thing
concurrently
at
the
same
time
and
then
merge
the
product
of
that
and
do
a
single
place.
You
just
can't
do
it
and
it
becomes
a
frustration
and
it
slows
progress
because
you
can't
collaborate
and
so
what
what
can
I
do
about
it?
And
the
answer
is
you
can
version
control
your
slides
right?
A
So
there's
this
framework
called
reveal
Jas,
and
this
allows
you
to
build
content
in
markdown
and
have
that
converted
into
the
slide
decks
that
you
present.
In
fact,
this
slide
deck
that
I've
been
presenting
to
you
right
now
has
all
of
my
slides
and
all
of
my
notes,
built
in
markdown
and
I'm,
actually
serving
it
from
get
lab
pages
on
the
web.
That's
where
my
slide.
That
comes
from.
So,
if
you
look
at
the
repo,
this
is
the
slides
that
MD
file,
and
this
is
the
markdown
that
I
wrote
that
actually
generated
my
slide
deck.
A
So
my
pal
Brendan
O'leary
who's
in
charge
of
customer
training
at
git
lab.
He
was
the
first
one
who
introduced
me
this
and
he
ran
into
the
same
problem.
He
wanted
to
collaborate
on
slide
content.
It
was
really
really
hard,
and
so
he
wanted
to
make
this
version
of
Wolvie
again
and
implemented
this
slides
that
markdown
and
he
introduced
it
to
me
so
I
built
this
presentation
in
markdown
and
basically
my
next
step
is
to
start
building
more
presentations
so
that
we
can
create
a
system
where
more
folks
can
collaborate
and
start
using
it.