►
Description
So I've tried to introduce Rust at my $DAYJOB, and failed miserably.
Failure can be a great catalyst for reflection, and indeed, there was a lot of valuable lessons to be learned!
At this brief talk, I'll not only share the pitfalls to avoid, but the insights I've gained while trying to make Rust work for us (and maybe for you?).
A
Hello
good
morning,
everyone
I
am
qmx,
as
he
said,
as
she
said.
No
one
knows
me
by
Dallas
I
work
at
digitalocean
and
yeah
thanks
for
them
to
actually
bring
me
here.
I
have
a
very
important
disclaimer
to
make
at
this
very
beginning,
so
this
talk
tell
it
tells
a
story
about
how
things
went
badly
badly
wrong
and
sometimes
when
you
have
to
explain
the
reasons
why
you
came
there,
you
have
to
use
examples,
and
this
disclaimer
essentially
begs
you
a
favor.
A
Please
be
nice,
and
why
am
I
and
why
I'm
asking
this
question
and
asking
you
to
be
nice
is
that
you
know
this
is
a
very
cute.
Animal
I
mean
I,
really
love
the
golfer
and
I
have
to
talk
about
calling
problems,
because
that's
what
like
motivated
us,
I'm
trying
to
look
for
us
but
I,
really
like
calling
I
mean,
don't
take
it
personally,
it
could
be
any
other
language.
That's
just
example.
Do
you
so,
let's
get
moving,
please
leave
the
Gopher
alone.
A
We
needed
to
process
a
bunch
of
data
and
do
essentially
some
stream
processing
it
had
like
high
performance
requirements.
It
was
a
distributed
system
and
we're
going
to
build
micro
services,
and
you
can
imagine
like
this
is
like
the
buzzword.
Bingo
I
was
going
to
use
other
words
with
me,
but
whatever
so.
A
Essentially,
this
is
like
a
classic
problem
when
people
say
yes,
yes,
this
is
perfect.
Everyone's
kind
of
handles
the
same
stuff
and
this
is
Unix
with
no
G's.
No.
Actually,
this
is
:.
We
notice,
like
that's
the
standard
answer
to
that
question
in
general,
and
we
fast
forward
a
few
months
there
and
the
project
actually
was
a
success.
I
mean
we
did
a
micro
service
using
going
and
all
the
technology
that
is
there
all
the
tools
and
everything
is
happy.
It
was
running
in
production.
A
It
was
happening
in
jesting
over
4k,
very
complex
messages
over
a
car
cables,
and
that
was
it
like.
The
project
was
running.
Everything
was
happy
and
I
read
on
the
realities
that
software
is
never
ever
done,
I
mean
when
you
release
it,
then
the
party
starts
right
and
then
is
when
you
find
out
that
not
everything
is
roses,
so
we
were
running
when
production
customers
were
using
this
software
indirectly,
and
my
process,
question
and
I
have
no
idea.
A
Why,
then
that's
kind
of
like
where
you
start
learning
more
about
the
language
that
you
are
working
with
and
I
started,
looking
at
going
with
different
eyes?
Essentially,
I
have
two
strokes
there.
Nothing
special
about
them,
they're
kind
of
like
the
same
as
the
see
the
same
as
burst,
with
a
huge
difference.
I
didn't
know
at
the
time
that
the
default
value
for
structs
and
for
things
inside
stress
was
new
and
it's.
A
It
manifests
itself
in
subtle
ways,
because
when
I
kind
of
try
to
call
methods
on
a
pointer
to
a
structure,
this
pointer
can
be
nil
and
the
compiler
is
not
going
to
complain
and
of
course,
I
did
a
big
mistake.
I
had
a
new
reference
there
and
then,
when
I
called
it
is
actually
prints
wave
on
a
new
reference.
If
you
are
not
accessing
anything
on
inside
this
truck,
this
is
fine.
But
as
soon
as
you
have
data
there
boom
you're
going
to
have
a
crash
in
a
sec
fault
and
it's
a
terrible
to
debug.
A
A
This
causes
an
outage
and
it
was
my
fault,
but
whatever
it
was
annoying,
but
there
are
some
things
that
are
more
subtle
and
I
would
say
annoying,
but
not
like
life
and
death,
but
it's
so
when
we
are
trying
to
process
a
lot
of
network
metrics
and
things
going
from
a
firehose
of
events
like
we're
a
cloud
provider.
After
all,
there's
a
bunch
of
machines
there
and
suddenly
you
have
to
deal
with
a
lot
of
counters
and
those
counters.
Usually
when
it's
positive
you're
going
to
go
for
an
unsigned,
integer
64,
that's
fine!
A
But
what
is
the
difference
from
the
first
to
the
second?
One
might
be
megabits,
another
might
be
megabytes,
and
this
sounds
like
a
very
nice
mistake
right.
If
you
get
the
unit's
wrong,
everything
is
going
to
be
wrong
and
the
only
way
that
we
found
out
that
we
were
getting
things
wrong
was
because
some
customer
was
looking
at
the
charts
and
like
wait
a
minute,
it's
impossible
for
me
to
have
all
this
bandwidth,
it's
kind
of
like
yeah.
A
We
were
doing
things
wrong,
but
this
was
like
on
the
very
early
days
on
the
beta
axis
Oh
happily,
and
we
got
the
bug
before
it
went
to
generate
this,
but
there's
another
fun
one.
As
we
have
a
lot
of
networking
gear,
we
have
a
lot
of
CPUs
and
when
you
start
doing,
processing
on
Scipio
metrics,
sometimes
you
have
to
do
like
the
linear
interpolation
for
getting
the
points.
A
And
suddenly
you
have
a
bunch
of
slopes
on
a
bunch
of
counters
that
it's
a
pain,
because
you
probably
need
to
do
some
functional
programming,
style
folding
over
several
values
and,
oh
boy,
that's
rest.
Functional
support
will
be
so
nice,
so
much
better
than
my
function.
That
was
returning
a
function.
That
was
the
point
in
SLO
yeah.
A
It
was
not
cool,
so
I
have
very
one
thing:
there's
only
one
thing
that
I
really
disagree
with
go,
that's
kind
of
like
you
know,
I'm
not
going
to
talk
about
it
because
generics
I
think
it's
it's
like
even
they're
wrong.
Okay,
I
love
them
soon,
but
let's
talk
about
West
bits,
which
is
why
we
are
here
right.
A
So
it's
there
are
several
ways
of
you
introducing
a
deck
to
your
company,
and
my
approach
was
to
try
and
make
sure
that
these
we
did
things
on
as
grassroots
as
possible
and
like
not
trying
to
make
a
big
boom
not
trying
to
force
this
choice
over
anyone.
After
all,
we're
a
go,
Lang
shop,
people
love,
go
there,
that's
fine,
so
the
first
thing
I
did
was
to
create
a
highlight
for
rust
in
slack
and
then
another
one
that
was
kind
of
like
a
little
bit
more
evil.
A
It's
kind
of
like
all
the
problems
that
I
know
on
goldlink
and
on
Ruby.
We
have
Ruby
and
I
kind
of
like
I,
have
a
very
special
set
of
highlights.
So
when
people
talk
about
those
problems,
I'm
aware
of
that
and
then
I'm
not
going
to
go
like
rest
evangelism
strike
force,
please
know
like
I'm
not
going
to
ask
people
to
here
writings
in
rest,
please
no
I'm
going
to
just
be
out
work,
because
my
end
goal
is
that
we
get
better
softer
and
we
notice
those
shortcomings
can
be
addressed
in
a
better
way.
A
So
we
start
with
a
side
project.
A
very
is
more
side,
project
kind
of
like
a
toy
project,
but
the
main
difference
here
is
that
I
try
to
make
it
production
really
like
what
would
I
do
if
I
had
to
ship
this
to
production?
So
it's
not
only
like
it
compiles
it
works.
We
know
that
this
kind
of
very
true
on
rest,
like
it's
amazing
but
yeah.
A
Let's
do
more
so
it
might
sound
like
overkill,
but
if
you
keep
practicing
and
trying
to
make
things
better
and
better
and
better
they're
going
to
be
really
better,
so
the
first
project
was
actually
Agrafena
notations
data
source
API,
who
ever
ever
use
it
we're
gonna
hear
the
definition
is,
is
a
dashboard
in
ping.
It's
a
very
like
something
over
simplifying
it.
That
shows
amazing
dashboards
and
gets
parameters
metrics
and
things
from
other
sources,
and
next
I'll
show
you
nice
charts
that
helps
you
when
you're
a
page
at
2
a.m.
A
and
try
to
debug
something
it's
great,
but
those
charts
actually
don't
have
some
context
like
I
didn't,
did
a
deploy
but
I
added
an
index
to
my
database
and
then
what
is
the
effect
of
changing
another
part
of
the
system?
That's
going
to
impact,
my
application
is
going
to
reduce
CPU
usage.
The
database
database
queries
are
going
to
return
faster,
so
we
kind
of
like
put
a
marker
there
like
it's
a
bad
line
by
the
way
you're
running
through
those
diseases
on
native
feature
in
Griffin
of
five,
but
there
was
not
there
yet.
A
This
is
the
time
where
to
change
it
happened,
and
then
you
could
correlate
what
was
the
complete
behavior
of
the
application
and
it's
a
very
simple
REST
API
like
this,
could
be
like
drawn
in
20
lines
of
JavaScript
whatever,
so
we
added
parameters
metrics
this
endpoint
in
this
application
made
sure
that
we
had
all
the
data
that
were
a
big
application
would
have
like.
How
long
are
we
taking
to
write
to
the
database?
How
long
are
we
yeah
we're
just
doing
the
metrics
the
right
way
and
for
things
that
are
exceptional?
A
That
should
not
happen
on
the
normal
course.
We
have
structure
logs
and
we're
writing
to
the
centralized
logging
infrastructure
that
we
have
at
the
company,
and
not
only
that
I
made
make
sure
to
have
a
CI
CD
pipeline,
so
we
could
actually
have
the
same
practices
we
have
for
our
production
software,
but
it's
on
this
toy
project.
A
Of
course,
after
our
CI
CD
pipeline
you're
going
to
package
it,
and
we
made
sure
that
it
worked
well
with
docker
make
sure
that
we
are
caching
the
artifacts,
with
a
different
set
of
hell
when
you're
trying
to
deal
with
rust,
because,
depending
on
how
you
do
it,
every
build
is
going
to
take
forever.
Even
if
you're
just
doing
like
a
hello
world,
you
are
bringing
like
several
crates
and
suddenly
you
takes
ten
minutes,
it's
not
good
and
finally,
we
deployed
it
to
communities
it's
kind
of
like
almost
the
standard.
A
Nowadays
we
still
have
a
lot
of
mazes,
but
yeah
I
think
Cabrini's
one
and
after
you
do,
you
have
done
all
this
after
this
thing
is
running
its
own
production.
You
are
like
seeing
how
it
works,
then
you
need
to
start
asking
the
right
questions
and
what
is
annoying
to
develop
on
rest
like
how
hard
was
to
actually
build
to
the
simple
application
interest.
How
do
you
bug
this
thing?
A
It's
kind
of
like
what
are
the
failure
modes
like
what
happens
if
the
database
dies
is
application
I'm
going
to
seg
faults
and
crash?
Are
you
going
to
just
exit?
Are
going
to
try
to
recover
so
there's
a
lot
of
questions
around
this
like
how
to
board
muting
members,
like
is
learning
rust,
really
hard?
Are
people
going
to
feel
comfortable
how
about
ID
support
people?
Everyone
loves
their
predator,
like
we
know
that
there's
more
than
Vinnie
max
right.
So
essentially,
everyone
has
their
preferences.
A
A
Now
we're
going
getting
more
ambitious,
we
had
an
internal
hackathon
on
that
put
on
the
company
and
again
I
have
the
opportunity
of
replicating
the
first
system,
the
bigger
one
that
was
written
going,
which
was
like
it
stream
processing
again
reading
data
from
Kafka
and
then
I
found
the
Holy
Grail.
There's
a
very
nice
library
called
me,
Bartok
Africa,
which,
which
is
extremely
performance.
You
can
get
a
lot
of
performance
by
using
this
thing
and
I
didn't
have
to
write
it.
It's
amazing
awesome.
A
We
use
it
that,
and
we
start
parsing
a
binary
protocol
with
like
some
proprietary
stuff
yeah.
Whatever
did
this
parsing
then
do
some
real-time
analysis
over
the
stream
of
day,
it's
kind
of
like
it's
pumping
from
literally,
like
all
the
machines
that
we
have
and
getting
this
data
in
regard
impressive
performance
performance
results
by
just
trying
to
do
the
same
thing
that
we're
doing
go
but
doing
using
the
rest
machinery,
and
it
was
a
success
like
a
side
project
that
went
really
well.
A
We
had
basically
zero
problems,
awesome
and
then
we
go
to
the
third
project
and
we
get
like
amazing,
even
bigger
scope,
even
more
chances
to
fail
right.
Okay,
let's
do
a
micro
service
in
Reverse
this
time,
like
with
the
full-blown
structure,
the
idea
was
to
fold
over
a
coffee
stream
again
with
a
lot
of
machine
data
process
it
and
do
like
the
normal
operations
that
we
needed
persist.
A
The
results
so
dissing
Ovid,
Remz
databases
and
all
those
things
and
finally,
there's
another
beat
that
was
really
painful,
which
is
actually
exposing
it
via
a
RPC
API
with
something
that
it's
so
easy
to
do
in
going.
And
then,
when
you
come
to
us
and
all
now,
I
have
to
use
build
steps
and
compile
the
proto
and
generate
some
things
to
help
yeah.
Okay,
it
went
well,
it
was
a
success.
Right
I
mean
one
two
three,
the
tree
needs
to
be
a
success.
A
This
combination
of
failures
is
starts
with
a
very
interesting
problem.
We
suffered
from
the
zero
syndrome
and
I
just
realized
that
my
slides
are
not
synchronized
with
the
older
ones.
Okay,
so
sharks,
tornados,
diesel-powered
rockets,
pineapple
and
pizza.
What
those
things
have
in
common.
A
bunch
of
those
things
happen
on
the
last
rascon,
where
we
had
surgery
showing
amazing
things
on
rockets.
A
Yes,
amazing,
and
we
have
seen
same
Griffin,
also
saying
like
great
things
about
diesel
and
like
an
how
zero
cost
abstractions
are
awesome
and
all
those
things
sure,
but
when
you
add
sharks
and
tornados,
you
get
sharknado
and
you
don't
want
that.
So
essentially,
the
problem
is
when
you
jump
the
shark
pun
intended
everything
gets
complicated,
and
so,
when
you
have
zero
allocations,
like
I
wanted
to
get
the
data
straight
from
Liberty
Kafka
and
without
allocating
it
again
I
Pro,
I
parse
it
in
memory.
A
I
have
the
references
going
there
and
then
I
finally
use
this
thing
and
make
it
work
and
everything
is
awesome
and
rainbows
and
unicorns,
and
then
you
have
like
I
try
to
make
my
type
zero
size
it
and
I
go
diligently.
Making
this
work
I
push
really
hard.
My
zero
called
abstractions
and
point
went
with
zero
working
software
because
I'm
waiting.
A
So
yes,
you
sum
this
with
the
fact
that
I
was
the
only
experienced
addressed
developer
on
this
team
like
noob,
also
a
little
bit
more
than
the
other
guy.
Essentially,
my
takeaway
is
clone
away.
This
might
sound
awkward
and
even
counter
production.
Like
wait
a
minute,
we
wanted
to
use
rust
because
of
the
ownership.
You
know,
learning
things
is
complicated
and
if
you
just
clone
away
while
you're
getting
started,
you
are
still
going
to
be
miles
ahead
on
memory
safe,
it's
a
safety.
A
If
you
were
doing
my
walking
free,
it's
a
trade
off,
it's
a
it's
kind
of
like
training
wheels
for
your
bicycle,
you're,
still
learning
how
to
deal
with
the
language,
and
this
helps
a
lot
for
you
to
get
speed
up
and
get
productive
and
fun
story.
Even
cloning,
it
was
faster,
can
go
learning.
Ownership
is
not
easy.
That's
my
takeaway
I've
been
doing
risk
for
several
years
now
and
I
still
don't
get
it
properly.
I
think
it's
always
something
new.
That
surprises
me
usually
I'm
wrong.
A
That's
why
I
get
surprised
like
oh
yeah,
I
wasn't
I
wasn't
paying
that
much
attention,
but
it's
really.
He
worthy
I
had
the
pleasure
of
having
an
intern
for
this
summer
doing
a
roast
project
and
he
was
like
oh
wait.
A
minute
I
have
to
think
before
I
build
stuff,
I,
don't
I!
Just
cannot
like
go
bashing
and,
like
think
about
the
types
thinking
about
the
things
that
I'm
trying
to
do
so.
Essentially,
when
you
spend
some
time
trying
to
learn
the
language
better,
you
become
a
better
software
engineer,
which
is
amazing.
A
A
It's
awesome,
but
it's
a
nightmare
because
suddenly
we
had
a
problem
that
rocket
was
having
because
of
the
plugins
on
the
compiler,
and
then
we
had
to
upgrade
to
a
new
nightly
snapshot
and
then
suddenly
we
broke
diesel
and
then
oh
and
we
went
into
that
very
inconsistent
state
where
we
couldn't
go
back
because
then
other
things
will
start
failing
in
very
unpredictable
ways
and
inside
that
was
a
very
stupid
idea.
But
yeah
it's
kind
of
like
everyone,
these
mistakes
and
that's
it
we're
fine,
is
fine.
A
So
the
takeaway
for
this
is
like
fewer
moving
parts,
please
it's
kind
of
like
if
you
can
stick
to
a
stable
version,
you're
going
to
be
a
way
way
happier
person,
even
if
you
miss
those
cool
features
that
Knightley
has
so
a
high
rate
of
change,
which
is
actually
what
happens
in
Knightley
leads
to
an
even
higher
quad
cognitive
load.
And
when
you
think
for
a
bit
wait
a
minute,
we
were
already
kind
of
learning
in
onboarding
people
on
rest
and
the
reality
is
that,
with
this
context,
stable
can
be
bleeding-edge
enough.
A
Let's
be
honest,
shiny
objects
are
cool,
it's
kind
of
like
playing
with
new
tech,
new
hardware,
new
approaches,
new
language.
Like
rest,
it's
not
that
new,
if
it
I'm
understanding
correctly
but
whatever
so.
Sometimes
you
get
really
smart
abstractions.
You
really
want
to
make
things
shine
and
be
really
efficient,
and
sometimes
it
feels
like
magic
like
so
I'm
having
this
pipe.
A
That
is
being
automatically
dereferences
into
something
else,
and
then
the
compiler
is
able
to
inline
this
thing
and
make
a
zero
cost
abstraction
or
whatever,
like
it's
amazing,
but
sometimes
you
end
up
with
types
that
I
have
like
these,
where
trate
trate,
trate
trate,
trate
trate
several
traits,
it's
kinda
like
it
gets
really
complex.
I
think
that
the
good
example
is
that
I
have
ever
have
it.
A
Has
anyone
heard
about
scours,
turing-complete
type
system,
where
you
can
do
like
how
my
powers
compile-time
just
by
using
types,
it's
kind
of
insane
and
super
cool
check
it
out,
but
yeah?
It's
kind
of
you
do
you
want
to
play
with
those
things
and
have
fun,
but
a
reality
check
is
that
this
is
not
Hogwarts
if
you're
keeping
doing
magic
you're
going
to
have
a
lot
of
pain
to
deal
with
this
thing
later.
A
The
fact
that
you
can
do
it
like
the
Hanoi
towers
doesn't
mean
that
you
should
do
it
on
production
or
a
like
on
on
a
real
serious
project,
and
then
I
have
like
something.
That's
always
bugging
me.
My
background
is
Java
programming
and
like
very
big
and
boring
enterprise
systems
and
I
I.
Ask
you.
Oh
yeah
I
jump.
A
So
the
takeaway
here
is
that
there
is
this
pretty
young,
and
it's
really
cute
so
by
the
way
I
love.
This
I
wish
that
this
was
like
the
official
mascot,
not
the
unofficial
one.
But
the
thing
is
we
don't
have
an
established
patterns,
yet
we
have
a
bunch
of
things
that
are
happening,
and
yet
we
don't
have
them
yet,
because
the
community
is
actively
working
on
trying
to
find
those
patterns,
which
is
great.
A
Also,
if
you
end
up
doing
a
lot
of
match,
match
match
matching
two
nested
things,
and
then
you
go
with
pyro
means
of
doom.
Like
JavaScript
I
mean
this
is
not
JavaScript.
This
is
rest.
We
need
to
try
to
play
different
and
actually
experimenting
with
those
things
is
really
important,
but
you
really
need
to
be
mindful
of
your
own
business.
We
all
have
pieces,
we
all
have
experiences
of
our
lives.
So
this
brings
me
to
the
most
important
points,
which
is
the
human
factor.
A
When
we
go
over
all
this
experimentation,
seeing
all
the
mistakes
and
ask
the
right
questions
again
and
by
the
way
asking
the
wrong
ones
is
fine
as
long
as
you're
asking
so.
The
first
question
that
I
have
is:
am
I
too
excited
about
rust.
I
mean
we
all
love
the
language
this
guy,
like
is
really
cool,
I
would
easily
like.
A
Oh
do
you
want
to
write
rust,
full-time
sure,
why
not
school,
but
when
we
get
too
excited
in
hindsight
in
insight,
it's
kind
of
like
hard
for
you
to
pay
attention
because
you're
so
excited,
and
sometimes
people
were
talking
to
you
and
saying
like
hey.
This
is
not
cool.
This
is
kind
of
like
Strobel
song.
Rls
is
crashing
every
hour,
I
mean
I.
Don't
I
cannot
jump
from
a
function
to
an
order.
It's
I
have
to
use
ctags
really
I
mean
yeah.
A
Am
I
listening
to
what
people
are
saying
me
and
like
this
I
knows
that
they
are
giving
me
or
I
just
I'm,
just
listening
to
what
I
want
to
hear
like
I
love,
first
and
I
want
to
make
successful.
Yo,
let's
go
on
up
like
we
really
need
to
be
mindful,
and
this
is
an
interesting
one-
make
sure
you
have
explicit
by
him
not
only
from
your
direct
manager
but
beyond
today,
infinity
and
beyond.
Why?
A
What
happens
if
you're
a
manager
move
moves
on
and
he
was
cool
with
a
rest
project
and
suddenly
the
director
wakes
up-
and
we
have
I-
didn't
know
that
and
suddenly
you
have
a
very
big
ball
of
mud
to
deal
with
it's
kind
of
like
it's
nice
to
have
like
the
experimenting
in
a
corner,
but
make
sure
that
this
is
being
communicated
somewhere
else.
Coming
with
a
surprise,
can
be
really
bad
and
essentially
can
mean
that
even
a
so
sex
successful
project
can
be
killed
so
and
I
think
this
is
the
most
interesting
one.
A
Like
people
have
opinions,
some
people
were
like.
Oh,
you
don't
need
a
package
me,
a
package
manager.
No,
no,
it's
fine!
Just
vendor
everything!
You
don't
even
need
the
gold
link
tools
that
the
vendor
things
you
just
copy
stuff.
There
I
heard
this
people
have
opinions
surprisingly
yeah,
and
you
need
to
be
mindful
that
not
everyone
has
to
think.
A
Like
you
and
you
don't
have
to
agree
with
them,
you
have
the
keynotes
saying
that
we
have
a
continuous
tension
between
different
ways
of
seeing
things,
and
we
need
to
be
mindful
of
them,
because
at
the
end
of
the
day,
carbecue
ting
is
totally
a
thing
and
that's
fine,
because
at
the
end
of
the
day
we
are
humans
and
people
in
interactions
should
matter
way
way
more
than
the
technology
that
we
are
using.
So
on
the
closing
notes:
there's
a
secret
sauce
for
making
all
of
this
be
a
little
bit
easier.
A
The
secret
sauce
is
empathy.
Empathy
is
a
powerful
feature
to
actually
make
you
go
out
of
your
perfect
rose
roles
and
understand
that
sometimes
golang
is
the
better
solution,
even
if
it
hurts
to
say
that,
but
you
know
we
can
have
we.
There
are
some
situations
where
it
doesn't
make
sense
to
try
to
force
things.
And
honestly,
this
is
really
hard
to
do.
I
would
say
that
by
far
is
the
hardest
thing
like
to
ecology,
meets
that
admit
defeat.
Okay.
This
is
not
the
time
yet
to
use
rest,
but
yeah.