►
Description
This presentation was recorded at GOTO Berlin 2018. #gotocon #gotober
http://gotober.com
Ashley Williams - Rust Core Team Member and Rust Community Team Lead
ABSTRACT
I made one of my favorite pull requests ever on December 17, 2016: rust-www/pulls/634: add npm to friends page.
On any given day, the npm registry, a repository of packages primarily for JavaScript and Node.js, serves around ~650,000,000 package downloads. The npm services team is small and this once little Node.js service, the lifeblood of the modern web development workflow, is now a huge set of microservices- and starting in late 2016, it’s no longer just Node.js- it’s running production Rust. In this talk, I’ll tell the story of how I convinced my manager and team to give Rust a chance. Along the way, I’ll talk about the critical challenges that the npm registry services encounter on a daily basis, the patterns we’ve adopted to cope with the heavy operational load, and how they are well suited to be solved with Rust. I’ll also highlight the unique aspects of Rust that [...]
Read the full abstract here:
https://gotober.com/2018/sessions/528
RECOMMENDED BOOKS
Tim McNamara • Rust in Action • https://amzn.to/3ux2R9u
Blandy, Orendorff & Tindall • Programming Rust • https://amzn.to/3x7r6w6
Ken Youens-Clark • Command-Line Rust • https://amzn.to/3PQZ539
Kevin Hoffman • Programming WebAssembly with Rust • https://amzn.to/3x3brhe
https://twitter.com/gotober
https://www.facebook.com/GOTOConference
http://gotocon.com
#Rust #Rustlang #JavaScript #NodeJS #JS #Programming #ProgrammingLanguage #SoftwareEngineering #Mozilla #Coding #FP #FunctionalProgramming
Looking for a unique learning experience?
Attend the next GOTO Conference near you! Get your ticket at http://gotocon.com
SUBSCRIBE TO OUR CHANNEL - new videos posted almost daily.
https://www.youtube.com/user/GotoConferences/?sub_confirmation=1
A
So
my
talk
today
is
called
zen
and
the
art
of
convincing
your
company
to
use
rust.
There
are
some
hand-drawn
illustrations,
as
you
can
see
right
here.
I'm
gonna
talk
a
little
bit
about
NPM
and
if
you
don't
know
that
NPM
mascot
is
a
wombat,
so
that
is
the
wombat
here
on
a
motorcycle
and
then
the
rust
mascot
is
a
crab
named
Ferris.
If
you
want
to
know
the
puns
behind
that,
I'll
explain
them
to
you
later.
They
are
extensive,
so
yeah,
my
name
is
Ashley
Williams.
A
You
may
know
me
from
the
internet
as
a
g-dubs.
If
you
follow
me
on
Twitter
I'm,
sorry,
if
you
don't
follow
at
your
own
risk,
so
I
currently
work
as
a
contractor
for
Mozilla
and
I
work
on
the
rust
programming
language.
So
this
is
a
small
set
of
the
titles
that
I
hold,
because
it
turns
out
that
an
open-source
project
is
very
similar
to
a
small
startup
and
trying
to
do
just
one
thing
is
incredibly
difficult.
A
A
How
many
people
here
want
to
write
rust,
alright,
hopefully
by
the
end,
I
may
have
convinced
a
couple
more
of
you.
If
you
don't
want
to
write
it
I'm
very
curious,
while
you're
here
this
will
be
fun.
How
many
people
here
write
JavaScript
all
right,
cool,
there's
a
small
bit
at
the
end
about
using
rusts
to
make
your
JavaScript
awesome.
So
I'm
really
excited
to
talk
about
that
as
well.
All
right!
So
this
talk
today
is
a
my
story
about
getting
the
company
NPM.
A
You
may
have
heard
of
it
to
use
rust
and
so
NPM,
as
we
all
know,
stands
for
nearly
perfect
machine.
It
definitely
doesn't
go
down
or
have
problems
right.
We'll
talk
about
some
of
those
problems
later
today,
but
I
worked
at
NPM
up
until
January
of
this
year
when
I
got
to
leave
that
company,
so
that
I
could
do
my
dream
job,
which
is
work,
full-time
and
open
source.
A
The
CLI
tool
is
called
cargo
and
it's
awesome
and
the
registry
is
called
crates
I/o
and
so
I
am
just
you
know,
part
of
this
team
of
really
cute
animals
moving
packages
of
code
around
I,
a
joke
that
when
I
retire,
I'm
gonna
work
at
UPS,
which
is
the
parcel
system
for
the
United
States,
because
it's
simply
my
only
skill
set
but
yeah.
So
if
you
don't
know
about
MPM
NPM
always
likes
to
talk
about
how
large
their
numbers
are.
A
So
this
was
taken
earlier
today,
it's
funny
because
when
I
gave
this
talk
a
version
of
this
talk
about
a
year
ago,
the
numbers
were
about
50%
of
these.
So
big
numbers
are
big,
NPM
is
a
huge
ecosystem,
and
so
this
is
module
counts.
If
you
don't
know
about
this,
this
is
a
site
that
aggregates
all
of
the
packages
in
all
of
the
different
package.
A
Registries
and
I
like
this,
because,
as
you
can
see,
NPM
has
this
thing
in
startup
terms,
called
a
hockey
stick
curve
I,
don't
know
why
they
call
it
that
it's
just
an
exponential
curve,
but
clearly
you
can
see
it's
quite
large
and
hilariously.
If
you
take
a
look,
the
yellow
line
is
crates
I/o,
so
we're
not
quite
at
the
same
scale
yet.
A
But
I
show
these
to
say
that
NPM
is
the
largest
package
registry
in
the
world
and
immediately
upon
saying
this,
all
of
the
YouTube
comments
I
get
are
like.
Actually
no,
and
so,
if
you
want
to
fight
about
this,
YouTube
comments
exists.
I,
guess,
that's
probably
the
best
place
to
do
it
mostly.
What
I
want
to
say
is.
This
is
an
incredibly
large
service
that
has
to
deal
with
a
lot
of
requests,
and
so
that's
gonna
be
a
big
reason
that
we
end
up
talking
about
rust,
so
in
2016.
A
So,
almost
two
years
ago,
I
got
to
make
this
amazing
pull
request.
That
said,
add
NPM
to
the
friends
page
for
those
of
you
who
don't
know
on
the
wrestling
website,
all
of
the
companies
that
use
rust
in
production.
It's
a
lot
of
blockchain
companies,
what's
the
small
ones,
but
there's
also
some
big
ones
and
in
December
of
2016
I
got
to
add
NPM
to
that
list,
and
that
was
amazing.
How
many
people
here
have
tried
to
get
their
company
to
take
a
bet
on
a
brand
new
kind
of
edgy
technology?
A
How
many
people
succeeded
all
right?
So
that's
good,
but
if
you
want
to
succeed,
that's
really
the
goal
of
the
talk
today.
So
NPM
uses
rust,
and
this
was
like
my
most
exciting
thing.
I
was
incredibly
happy
about
this,
but
I
realized
that
many
people
in
this
room
may
not
know
what
rust
is
so
I'm
not
gonna.
Go
into
too
many
like
technical
details
about
rust.
If
you
want
to
ask
those
in
the
questions,
I'm
super
happy
to
answer
them.
But
to
start
we
can
talk
with
how
rust
describes
itself
on
its
website.
A
Rust
says
that
it
is
a
systems,
programming,
language
that
runs
blazingly
fast,
prevents
seg
faults
and
guarantees
thread
safety.
Now
that
sounds
I,
guess
kind
of
good,
but
most
people
who
hear
this
kind
of
hear
this.
It's
like
okay,
what
like
what
is
systems
programming
every
time,
I
ask
someone:
they
have
a
different
answer
and
so
I
like
to
kind
of
tell
the
story
of
rust.
So
many
people
don't
realize
that
rust
was
a
programming
language
that
was
originally
designed
to
replace
C++
in
the
Firefox
codebase.
A
The
Firefox
codebase
needed
to
move
very
quickly
at
the
speed
of
the
web.
Perhaps,
and
it
turned
out
that
the
C++
they
had
was
just
incredibly
hard
to
maintain,
particularly
because
of
the
lack
of
safety
guarantees
trying
to
refactor
or
change
something
in
the
codebase
could
cause
really
huge
problems
in
another
spot.
How
many
people
here
have
ever
written
some
C++?
How
many
people
here
have
written,
unsafe
C++?
All
the
hands
should
still
be
up?
A
Okay,
but
that's
not
to
say
that
C++
is
a
bad
language
is
incredibly
powerful,
but
rust
was
conceived
to
be
like
okay,
we
need
to
have
a
C++
code
base,
that's
gonna
be
old
and
we
need
to
be
able
to
move
quickly
on
it,
and
that
was
the
original
inspiration
for
rust.
So
if
many
people
here
have
heard
of
kind
of
the
battle
between
rust
and
go
that's
kind
of
an
artificial
one,
that's
kind
of
developed
and
emerged
of
the
community
like
originally
we
were
really
looking
to
replace
C++.
A
So
a
couple
of
the
characteristics
of
the
language
are,
we
are
statically
typed,
it's
a
compiled
language.
We
don't
have
any
runtime,
there's
a
lot
of
different
ways
to
talk
about
types
of
garbage
collection.
Some
people
like
to
say
you
have
to
manually
manage
memory
and
rest.
It
is
not
entirely
accurate,
but
there's
certainly
nothing
happening
at
runtime
with
that
memory
management.
As
a
result,
the
rest
programs
that
you
write
are
gonna
have
an
incredibly
small
memory
footprint
and,
more
importantly,
we
have
memory
safety,
guarantees
and
I'll
talk
about
that
in
a
little
while.
A
A
I
don't
want
to
get
close
to
the
metal
and
rust
is
here
to
say:
not
only
can
you,
but
you
should-
and
this
is
the
type
of
language
that
you
can
do-
that
with
so
rust
has
always
been
kind
of
looking
at
these
ideas
of
trade-offs,
and
whenever
we
talk
about
programming
tools,
we
often
talk
about
trade-offs,
but
what
rust
wants
to
do
is
say
some
of
these
original
kind
of
like
baked
and
trade-off,
so
we
kind
of
take
for
granted.
What,
if
we
didn't,
what,
if
we
could
say?
A
Oh,
you
know,
there's
often
a
you
know:
a
separation
between
the
idea
of
speed
or
safety
and
then
productivity
and
ergonomics,
and
we're
like
what,
if
with
the
magic
of
compilers
compilers,
are
so
cool
with
the
magic
of
compilers.
We
can
not
have
to
make
this
a
trade-off.
What
if
we
can
have
all
three
now
Russ
is
a
very
new
language
to
a
certain
extent,
especially
compared
to
a
lot
of
the
languages.
A
That
being
said,
if
you
are
already
decided
after
my
little
spiel
about
rust,
that
rust
doesn't
seem
like
the
thing
for
you,
one,
that's
cool,
but
two
at
think.
A
lot
of
the
tips
here
are
gonna
help
you
like
advocate
for
any
type
of
technologies
like
at
your
company,
so
you
may
or
may
not
have
recognized
that
my
title
is
a
reference
to
a
book
called
zen
and
the
art
of
motorcycle
maintenance.
Hence
that
weird
illustration
of
a
motorcycle
at
the
beginning.
A
But
in
that
book
there's
a
statement
that
says
the
number
of
rational
hypotheses
that
can
explain
any
given
phenomena
is
infinite.
So
the
real
answer
is:
how
can
you
convince
your
company
to
use
rust
like
there's,
probably
an
infinite
number
of
answers,
but
today
I'm
gonna
represent
ten
of
them
and
you
may
or
may
not
notice
that
a
lot
of
them
have
contradictions,
because
it
turns
out
that
things
are
difficult,
so
yeah,
let's
get
started
so
the
very
first
tip
for
getting
your
company
to
write
rust
is
to
not
rewrite
your
software.
A
It
rust
right
you're
like
what
No.
So
what
I
mean
to
say
is
that
you
should
not
completely
rewrite
your
software
in
rust,
and
this
is
incredibly
important.
So
it
turns
out
that
complete
rewrites
are
often
very
unsuccessful.
How
many
people
here
have
tried
to
endeavor
on
a
complete
rewrite
that
didn't
work
out
yeah
same
so
one
of
the
neat
ways
to
talk
about
this
is
actually
from
somebody
who
does
systems
engineering
but
also
is
a
pediatrician.
A
He
wrote
a
book
called
system
antics
about
how
systems
succeed,
but
particularly
how
systems
fail
and
here's
what
he
says
about
systems.
He
says
a
complex
system
that
works
is
invariably
found
to
have
evolved
from
a
simple
system
that
worked.
A
complex
system
designed
from
scratch,
never
works
and
cannot
be
patched
up
to
make
it
work.
You
have
to
start
over
with
a
simple
system,
and
so
with
this
quote,
you
might
ask
oh
gosh:
all
efforts
will
fail.
A
How
can
I
possibly
introduce
a
new
technology
at
my
company,
and
so
when
I
was
working
at
MPI,
our
CTO
is
named
CJ
Silverio
and
she
gives
a
talk
called
cheating
calls
law.
How
can
we
cheat
this
idea
that
we
always
have
to
start
with
a
simple
system,
and
this
is
kind
of
how
we
do
it.
So
this
is
exactly
how
we
do
it
at
MPM,
which
is
to
say
NPM
originally
started.
As
a
monolith
even
worse,
it
was
a
mono
lift
that
was
basically
all
inside
a
database
recommendation.
A
Don't
do
that,
but
it
turns
out
that
to
get
MPM
started.
It
was
a
pretty
good
idea,
so,
as
NPM
grew
and
had
tons
of
scaling
problems.
If
anyone
was
trying
to
do
JavaScript
in
like
2000
hit,
1011
NPM
was
kind
of
on
fire,
and
so
the
way
we
started
dealing
with
this
was
instead
of
trying
to
completely
rewrite
it
from
scratch,
which
I
think
we
can
all
agree
was
probably
going
to
be
a
bad
idea.
A
We
started
introducing
a
proxy
and
then
splitting
off
tiny
little
services,
and
so
these
are
well
known
as
micro
services,
and
so
this
is
like
a
hot
term
and
I
probably
do
not
have
to
explain
it
to
you,
but
it
turns
out
that
if
you
want
to
introduce
a
new
technology
at
your
company,
a
micro
services
architecture
is
a
great
way
to
do
it
so
to
follow
up
with
this
tip.
2
is
to
show
up
with
code.
A
So
inevitably,
this
means
that
you
might
be
working
kind
of
like
off
hours
late
at
night,
sneaking
in
some
work
to
do,
and
so
the
very
first
rest
code
that
I
ever
wrote
was
using
this
framework
called
Tokyo
which,
if
anybody
here
is
familiar
with
rust.
This
is
our
async
solution
and
when
I
was
doing
this
in
2015,
it
turns
out
that
this
was
really
an
immature
library.
And
so
the
story
today
around
async
and
rust,
is
still
pretty
complicated.
A
A
Let
me
try
this
out
in
rust,
so
how
many
people
here
have
heard
of
a
registry
follower
all
right,
so
the
NPM
registry
takes
in
all
of
these
events
and
sends
them
out,
and
you
can
write
a
follower
to
follow
these
events
and
do
activities
and
I'll
talk
a
little
bit
about
that
more
later.
But
this
was
what
I
decided
to
do,
because,
fundamentally,
this
is
how
all
of
the
NPM
registry
architecture
works.
A
So,
when
I
talked
about
that
database,
our
database
application
was
all
inside
CouchDB,
which
is
a
red
couch,
that's
their
logo,
and
so
you
can
see
that
all
of
these
types
of
events
come
into
the
CouchDB
and
then
what
we're
able
to
do
in
the
NPM
registry
is
have
followers
that
can
follow
those
events
and
so
in
a
little
bit
less
illustrative
terms.
This
is
kind
of
what
that
looks
like,
which
is
to
say
changes
go
into
the
registry.
The
registry
emits
events
and
those
followers
subscribe
to
those
events
and
based
on
particularly
particular
data.
A
In
those
events,
we're
able
to
do
a
wider
range
of
things.
This
is
literally
how
everything
in
the
NPM
registry
works
and
if
you
ever
want
to
do
fun
stuff
with
registry
data.
This
is
how
you
do
it
it's
much
better
than
actually
downloading
the
entire
NPM
registry,
which
at
this
point
is
incredibly
large.
So
what
I
decide
to
do
was
write
one
of
these
followers,
and
so
this
is
what
my
code
looked
like.
A
It's
kind
of
amazing
how
pithy
it
is,
but
this
is
leveraging
that's
the
end
point
the
replicate,
NPM,
J,
Escom,
slash,
underscore
changes
and
all
this
code
does
right.
Here
is
pull
in
the
changes
and
then
print
them
out
to
the
screen,
but
that's
all
I
needed
to
really
be
able
to
demonstrate
to
say
that
rust
is
ready
to
be
able
to
part
to
be
part
of
our
architecture,
and
so
here
this
adds
a
little
bit
more.
A
This
is
the
j/s
that
you
write
to
do
the
same
thing,
so
this
is
the
node
and
that's
the
rust.
It
turns
out
that
the
rust
is
shorter,
which
blew
my
mind
all
right,
so
showing
up
what
that
code
was
really
really
good,
but
one
of
the
more
key
things
about
being
a
developer
advocate
is
to
not
sell
what
right.
So
what
I
originally
came
into
NPM
our
CTO
had
been
looking
at
go.
A
She
was
really
excited
about
Go
Go
is
an
incredibly
exciting
language,
and
so,
if
I
had
walked
in
and
been
like,
CJ
go,
they
don't
even
have
generics.
It's
terrible!
That's
a
really
niche.
Go
joke!
Sorry,
but
as
you
can
see,
bashing
other
languages
makes
everyone
look
bad,
so,
unfortunately
oftentimes
when
you're
working
in
programming
languages,
a
lot
of
people
see
it
as
a
zero-sum
game,
which
is
to
say
if
this
language
is
good.
That
must
mean
that
all
other
languages
are
bad.
A
Now,
potentially,
you
can
believe
that
in
your
heart
of
hearts,
but
it
turns
out
that
if
you
want
to
actually
change
someone's
mind,
that
is
a
terrible,
terrible
route
to
go,
and
so
I
see
a
lot
of
people
being
a
bit
quiet
here.
I
guess
that's
because
I
am
giving
a
talk,
but
this
is
a
huge
thing
that
I
see
in
the
community
and
it's
incredibly
difficult
to
actually
convince
people
not
to
do
this.
But
beyond
that
one
of
the
other
things
that
I
think
is
very
interesting
about.
A
Introducing
a
new
technology
to
people
is
that
you
don't
have
to
control
someone
else's
first
experience
of
rust,
and
that
means
you
as
someone
who
is
selling
it,
but
also
the
rust
language
and
its
tools
in
general.
So
I
have
a
small
story
about
telling
CJ
and
going
through
this
project
with
her.
So
what
I
learned
is
that
not
everyone
is
gonna
love
everything
about
rust,
right
away,
they'll
warm
up
to
it,
and
so
this
is
some
fun
punctuation
incantation.
A
If
you
don't
know
rust,
you
don't
have
to
worry
too
much,
but
this
is
something
that
you
can
put
at
the
top
of
your
code,
which
is
to
say,
I,
don't
want
the
compiler
to
warn
me
about
how
I'm
naming
my
functions
and
variables,
and
so
it
turned
out
that
CJ
is
somebody
who
has
a
very
particular
style
and
to
get
her
to
enjoy
rust,
I
needed
to
make
sure
that
she
could
just
use
that
style.
For
now.
She
really
just
wanted
to
use
that
style
and
she
was
like
Ashley.
A
How
do
I
turn
off
these
compiler
warnings?
How
do
I
do
it
and
I
was
like,
oh
I'm,
sure,
there's
a
way,
let
me
find
out,
and
so
I
was
looking
through
the
docs
and
I
was
like.
Oh
no,
the
way
you
turn
off
the
compiler
warnings
is
I
have
to
tell
my
CTO
that
she
has
to
write,
allow
bad
style
in
her
code
and
I'm
like
oh
dang.
A
This
is
an
issue,
but
in
our
RFC's
repo
to
say
hey,
maybe
we
could
be
like
a
little
less
Shamy
about
having
this
like
it
having
good
style
if
you're,
just
starting
out
like
we
want
people
to
use
rust
so
telling
them
that
they
have
to
be
shamed
constantly,
is
probably
not
a
great
way
to
convince
them
to
use
it.
Now.
You
might
note
those
github
reactions
how
about
that.
A
So
in
the
rest,
community,
we
worked
very
hard
to
be
welcoming,
but
old
habits
die
hard
with
a
lot
of
people,
and
so
this
thread
became
very
contentious,
extremely
contentious.
You
can
see
a
lot
of
moderation.
Actions
here.
I
show
this
just
to
point
out
that,
despite
the
fact
that
it
was
incredibly
contentious,
rust
values
being
inclusive
and
welcoming
to
new
people,
we
won't
succeed.
A
If
people
don't
use
rust,
and
so
we
have
a
strong
moderation
team,
that
kind
of
shut
that
all
down-
and
so
you
can
see
so
many
comments
happened,
but
fundamentally
we
ended
up
getting
this
into
the
language.
So
if
you
want
to
try
rust,
you
can
name
your
functions
whatever
you
want,
you
can
say,
allow
non-standard
style
and
still
feel
good
about
yourself.
A
So
in
complete
contrast
to
tip
number
three
tip
number
four
is
to
sell,
sell,
sell
so
in
rust,
because
we're
a
new
language
we
have
so
many
enthusiastic
beginners
you
may
or
may
not
have
seen
on
orange
websites.
The
idea
of
the
rust
evangelism
strike
force
we're
upset
about
that.
We
don't
love
that
it's
a
little
bit
aggressive.
That
being
said,
there
are
really
awesome
ways
to
sell
stuff
inside
of
your
company
that
are
not
aggressive.
It's
like
going
around
and
filing
an
issue
on
every
repo
of
every
open-source
ship
project.
A
You
use
and
say
please
rewrite
this
in
rust.
Don't
do
that
please
and
I'm
not
exaggerating.
There
are
people
who
do
it
and
it's
incredibly
frustrating
to
everybody
in
leadership
in
trust,
but
one
thing
that
I
did
at
MPM
to
make
this
work
out.
Was
we
created
a
react,
G
channeler,
which
is
something
we
use
slack
at
NPM,
and
so
every
time
somebody
shared
something
depending
on
whatever
channel
it
was
in.
You
could
react
with
a
crab
emoji
right
here
and
it
would
pull
everything
into
a
single
channel.
A
So
on
to
tip
number
five,
so
the
hard
part
of
programming
isn't
programming
all
right.
Maybe
we
all
agree
on
this,
but
this
is
a
thing
that
rust
really
cares
about,
and
it
turns
out
that
in
selling
rust
to
CJ
the
thing
that
really
convinced
her
over
go
was
all
of
the
support
elements
that
rust
had.
So
we
have
a
really
large
documentation
culture.
We
have
tons
of
books.
This
is
not
even
all
of
them.
One
of
the
things
that
we've
done
this
year
is
work
to
create
what
we
call
the
domain
working
group
books.
A
The
rest
book
that
we
have
is
very
much
focused
on
beginners,
and
then
we
have
something
called
the
nomicon,
which
is
literally
like
the
dark
arts
of
rust,
which
use
lots
of
unsafe
and
very
funky
things.
But
we
kind
of
noticed
that
the
intermediate
level
kind
of
was
missing,
and
so
what
we
did
this
year
was
create.
Domain
working
groups
focused
on
specific
elements
of
programming
that
an
intermediate
develop
developer
would
be
interested
in,
so
we
focused
on
CLI
tools,
embedded
web
assembly
and
networking,
and
each
one
of
those
groups
produced
its
own
book.
A
So
if
you
you
happen
to
use
node
or
maybe
something
like
Ruby,
you've
probably
had
to
deal
with
version
manager
tools
before
and
those
version
manager
tools,
kind
of,
like
our
weird
community
side
projects
and
it's
kind
of
hard
to
tell
which
one
is
the
right
one
to
use
a
given
time
in
rust.
You're
like
we're
just
gonna,
do
this
out
the
back,
so
we
have
rust
up
and
that's
how
you
manage
all
of
your
tool
chain
versioning.
A
Additionally,
if
you
come
from
JavaScript
you're
probably
used
to
code
for
matters,
you're
also
used
to
people
fighting
viciously
about
code
for
matters,
Russ
combs
was
one
out
of
the
box.
It's
called
rust
format.
If
you
want
to,
you,
can
configure
it,
but
the
defaults
are
pretty
good
and
then,
lastly,
if
you
happen
to
ever
use
Microsoft
Word,
you
might
get
the
reference
of
this
idea
of
Clippy.
A
Clippy
is
a
way
to
lint
your
project,
not
for
style
or
for
safety,
which
our
compiler
just
already
does.
Clippy
will
help
you
write
idiomatic
rust,
so
it
does
static
analysis
on
your
project
and
is
able
to
say
hey
you're
doing
this,
but
did
you
know
that
the
better
way
to
do
it
is
this
seems
like
you're
writing
an
if
statement
it
would
be
really
great.
A
If
I
don't
know,
people
were
joking
when
github
got
acquired
by
Microsoft
that,
oh,
my
god,
github
is
gonna,
have
Clippy
now
and
I
kind
of
was
like
rust
does
have
Clippy.
Is
that
bad,
but
Clippy
is
one
of
the
most
awesome
tools
ever
and
especially,
if
you're
getting
started
again,
it's
like
having
somebody
else
programming
with
you
to
check
those
things
out.
A
Lastly,
rust
cares
a
ton
about
community,
so
if
you're
new,
we
have
an
IRC
channel,
which
is
not
an
evil
terrible
IRC
channel
called
rust
beginners.
That
is
extremely
well
staffed
by
both
core
team
members
and
community
members.
To
answer
any
of
your
questions,
we
are
excited
when
people
come
with
questions
about
rust,
there's
no
RTFM
there.
We
really
care
about
it
and
will
happily
just
sit
and
work
with
you
through
your
issues.
Additionally,
we
have
started
to
have
a
whole
bunch
of
conferences.
A
This
is
just
a
small
set,
but
if
you
are
interested
in
attending
a
rust
conference,
rust
Fest
travels
all
over
Europe
and
they're
really
awesome
events.
Additionally,
we
care
about
inclusivity
as
well.
It
turns
out
that
systems
programming
is
not
the
most
diverse
part
of
programming,
which
is
not
the
most
diverse
anything
at
the
moment,
and
so
we
have
two
programs
increasing
breast
reach,
which
is
basically
our
google
Summer
of
Code,
and
additionally,
we
have
programs
called
Russ
bridge,
which
are
educational
workshops
focused
on
under
people
to
get
them
into
rust.
A
Lastly,
if
doing
kind
of
problems
on
your
own
is
your
thing:
we
have
a
pretty
vibrant
community
over
at
exorcism
IO,
which
is
a
set
of
code
Coty's
that
you
can
do
in
a
ton
of
different
languages,
but
the
rest
one
is
also
there
and
super
great.
So
I
mentioned
all
of
this
and
I
know
that
it
kind
of
seems
obvious
you're
like,
of
course,
these
are
good
things
right,
but
you
know,
despite
the
fact
that
they
seem
so
easy
in
common.
A
They
really
are
neither
it's
incredibly
difficult
to
set
these
types
of
things
up
and
I'm
really
happy
that
rust
is
decided
to
invest
in
these
things
early,
because
if
you
don't
get
these
things
early
and
you
try
and
add
them
on
after
you're,
gonna
have
a
really
bad
time
and
I
know
this,
because
I
participated
in
node
for
a
very
long
time.
So
getting
this
stuff
out.
A
The
bet
is
awesome,
a
cool
kind
of
fact
that
many
people
don't
know
the
very
first
commit
to
rust
was
a
code
of
conduct
and
a
lot
of
people
say:
oh
those
rust
SJW
is
the
code
of
conduct.
It's
so
bad
and
they
say
I'll
never
use
rust.
Because
of
this,
and
to
be
honest,
we
say
good,
we
think
it's
awesome,
all
right,
so
tip
6
the
hardest
part
of
programming
actually
is
programming.
A
So,
of
course,
when
you're
trying
to
sell
some
sort
of
tech
to
your
company,
you're
gonna
want
to
sell
it
on
technical
merits,
but
I'm
not
gonna,
spend
too
much
time
here,
because
it
turns
out
that
actually
selling
something
on
technical
merit
is
very
easy.
People
get
very
focused
on
that
part
and
very
distracted
and
don't
focus
on
the
other
parts
that
I
personally
think
are
most
important.
A
So
the
only
date
a
bit
I'll
give
you
here
is
for
reasons
that
still
kind
of
baffle
me
rust
has
been
the
most
loved
programming
language
on
the
Stack
Overflow
survey.
For
the
last
three
years
say
what
you
will
about
surveys
say
what
you
will
about
Stack
Overflow.
There
is
a
community
of
people
that
really
love
this
language
and
that's
pretty
awesome
all
right
so
on
to
tip
number
seven.
So
this
is
gonna
be
a
little
bit
of
a
vignette,
but
this
is
to
say,
be
prepared
for
things
to
change.
So
at
M
p.m.
A
we
have
a
problem
that
might
be
familiar
to
you.
We
have
node
and
all
over
almost
all
of
our
services
and
our
service
logs
are
not
only
incredibly
huge.
Imagine
as
logging
all
of
the
events
that
happen
on
the
registry,
but
they
also
have
runtime
errors,
because
it
turns
out
that
JavaScript
has
runtime
errors
and
if
you
want
to
be
able
to
go
clean,
those
up.
A
A
Here
I
am,
but
this
is
kind
of
a
huge
bummer
and
we
want
to
do
stuff
to
change
this,
so
Ryan
decided
to
kind
of
he
was
like
I'm
gonna
write
a
log,
parser
I'm,
just
gonna
do
it,
and
so
he
didn't
really
know
much
for
us
to
use
their
documentation
and
just
kind
of
scripted
something
up,
and
he
ran
into
this.
He
was
like,
isn't
Russ
supposed
to
be
super
fast,
like
how
is
my
Russ
parser
two
times
slower
than
my
JavaScript
version
like
this?
This
is
not
what
you
sold
me
on.
A
How
is
this
even
possible,
and
so
there
are
several
different
things,
including
this
there's.
A
lot
of
memory
management,
that's
happening
in
rust,
and
so
how
you
write
rust
fast,
is
actually
just
a
little
bit
more
complicated,
and
so,
if
you
write
a
naive
thing,
there's
a
chance
that
the
thing
that
you
write
in
rust
is
going
to
be
slow.
A
It
turned
out
in
this
situation,
which
is
a
default
that
we've
finally
changed.
Thankfully,
was
that
when
we
were
reading
in
a
buffer,
the
default
size
of
that
buffer
was
different
than
what
the
default
size
of
the
buffer
was
a
node,
and
it
turns
out
that
our
size
was
making
the
buffer
read
incredibly
slow.
So
when
we
manually
set
that
to
be
what
was
unknown,
it
sped
up
to
around
three
times
faster
than
the
JavaScript.
A
So
I
think
this
is
a
really
interesting
quote
from
my
colleague
where
he
said:
I
just
fully
expected
to
rest
my
way
into
50%,
/,
/
jeaious,
but
sometimes
I
forget
that
v8
is
pretty
darn
fast.
So,
while
trying
to
sell
rust
over
note,
it's
again
really
important
to
remember
bashing
through
the
languages
doesn't
work
like
other
languages
are
really
good.
Node
is
really
fast
and
so
trying
to
get
that
speed
is
always
not
always
exactly
what
you're
looking
for.
A
So
this
is
another
quote
from
that
art
of
the
motorcycle
maintenance,
and
it
says
you're
never
dedicated
to
something
you
have
complete
confidence
in.
No
one
is
fanatically
shouting
that
the
Sun
is
going
to
rise
tomorrow.
They
know
it's
gonna
rise
tomorrow
when
people
are
fanatically
dedicated
to
political
or
religious
faiths
or
tech.
Maybe
it's
always
because
these
dogmas
or
goals
are
in
doubt.
So
what
to
say
is
that
when
we
are
kind
of
promoting
these
types
of
things
like
it's
because
there's
a
question
there,
there's
an
interesting
trade-off.
A
There's
a
potential,
that's
maybe
yet
unfulfilled,
and
so
something
that
I
found
was
really
interesting.
Is
that
originally
I
thought
I
would
be
selling
rust
because
of
its
speed,
but
in
the
end
I
really
ended
up
selling
rust
because
of
its
safety.
And
so
when
you
go
to
promote
technologies
inside
your
company,
you
may
go
in
with
particular
reasons
but
be
prepared
to
react
to
the
other
reactions
you
get
and
to
potentially
change
those
reasons.
A
So,
even
though
the
learning
curve
in
order
to
make
rust
a
bit
faster
than
node,
was
higher
than
people
initially
wanted,
the
safety
guarantees
made
it
worth
that,
but
you
have
to
be
prepared
if
I
had
just
suddenly
seen.
Oh,
it's
really
hard
to
make
rust
faster
than
node.
I
may
have
just
stopped
and
been
like.
Maybe
this
is
bad,
but
paying
attention
to
how
people
are
reacting
and
being
able
to
say,
ok,
be
ready
to
change
your
mind.
It
can
make
it
a
lot
easier
and
a
lot
more
effective.
A
So,
as
I
said,
there's
a
learning
curve
to
making
rust
go
fast,
so
I
told
you
kind
of
a
sad
story
about
log
parsing,
but
now
I'm
gonna
tell
you
an
amazing
story
about
log
parsing,
so
this
is
Andre.
Arco
Andre
Arco
helps
maintain
bundler,
which
is
a
package
manager
for
ruby
and
similar
to
our
situation
in
node.
He
has
a
lot
of
logs,
and
so
he
was
like
shoot.
A
You
know,
I,
really
gotta
figure
out
how
to
parse
all
these
logs,
and
so
originally,
he
kind
of
started
out
you
using
AWS,
lambda
and
Python
in
his
first
attempt
ended
up
costing
him
around
$4,000
in
server
bills
and
he
was
like
whoops.
This
is
not
gonna
work,
and
so
he
started
being
like
why
don't
I,
try
out
rust,
and
so
what's
really
interesting.
A
These
are
the
numbers
from
about
525
records
per
second
to
50k
and
he
was
like
I'm
doing
great.
This
is
awesome.
He
showed
it
to
a
buddy
and
the
buddy
was
like.
How
is
that
so
slow
we're
gonna
have
to
profile
this.
What
is
going
on?
Why
is
this
incredibly
slow
and
harder?
It
was
like
I
already
sped
it
up
like
200%
like
what?
What
do
you
mean?
It's,
slow
and
kind
of
hilariously,
depending
on
how
you're
used
to
things
so
Andrei
comes
from
something
like
Ruby,
where
compiler
optimizations
aren't
a
thing.
A
A
So
his
current
implementation,
that's
in
rust,
now
goes
so
fast
that
it
fits
in
the
free
tier
for
a
dubious
lambda.
So
we
went
from
paying
about
five
thousand
dollars
to
none,
which
is
incredibly
awesome.
Yeah,
so
making
risk
correct
is
the
default
right.
Making
it
fast
can
take
a
little
bit
learning,
but
the
best
thing
about
rust
is
making
it
correct
is
the
default.
So
we
like
to
say,
unrest
that
the
safest
problem
is
safest.
Program
is
one
that
doesn't
compile
at
all
and
that's
because
we
have
a
compiler.
A
That's
gonna
do
a
bunch
of
static
analysis
on
your
program
and
it's
going
to
tell
you
a
lot
of
this.
No
that's
bad,
don't
do
it.
You
must
change
it
and
while
a
lot
of
people
can
kind
of
see
working
through
compiler
errors
is
something
that's
really
tough
for
a
begin.
One
of
my
favorite
ways
is
to
kind
of
switch
that
perspective
and
say:
hey,
wouldn't
it
be
awesome
to
just
always
have
a
pair,
that's
incredibly
smart
and
knows
how
to
analyze
like
race
conditions
in
your
program
and
they're.
A
Just
there
all
the
time
so
Russ
compiler
has
some
really
amazing
error
messages.
Now
we
have
the
elm
community
to
thank
for
that.
If
you
have
ever
used
elm,
they
have
absurdly
good
error
messages
and
I.
Don't
think
we're
quite
there
yet,
but
we
were
very
inspired
by
what
they're
doing,
but
a
lot
of
the
time.
Our
compiler
can
just
take
a
look
at
your
code
and
just
be
like
hey.
This
isn't
gonna
work.
Also,
here's
the
exact
code.
You
should
write
to
make
it
work.
It's
really
amazing.
A
The
amount
of
cognitive
effort
I
have
to
do
in
writing
a
program
when
I
write
it
in
rust
is
so
much
lower
than
the
cognitive
effort
of
writing
a
language
writing
in
a
language
that
doesn't
have
these
types
of
guarantees.
It
turns
out
that
compilers
are
really
amazing.
So,
whenever
you're
designing
a
language,
hopefully
one
of
your
goals
is
to
at
least
make
the
right
thing
easy.
A
So
again,
we
will
just
not
compile
your
program
if
it's
going
to
have
errors,
and
so,
to
that
extent
we're
like
dopes
just
can't
do
the
wrong
thing
and,
as
a
result,
we're
able
to
have
programs
that
are
incredibly
reliable
so
on
the
tip
number
eight,
so
we
were
being
prepared
for
things
to
change,
but
now
we
need
to
be
prepared
for
things
to
stay.
The
same
so
boring
code
is
my
absolute
favorite
code.
A
How
many
people
here
like
boring
code,
not
enough
Oh
boring
code,
is,
is
so
great
I
really
love
it,
but
I
understand
that
lots
of
people
write,
love,
writing
clever
code
and
particularly
when
you're
excited
about
a
technology.
You
really
just
want
to
start
leveraging
all
of
its
awesome
superpowers.
You're
like
this
is
what
I
want
to
do.
It's
kind
of
funny
when
I
started
writing
a
lot
of
my
first
rest
code.
I
was
like
worried
that
it
was
not
very
good.
A
So
I
talked
to
some
of
my
friends
and
like
the
core
team
and
I'm
like
is
this.
This
is
like
horrible
Russ
code
and
they
wouldn't
even
look
at
it
and
they're
like
are
using
like
a
box
or
an
arc
or
any
of
that
stuff
and
I
was
like
no
and
they're
like
great
you're,
probably
fine
so
reaching
for
those
awesome.
Superpowers
of
a
language
can
be
something
that's
really
attractive,
but
again,
when
you're
trying
to
get
a
company
to
use
it
wouldn't
like
their
money,
is
at
stake.
They're
writing.
A
Boring
code
can
be
super
good,
so
just
because
you
started
using
rust
doesn't
mean
that
everything
will
change
in
your
company.
In
particular,
you
know
it's
probably
a
lot
better
if
it
doesn't,
when
you're,
adding
company
like
when
you're,
adding
technologies
to
a
company
having
something
be
boring
and
not
a
large
change
is
really
really
important.
So
I
like
to
talk
about
the
scientific
method
here,
a
lot
of
people
think
that
ferrous
is
it's
a
thing
that
I
missed
the
spark
thing.
A
A
A
Think,
that's
that,
oh,
my
goodness,
that's
terrifying
to
me,
like
I,
cannot
predict
how
much
that
is
going
to
actually
take,
whereas
if
you
take
a
little
bit
of
a
look
at
how
that's
working
in
the
web
assembly,
it's
incredibly
small
and
that
reliability
is
more
important
to
me
and
probably
more
important
to
a
company
than
the
actual
speed
difference
and
so
again
being
ready
to
change
your
mind
being
able
to
measure
and
be
able
to
show
some
of
the
most
awesome
things
about.
That
is
incredibly
important.
A
So
the
other
great
thing
about
only
changing
one
thing
at
a
time
is
that
if
you
change
more
than
one
thing
at
a
time,
you're
probably
going
to
burn
a
bunch
of
people
out
having
lots
of
things
up
in
the
air
can
be
incredibly
stressful.
And
so,
even
though
you
are
particularly
excited
about
technology,
doesn't
mean
that
your
entire
team
wants
everything
to
change
at
once.
Sometimes,
if
you're
on
a
deadline,
do
you
want
to
reach
for
the
tool
that
you're
super
comfortable
with
and
so
trying
to
change?
A
Everything
at
once
is
a
recipe
for
failure.
So
one
of
these
things
that
we
saw
at
NPM
is
that
so
Russ
is
a
compiled
language,
we're
able
to
compile
into
binaries,
which
is
super
great.
As
an
ops
person
I'm
like
perfect
binary,
just
stick
it
up.
There
boring
I,
love
it,
but
the
team
really
wasn't
ready
to
set
that
up.
Yet
we
have
an
incredibly
extensive
set
of
Yambol
files.
A
Again,
not
many
ops
people
in
the
house,
but
if
you
do
ops,
all
the
ammo
files-
oh
my
goodness,
but
we
have
tons
of
gamal
and
it
was
kind
of
a
big
pain
in
the
butt.
And
what
we've
realized
is
that,
even
though
Russ
is
able
to
generate
a
binary
for
us
at
that
moment,
we
just
needed
to
deploy
the
rest.
The
same
way,
we
were
deploying
the
node.
So
this
is
how
we
do
it
again.
Here's
some
some
gamal,
it's
delightful,
but
we
decided
to
do
the
same
thing.
A
A
A
You
have
not
the
one
you
want
to
have
and
yet
I
see,
so
many
people
constantly
solving
the
problems
that
they
think
are
super
cool,
but
not
actually
the
ones
that
they
have
now
I
like
to
say
that
finding
a
problem
should
be
easy,
because
all
software
is
terrible.
It
really
is
I,
don't
know
if
you're
here
and
you
think,
computers
work.
Please
bring
me
hope,
because
my
experience
throughout
software
is
like.
If
it
works,
that's
that's
great
but
like
it
probably
won't
work
for
long.
A
So,
as
I
told
you
at
MPM,
big
numbers
are
big
when
I
was
writing
this
service
that
I'm
gonna
talk
to
you
about,
we
had
about
70
billion
downloads
occur
on
the
service,
so
that
is
a
lot
of
traffic,
and
these
are
her
rolling,
weekly
downloads
they're
going
straight
up
just
for
fun,
though,
you
might
notice
that
huge
crevasse
there
people
actually
do
take
vacation
on
Christmas,
it's
cool.
We
literally
see
it.
A
A
So
we
have
something
in
MPM
called
Store
file
transforms,
which
is
to
say
when
we're
building.
When
you
have
a
package,
you
also
have
a
bunch
of
other
stuff
associated
with
the
package
like
a
readme
and
also
some
metadata,
and
we
need
to
do
processing
on
this,
and
so,
if
you're
curious
about
something
that
rust
is
particularly
good
at
rust,
is
super
good
at
just
processing
files.
Markdown.
All
of
this,
it's
super
excellent
at
that,
and
so
we
had
this
kind
of
similar
situation
where
we'd
get
changes
in
and
those
changes
particularly
were
publishes.
A
And
then
what
we
needed
to
do
was
to
take
a
bunch
of
the
metadata
and
associated
files
with
that
publish
and
then
run
a
bunch
of
transforms
on
those
files.
And
so
we
were
doing
this
in
node
and
it
was
falling
over
the
memory.
Problems
were
terrible,
and
so
you
might
be
like
you're
a
bad
developer
and,
like
I
mean
probably
aren't
we
all
bad
developers,
but
we're
pretty
like
much
of
the
engineering
resources
at
MPM
are
people
who
are
like
on
the
node
TSC
and
like
working
literally
on
nodes.
A
So
we're
pretty
good,
but
it
turns
out
that
memory
is
always
still
a
problem,
and
so
what
we
were
able
to
do
is
we
were
able
to
take
that
bit
just
that
one
tiny
bit,
and
so,
if
you're
wondering
where
is
the
rust
in
NPM,
the
rust
is
in
the
store
file
transforms,
there's
actually
a
couple.
Other
auth
services,
mostly
associated
with
our
enterprise
product,
but
the
store
file
transforms,
are
all
done
in
rust
and
that's
because
they
were
able
to
do
it,
not
in
necessarily
a
fancy
way.
A
A
Don't
make
people
take
on
risk.
They
don't
need
to
find
the
parts
where
you're
already
having
risk
and
try
and
alleviate
them.
So
the
final
tip
tip
number
10
is
learning.
Curves
are
a
blessing
in
disguise.
How
many
people
have
heard
that
it's
hard
to
learn
rust,
alright,
I'm,
here
to
tell
you
that
many
people
report
that
is
incredibly
hard
to
learn
rust.
A
However,
one
of
the
things
that
you
have
to
manage
at
a
company
is
employee
motivation,
and
so
this
is
my
colleague
Ryan
who
was
working
through
that
you
know
kind
of
weird
log
parser.
He
was
writing
and
what
he
said
is
this
is
the
really
fun
part
about
learning
new
things.
I
still
have
the
patience
to
do
any
number
of
silly
things,
and
so
that's
like
kind
of
adding
a
joy,
and
so
we
all
kind
of
slave
away.
A
So,
in
summary,
these
are
all
your
lovely
tips,
apply
them
all
at
once
and
enjoy
the
pleasure
of
contradictions.
So
to
end
I'll
say
if
you're
gonna
repair
a
motorcycle,
an
adequate
supply
of
gumption
is
the
first
and
most
important
tool.
If
you
haven't
got
that,
you
might
as
well
gather
up
all
the
other
tools
and
put
them
away
because
they
won't
do
you
any
good,
so
gumption
here
is
you
know
the
definition
is
a
spirited
initiative,
but
also
resourcefulness,
being
really
enthusiastic
and
shouting
from
the
rooftops
that
you
love
a
technology.
A
A
You
can
take
rust
and
compile
it
to
web
assembly
and
be
able
to
plug
it
just
directly
into
some
browser
code
or
some
node
code
if
you're
interested
in
that
tool.
This
is
the
tool
I
work
on
right
now.
It's
called
Waze
impac.
If
you
like,
the
crab
I
have
stickers
so
go
forth
and
try
new
things.
This
is
the
repo
thanks.
So
much.