►
From YouTube: Git Aliases of the Gods! - Git Merge 2017
Description
Tim Pettersen is a Bitbucket developer by day, and Git evangelist by night.
In the first section of his talk, he'll cover the nuts and bolts of creating aliases including parameter handling, incorporating multiple commands in the same alias, and tweaking the behavior of Git through options, environment, and inline configuration overrides.
Then he'll move on to the fun part: a bestiary of aliases. Tim has scoured dark corners of the web, freenode, and social media to uncover mystic aliases that perform every function from automating standup meetings to "I'm feeling lucky" searches across the DAG. He breaks apart each alias in turn, and dissects their guts to understand how they do what they do.
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
So
I'm
Tim
I'm
a
developer
attached
to
the
bitbucket
team
at
Atlassian,
we're
being
for
about
10
years.
I
spent
the
last
seven
or
eight
of
those
working
on
out.get
based
tools,
fit
bucket
bitbucket
server,
source
tree
and
JIRA's
version
control.
Integration.
Today,
I'm
actually
going
to
be
talking
about
a
little-known
subsystem
of
gift
called
aliasing.
Now
how
many
people
here
have
written
they
get
alias
before
Oh,
brilliant?
It's
like
most
of
the
audience.
A
A
Now
this
is
great,
saves
you,
a
few
keystrokes
makes
it
feel
a
little
bit
more
like
subversion,
but
at
the
end
of
the
day,
all
it
does
is
save
you
a
tiny
bit
of
time,
but
anything
actually
solves
a
huge
problem
that
the
get
open-source
project
has
now
git
has
huge
velocity.
There
were
five
major
releases
last
year
and
each
release
had
hundreds
of
features.
A
It
has
ironclad
backwards,
compatibility
and
guarantees,
which
is
awesome
for
tool
vendors
like
ourselves,
because
it
means
that
we
don't
have
to
rush
out
critical
patches
every
time
in
your
relationship
get
lands
in
order
to
make
sure
that
our
products
keep
working
and
it's
great
for
users
as
well,
because
it
means
that
the
core
fundamental
workings
of
get
don't
change
every
time
you
upgrade,
which
is
great
if
you
have
to
upgrade
five
times
a
year.
But
this
huge
velocity
and
backwards
compatibility
come
to
a
bit
of
a
paradox.
A
How
do
you
ship
hundreds
of
improvements
to
a
command-line
tool
without
breaking
backwards?
Compatibility
well
with
git
you've
got
a
few
different
options.
You
can
introduce
new
sub
commands.
You
can
create
new
options
to
use
in
conjunction
with
those
commands
or
you
can
create
new
config
properties
and
get
uses
a
combination
of
all
three
of
these
things
in
order
to
ship
new
features.
The
downside
of
this
is
the
git.
Now
has
hundreds
of
commands
that
you
can
use
thousands
of
options
and
thousands
of
config
properties
to
customize
the
behavior
of
get
now.
A
People
often
complain,
as
some
of
the
speakers
earlier,
that
the
git
man
pages
are
hard
to
navigate
and
actually
think
they.
You
know
some
of
the
some
of
the
terminology
is
a
little
bit
confusing
and
obtuse.
But
if
you
read
through
the
git
glossary,
you
realize
that
they
get
bad
pages
are
actually
extremely
well-written
and
structured.
A
The
only
problem
is
this
over
both
because
they
have
to
document
all
of
these
different
tweaks
that
you
can
make
to
the
git
commands
when
you
run
them
so
take,
for
example,
the
git
stash
command,
which
Santiago
was
speaking,
expect
about
at
length
this
morning
now
get
stash
the
handy
tool
that
lets
you
squirrel
away
changes.
So
you
can
go
and
work
on
something
else,
and
if
you've
made
some
changes
to
an
existing
file,
that's
already
tracked
by
git,
then
it
works
fine.
A
A
However,
for
novice
get
users
or
myself
up
until
about
a
week
ago,
if
you
create
a
new
file
in
your
working
copy,
which
seems
like
a
fairly
innocuous
operation
and
then
you
run
gifts,
oops
won't
actually
do
anything,
and
this
is
because
and
it'll
actually-
and
this
is
because
the
change
that
you've
made
by
creating
a
new
file
is
creating
an
untracked
file,
but
it
doesn't
actually
consider
when
it
runs
in
its
vanilla
mode.
The
reason
for
this
is
that
gets
these
changes
in
your
work
tree
in
one
of
four
fundamentally
separate
steps.
A
They
can
be
changes
to
attract
file
that
are
either
unstaged
or
staged.
There
can
be
changes
to
an
untracked
file
or,
basically,
the
creation
of
a
new
file,
and
they
go.
They
can
be
changes
to
an
ignored
file
that
you've
explicitly
told
gift
not
to
care
about
so
get
stash
run
in
its
vanilla
mode
will
only
operate
on
unstaged
and
stage
changes
to
files
that
are
already
tracked.
A
So
a
lot
of
developers
when
they
first
come
when
I
first
coming
to
get
grips
with.
Gift
will
overcome
this
deficiency
by
running
by
adding
all
of
their
changes
to
the
index
and
then
running
get
stash,
but
this
is
a
bit
of
a
hack
because
it
means
that
your
index
kind
of
gets
messed
with
and
when
you
apply
it,
when
you
pop
or
apply
a
special
later
on,
then
you
know
you
don't
quite
have
the
true
state
of
where
you
want
it
to
be
as
a
work
in
progress.
A
So
the
actual
correct
way
to
do
this
is
to
use
the
include
untracked
flag,
which
actually
stashes
your
untracked
changes
as
a
separate
area
enough
stash,
and
then
you
can
reapply,
though,
is
correctly
later
on
so
you've
got
to
kind
of
keep
in
you.
Keep
in
your
mind,
so
there's
two
different
ways
of
running
stash
in
a
stash
or
stash
include
on
track.
Now,
that's
not
too
hard
to
remember,
but
then,
while
perusing
the
men
they
get
mad
pages
I
realize
that
there's
also
a
old
flag.
A
You
can
use
as
well
to
include
your
ignore
files
as
part
of
your
stash.
Now
this
is
fantastic
because
it
means
you
can
fully
switch
context.
So
if
you've
ignored
build
artifacts
and
log
files,
they
will
come
along
into
your
stash
as
well,
and
you
can
pull
those
back
out
of
your
stash
with
stash
pop
rather
than
having
to
regenerate
those
again
from
your
source
and
there's
also
another
flag
called
keep
index,
and
this
actually
pairs
down
what
stashed
and
only
stashes
changes
that
haven't
yet
been
added
to
your
index.
A
So
this
is
great
if
you
want
to
commit
just
some
of
your
changes
and
as
saved
the
rest
of
your
work
tree
for
later
so
now,
we've
got
a
bunch
of
different
options
that
are
slightly
harder
for
a
map
to
remember,
at
least
for
me,
it's
not
that
they're
named
badly.
They
do
exactly
what
they
say.
They
do,
but
I
still
find
myself
going
back
to
the
man
pages
or
googling,
when
I
need
to
figure
out
what
one
of
how
to
do.
A
I
just
remember
that
it's
gets
dish
with
the
Kiwi
accent,
but
if
I
want
to
stash
everything
and
revert
back
to
basically
what
my
repository
looked
like
when
I
coined
it
I
do
it
gets
and
I
have
a
clean
work
trip
to
go
and
reproduce
problems
in
production
or
starting.
Your
feature
branch,
so
I
hope
I've
Illustrated
that
stat
that
are
creating
aliases
doesn't
just
save
you
keystrokes.
A
So
you
can
use
git
as
well
to
share
these
aliases
with
the
rest
of
your
team
or
the
general
public.
So
when
you
create
an
alias
using
git
config,
it
actually
gets
stored
in
your
global,
get
configuration
usually
sitting
at
the
root
of
your
user
directory
and
by
default
it's
just
stored
as
the
sub
command
and
options
that
get
passed
to
the
get
binary.
What
you
invoke
the
alias
we
can
actually
create
slightly
more
complicated
aliases
that
chain
different
commands
together.
A
So
this
is
an
example
of
an
alias
called
which
I'm
not
quite
I,
tried
to
chase
down
where
this
alias
originally
came.
For.
I
came
from
I
didn't
write
it.
Someone
on
my
team
had
it
sitting
in
their
git
config
file,
but
it's
like
I,
don't
quite
know
how
to
attribute
this
to
basically
what
it
does
is
it
searches
the
contents
of
your
world,
it
searches
the
names
of
your
branches
and
then
outputs
them.
So
it's
just
basically
piping.
A
The
output
of
git
branch
to
grab
now
get
gets
a
leasing
system
supports
parameters,
so
anything
that
you
tack
on
to
the
end
of
your
alias
indication,
gets
passed
to
the
under
command
to
the
underlying
alias
command
string.
So,
for
example,
if
I
was
looking
for
branch
related
to
a
JIRA
issue
that
I'm
working
on
I
could
use
this
to
try
and
track
down
that
branch.
A
So
the
way
that
this
alias
works
is
that
we've
prefixed
it
with
a
bang
and
that's
that's
basically
killing
gets,
rather
than
pass
the
string
to
get
to
evaluate
instead
drop
out
to
my
shell
and
get
it
to
evaluate
the
string
instead.
And
that
means
that
we
can
use
things
like
arguments
or
sorry
use
positional
arguments
which
we'll
look
at
in
a
second,
and
you
can
also
use
pipes
and
other
non
get
binaries
as
part
of
our
tool
chain.
A
So,
let's
extend
that
which
alias
with
another
one
called
lucky
now
this
this
alias
get
lucky
is
actually
building
on
top
of
our
which
alias
bypassing
the
output
of
which
to
get
check
out.
So
it's
basically
emulating
the
I'm
feeling
lucky
functionality
on
Google.
So,
instead
of
just
searching
for
branches,
it's
actually
going
to
check
out
the
first
one
that
appliance
now.
This
is
using
positional
parameters
or
positional
arguments
so
actually
evaluating
dollar
one
using
gel
or
batch
syntax
and
pausing
by
passing
that
into
the
get
check
out
command.
A
Now
this
doesn't
work
as
I've
written
it
here,
because
the
dollar,
because,
although
it
does
evaluate
dollar
one
correctly,
it
also
appends
the
arguments
at
the
end
of
the
command
string.
So
we'd
end
up
with
something
that
looks
like
get
check
out:
0
7,
0
7,
which
is
invalid
syntax,
so
they
could
check
out
command.
A
So
if
you
get
a
write,
an
alias
that
uses
positional
parameters
like
this,
then
you
actually
need
to
wrap
it
in
single
quotes,
so
git
doesn't
evaluate
it
and
then
pass
it
to
your
shell,
along
with
a
dash
at
the
end,
so
the
arguments
get
passed
through
and
your
shell
will
evaluate
it,
for
you.
Don't
worry
too
much
about
remembering
why
this
is
a
problem.
Just
remember
that
if
you
need
to
use
parameters,
wrap
it
in
single
quotes,
pass
it
a
shell
and
you'll,
be
fine.
A
So
it's
not
just
about
using
arguments
explicitly
supplied
by
the
user.
You
can
also
use
environment
variables
as
well.
So
this
is
an
alias
called
get
stand-up.
How
many
people
have
a
stand-up
meeting
once
a
day
about
the
same
number
of
people,
almost
everybody?
So
what
this
does
is
it
gives
me
a
prompt
for
what
I'm
going
to
say
to
the
rest
of
my
team
at
stand
up
by
showing
me
all
the
commits
that
I've
created
on
any
branch.
A
That's
what
the
old
flag
does
for
log
by
the
current
user,
which
is
me
so
it
actually
tests.
The
author
string
associated
age
commit
to
make
sure
it
contains
my
username
and
then
it's
using
the
relatives,
date/time
supported
by
git,
there's,
actually
a
fascinating
topic
in,
but
in
itself
hasn't
really
sophisticated
bite
time
pausing.
So
it's
going
to
show
any
commits
that
I've
created
since
last
time.
We
had
stand
up
and
then
it's
mangle
it
well,
no
mangling
its
truncating,
the
format
of
the
output.
A
To
only
show
me
the
subject
line
of
my
commit
message,
which
is
the
first
line,
so
this
works
great
and
the
output
looks
a
little
bit
like
this.
So
I
have
a
nice
human
possible
output
for
to
share
with
my
team,
but
I
decided
you
can
actually
automate
this
further
with
a
lazy
stand-up,
alias
that
pipes,
the
output
that
gets
stand
up
to
a
speech,
synthesis
command
like
say
on
OS
X.
So
this
works
great.
A
If
you
have
s
if
you're
a
remote
worker-
and
you
have
SSH
access
to
like
a
machine
somewhere
in
your
team
area
that
has
speakers,
for
example
your
team's
wall
board,
and
then
you
have
this
ghostly
disembodied
voice,
telling
everyone
that
stand
up
what
Tim
did
yesterday.
So
that's
basically
all
you
need
to
know
about
building
aliases,
to
remember
the
bank's
syntax,
remember
back
into
environment
variables
and
it
works.
So
now
I've
got
a
rough
idea
of
how
to
do
it.
A
You
weren't
able
to
push
and
pull
to
your
repositories,
which
sounds
great
until
you're,
stuck
in
the
middle
of
those
53
minutes
trying
to
get
code
on
some
to
someone
else's
machine
now
get
being
a
distributed
version.
Control
system
actually
has
a
built-in
get
server
that
you
can
use
called
the
get
Damon
now
like
many
git
commands,
the
get
Damon
has
a
set
of
somewhat
unintuitive
options,
so
I
always
end
up
kind
of
having
to
Google
how
to
use
it.
A
I
want
to
invoke
it
actually
and
a
little
aside,
if
you
find
yourself
repeatedly
googling
for
get
commands,
that's
a
really
good
opportunity
to
turn
that
into
an
alias.
So
you
don't
have
to
go
in
search
for
that
later
on
now,
when
you
run
the
get
demon,
it
starts
serving
your
local
repository
over
the
get
default
port,
which
is
nine
four
one
eight,
and
by
default
it's
pretty
rudimentary
it's
read-only.
You
can
actually
make
it
writable.
A
That's
not
the
grades,
not
a
great
idea,
because
it's
also
on
authenticated,
but
anyone
who
has
access
to
that
port
on
your
machine
can
now
clone
your
repository.
Unfortunately,
if
you
have
remote
team
workers
or
depending
on
your
local
network
setup,
you
may
not
actually
be
able
to
access
your
colleagues
point
nine
for
one
days,
so
I've
built
a
little
alias
that
works
around
this
problem
using
a
tool
called
an
grog.
A
Does
anyone
use
then
grukk,
fantastic,
Oh,
brilliant,
okay,
maybe
a
third
of
the
audience
so
that,
for
the
risk
of
the
rest
of
you,
Angra
is
a
little
tool
for
creating
a
secure
tunnel
from
a
local
port
on
your
machine
to
a
public
website
as
a
subdomain
under
end
Rock,
Dyer,
waingro
comm.
Basically,
you
can
copy
and
paste
that
URL
and
share
it
with
a
teammate
and
they
can
access
that
port
as
if
it
was
on
as
if
their
direct
access
to
your
machine.
A
So
it's
great
if
you're
a
web
application
developer
and
you're
trying
to
share
code
with
clients
or
anyone
else
who
wants
to
access
your
web
server.
Now
they
actually
also
support
arbitrary
TCP
tunneling,
so
get
end.
Rock
actually
starts
off
a
little
local,
get
daemon
and
then
starts
up
and
drunk
and
proxies
your
local
repository
out
to
the
public
Internet
via
the
git
protocol.
So
you
can
just
copy
and
paste
that
URL
send
it
to
someone
and
they
can
clone
your
work.
A
So
it
feels
kind
of
like
I'm
trying
to
put
out
put
the
bitbucket
out
of
business
by
showing
you
this,
but
it's
a
good
way
to
share
code.
In
a
pinch
now,
you
do
have
the
same
restrictions
in
that
by
default,
it's
going
to
be
read-only
and
it
is
also
unauthenticated.
So,
although
these
URLs
aren't
listed
anywhere
except
your
local
machine,
it's
a
pretty
easy
URL
to
guess.
If
you're
doing
some
port
scanning
I,
think
n
Grove
does
have
a
white
listing
feature
that
lets.
You
basically
prevent
unexpected
IPS
from
accessing
it.
A
We
looked
on
the
other
slide
to
invoke
the
get
Damon
and
then
we're
using
a
single
ampersand
to
fork
another
process
in
grok
to
start
it
up
in
tcp
mode
to
proxy
that
get
pipe
out,
and
then
we
have
a
couple
of
other
niceties
to
hit
the
local
end.
Rock
API,
so
I
only
just
found
out
about
this
thing,
but
n
grukk
actually
spins
up
a
little
application
server
locally,
that
you
can
query
via
rest
to
find
information
about
their
local
tunnels
and
then
so.
A
It
grabs
the
public
URL
of
that
tunnel
and
prints
that
out
on
the
command
line,
to
do
this
I'm,
actually
using
another
little
tool
called
JQ,
which
is
great
if
you're
building
aliases
that
need
to
interact
with
other
services
that
have
REST
API
s.
It's
basically
like
a
little
command
line,
pausing
and
assembling
tool
for
Jason
that
I
highly
recommend.
Now
you
might
be
looking
at
this
slide
and
you'd
be
forgiven
for
thinking
that
this
isn't
actually
a
talk
about
get
aliasing.
A
This
guy's
just
giving
me
a
tutorial
on
batch
programming,
so
definitely
not
what
I
signed
up
for
and
you're
absolutely
right.
At
the
end
of
the
day,
these
aliases
are
just
bash
scripts
that
are
invoked
via
the
get
binary.
So
you
get
a
sort
of
philosophical
question
about
when
should
I
create
an
alias
and
get,
and
when
should
I,
create
an
alias
and
bash,
and
really
it's
all
about
context
and
name
spacing
to
invoke
one
of
these
aliases.
You
have
to
prefix
it
with
git.
A
So
basically
my
philosophy
is
you
get
aliases
for
good
operations
and
bash
aliases
for
anything
else,
and
the
corollary,
if
that
is,
if
it
doesn't
use
the
git
command
or
it
doesn't
touch
the
dot
git
directory
that
it
probably
shouldn't
be
a
good,
alias
so
I
stopped
for
a
little
bit
too
fast.
But
another
cool
use
to
forget
aliases
is
that
you
can
use
them
to
interact
with
services
that
enhance
the
good
experience
or
build
on
top
of
get
like
that
bucket.
A
Now,
if
you're
a
bit
bucket
user,
you
may
have
noticed
in
the
left-hand
nav
for
last
few
months.
You've
had
this
little
pipeline's
link
and
if
your
team's
enable
this,
you
will
have
started
seeing
build
statuses
showing
up
in
the
right-hand
side,
because
pipelines
is
our
new
CIS
CD
tool
built
directly
into
bitbucket.
A
Now
we
built
the
bucket
you
know:
I
was
very
busy
I
CD
in
bitbucket
as
pipelines,
because
one
of
the
help
teams,
with
a
bucket
with
their
DevOps
tool
chains,
we
wanted
to
make
it
ridiculously
simple
to
start
getting
your
code
tested
and
deployed
in
an
easy
manner,
and
basically
it's
integrated
right
into
the
bit
bucket
UX.
So
you
can
see
all
your
build
results
and
so
on
pull
requests
and
branches
and
actually
inspect
your
logs
and
jump
back
and
forth
between
source
and
builds
really
easily.
A
Now
the
way
that
bitbucket
pipelines
is
configured
is
you
create
a
little
llamo
file
in
the
root
of
your
repository,
specify
a
docker
image
as
your
build
environment
and
then
create
some
steps
that
are
run
every
time
you
push
changes
to
the
server.
We
also
have
this
feature
where
it
been
a
less
sort
of
continuous
manner.
A
You
can
specify
custom
builds
that
do
things
like
ad-hoc
deployments,
if
you're
not
quite
ready
for
continuous
deployment
or
run
heavyweight
jobs
that
you
want
to
do
whenever
you
don't
want
to
on
every
hit
every
commit
like
static
analysis
or
publishing
documentation
or
any
of
those
other
things
that
you
have
script
up,
that
maybe
don't
want
to
run
every
commit.
Now
the
bucket
has
a
fairly
simple
UI
for
triggering
these
deployments.
A
We
can
click
from
a
commit
and
hit
the
deploy
button,
but
there's
a
lot
of
the
time
when
I'm
thinking
about
doing
one
of
these
jobs,
like
deployments
I'm
actually
in
my
gift
terminal,
I
thought
it'd
be
fun
to
write
an
alias
that
hits
the
pipeline
REST
API
to
deploy
a
commit
for
me
now.
This
has
a
couple
of
advantages
over
doing
it
by
the
bitbucket
UI
as
well.
A
So,
for
example,
I
can
use
get
pipeline
to
deploy
a
specific,
commit
or
I
can
use
it
to
deploy
a
specific
cat
or
deploy
the
documentation
for
a
specific
tag
or
I
can
run
static.
Analysis
against
a
feature
branch
that
I'm
currently
working
on
now.
A
lot
of
these
tools
that
you
might
want
to
integrate
get
with
don't
necessarily
have
the
full
dag
when
they're
working
with
building.
Now
when
there
are
working
on
servicing
your
rest
requests,
every
bucket
pipelines
does,
but
in
some
cases
you
might
actually
have
to
turn
these
commit
commit
issues.
A
This
was
basically
a
shorthand
for
a
commit
or
something
that
can
be
dereferenced
to
a
particular
commit
into
a
commit
char.
So
there's
a
tool
that
gets
ships
with
called
Rev
paths,
which
is
kind
of
used
under
the
hood
for
turning
what
you've
provided
at
the
command
line
into
a
char
one
which
can
be
used
by
the
rest
of
git.
And
so
this
can
do
things
like
translate
short
chars,
translate,
feature
branches
or
any
other
refs
like
an
tags
or
even
annotated
tags.
Things
like
ref
log
short
names.
A
So
a
couple
of
people
made
passing
references
to
wrote
it
to
the
rep
log,
but
basically
it
keeps
a
log
of
the
state
of
every
branch
that
you've
had
locally
and
then
records.
How
that's
changed
over
time
and
you
actually
use
a
ref
log
short
name
to
say,
hey,
tell
me
what
the
value
of
my
master
branch
was
yesterday
and
rev
possible
turn
that
into
a
commit
ID,
which
you
can
then
pass
on
to
a
service.
A
We
can
also
do
things
like
ancestry,
references
as
well
to
describe
a
commit,
that's
related
to
another
commit,
and
all
of
these
will
just
put
out
put
that
sha-1
hash
as
a
commitment
now,
git
also
has
a
sister
command
called
rev
list,
which
does
much
the
same
thing
in
terms
of
translating
shell
ones,
but
it
also
shows
you,
but
it'll
also
show
you
every
commit
in
that
range,
so,
whether
you're
using
double
dot,
syntax
or
triple
dot,
syntax.
Basically,
anything
you
can
pass
to
get
log.
A
You
can
pass
the
Rev
list
to
get
a
list
of
commits
that
traverse
your
dag.
We
use
this
pretty
heavily
behind-the-scenes
input
bucket
for
a
number
of
different
operations,
but
I
found
I
actually
use
this
to
create
a
second
script
called
pipelines
that
will
trigger
a
particular
job
or
a
particular
pipeline.
A
Rather
for
a
series
of
commits
now,
you
might
wonder
why
you
would
possibly
want
to
run
the
same
pipeline
against
a
series
of
commits,
let's
just
close,
that
thought
there
for
a
second,
and
let
me
talk
about
a
little
scenario
that
you
might
find
yourself
in.
Imagine
you're
a
developer
and
you
pulled
master
at
the
beginning
of
the
day
and
then
you
created
some
new
commits
and
you
want
to
push
them
to
the
server.
A
Now
you
go
and
check
the
bucket
pipelines
and
you
see
that
the
current
tip
of
master
is
passing
the
tests
so
you're
safe
to
push
we're
not
doing
feature
branching
for
simplicity
here,
which
is
committing
straight
to
master.
So
when
we
push,
we
wait
a
couple
of
minutes
and
we
get
a
notification
from
duplicate
pipeline
saying
that
our
latest
build
has
failed.
A
Now,
we've
got
a
bit
of
a
problem
because
there's
five
potential
commits
here
that
introduced
that
failing
change,
and
wouldn't
it
be
nice
if
we
could
do
some
sort
of
binary
search
over
our
history
and
find
out
which
one
caused
the
problem
now
git
actually
has
a
built-in
command.
That
does
that.
Does
anyone
know
what
I'm
talking
about
bisect?
Yes,
git
bisect,
that's
right!
So
you
can
actually
run
git
bisect
hafsat
the
failing
commit
hash,
so
that
would
basically
be
the
tip
of
Master
as
it
is
on
the
server
and
then
pass
it.
A
The
last
node
in
green
built,
which
is
actually
the
tip
from
before
we
pushed
for
bonus
points.
Can
anyone
tell
me
what
the
big
oak
complexity
is
of
a
binary
search
log,
an
very
nice?
So
this
way
this
is
basically
a
complexity
of
log
n.
So
our
expected
time
to
find
the
failing
test
is,
however,
long.
It
takes
to
our
test
to
run
times
log
n,
which
is
the
number
of
commits
log
5.
A
So
that's
great
and
that's
actually
an
incredibly
efficient
way
in
order
to
pair
down
and
figure
out
where
this
problem
was
introduced,
but
it
turns
out
we
can
brute-force
our
tests
using
get
pipelines
and
run
the
tests
for
every
single
commit
in
that
range
simultaneously
and
find
our
tests
in
that
find
our
failing
tests
in
T,
which
is
the
length
of
the
test
run
now.
Of
course,
this
is
horrific,
ly
inefficient
in
terms
of
being
the
little
CPUs
in
AWS
that
are
crunching
QR
code,
but
from
the
perspective
of
the
developer
sitting
there.
A
This
is
actually
great
I've
saved
myself.
Log
n
attempts
at
attempting
to
find
that
broken
test,
and
we
can
use
that
same
ref.
Log
short,
M
syntax
that
I
was
talking
about
before,
to
specify
exactly
the
commits
or
the
commit
range
from
the
commits
that
we
just
pushed
before,
and
the
commits
that
were
at
the
tip
of
Master
beforehand,
and
it
will
come
back
and
tell
us
exactly
which
commit
broke
those
tests.
A
A
So
the
pipeline,
alias,
is
a
interesting,
so
there's
two
try
and
make
it
sort
of
production
is
shift,
ran
in
some
environment
validation
to
make
sure
you
set
your
bit
bucket
credentials
and
some
dependency
checks
to
make
sure
you've
got
that
JQ
tool
installed
locally,
and
then
we've
got
some
horrific,
embedded
jason,
which
is
a
payload
to
the
bit
bucket
pipeline's
API
and
writing
these
scripts.
In
line
in
my
gift,
config
had
a
bit
of
a
strange
effect
on
me.
A
It
was
about
about
when
I
was
trying
to
figure
out
whether
I
needed
three
or
four
or
five
back
slashes
to
escape.
Those
Jason
quotes
that
I
started
regret,
submitting
get
aliases
as
the
topic
to
get
merge,
but
then
I
realized
you
don't
actually
have
to
write
aliases
as
aliases
fact
you
can
extend
get
by
creating
scripts.
A
This
is
a
much
more
maintainable
way
to
write
scripts
to
illustrate
this
I
want
to
show
you
one
last
little
tool
that
I
bought
for
this
talk
now
I
want
you
to
tell
me
if
you
can
see
anything
strange
about
this
screenshot
other
than
the
emojis
and
the
current
messages.
Now
this
is
a
screenshot
from
bitbucket.
It
has
been
cropped
a
little
bit
that
it
has
not
otherwise
been
tampered
with.
Can
once
anything
a
bit
weird
about
this.
A
Yes,
the
SHA
ones.
Look
a
bit
strange
now.
This
is
very
strange
because
I'm
sure
most
of
you
are
aware,
shell,
what
are
the
shell
one
commit
IDs
or
an
actual
sha-1
hash
of
the
contents
of
that
commit?
And
yet
here
we
have
these
monotonically
increasing,
commit
number
numbers
throughout
our
commit
messages.
This
is
very
strange
indeed,
because
sha-1
is,
you
know,
evenly
distribute
well,
they
well
distributed
hash
to
be
secure
and
actually
comes
down
to
those
emojis.
We
built
another
little
tool
called
get
sham.
A
That
takes
a
regular
expression
and
then
it
rewrites
your
the
latest
commit
message
from
the
tip
commit
of
your
repository
by
appending
three
different
emojis
to
it
in
random
order,
and
then
it
keeps
doing
that
until
it
finds
a
sha-1
that
matches
the
regular
expression
that
you
passed
in.
So
this
is
fantastic.
If
you
are.
A
For
example,
the
bitbucket
server
for
one
for
release
coming
up
thought
it
might
be
nice
to
celebrate
with
a
little
custom
show
that
started
with
for
one,
for
this
is
a
bit
weird
philosophically,
because
git
is
content-addressable,
but
now
the
sha-1
hash
sort
of
represents
that
content
as
well.
It's
a
good
bit
of
a
mindfuck
anyway.
A
This
is
horrific.
Do
not
use
this
under
any
circumstances,
but
writing
this
tool,
despite
how
evil
it
is,
was
much
more
pleasant
because
I
just
wrote
as
little
script
put
it
on
my
path.
Had
nice
syntax
highlighting
from
my
IDE,
also
a
giant
array
of
emojis
actually
couldn't
figure
out
a
way
like
there's
no
sort
of
contiguous
range
in
Unicode
of
emojis
that
you
can
use.
A
So
it's
just
like
a
hard-coded
array,
at
least
that
I
can
figure
out,
and
this
is
really
good,
because
brute-forcing
chars
is
horrific,
ly
expensive,
so
I
could
actually
basically
you're
running
like
a
little
small-scale,
Bitcoin
mining
operation.
Every
time
you
run
this
command
so
means
I
could
re-implement
this
in
C
and
then
you
know
just
have
that
commit
that
binary
is
sitting
on
my
path
and
as
long
as
it's
executable,
gif
will
find
it
and
run
for
us
now.
A
I
mentioned
before
that,
sharing
aliases
is
really
simple
and
it
is
so
I've
put
all
of
the
aliases
I
spoke
about
today.
I've
been
this
bitbucket
repository,
there's
a
short
link
on
the
next
slide.
So
don't
worry
about
writing
that
down
and
then
you
can
actually
include
this
if
you
quote
it
locally,
using
a
git,
config,
Inc
Lee.
A
So
if
you
put
in
quit
and
include
sections
with
the
path
property,
then
it
will
actually
include
that
config
files
wholesale
inside
your
git
config,
now
a
little
obvious
word
of
warning:
don't
go
including
random
stuff
in
your
git
config
from
the
internet.
If
you
are,
you
can
totally
trust
me
there.
A
You
can
also
use
it
to
change
commands
with
other
awesome,
UNIX
tools
and
other
binaries
of
your
own,
devising
too
some
really
cool
stuff,
and
that
it's
really
easy
to
share
these
tools
with
the
rest
of
your
team
using
git.
So
thank
you
very
much
for
your
time.
You
can
go
check
out
the
aliases
at
Bly,
Adela's,
n,
grukk
and
JQ,
and
now
indispensable
parts
of
my
workflow.
So
if
your
web
developer
absolutely
check
out
and
rocket
awesome
and
Jake
is
a
lot
of
fun
too,
you
can
check
out
get
Shann,
don't
do
it.