►
Description
Presented by Herman Radtke
The modern web stack is made up of a dozen different systems, but too few people know how to create and support them. I believe this is because systems programming has historically had too many barriers to entry, such as memory safety and the trading of expressiveness for performance. Let us explore some of the ways Rust breaks down these barriers and can make systems programming feel much more approachable to web developers
About CodeConf
CodeConf improves the software community by providing a forum for thought-provoking talks and forging social connections. The fourth installment of the CodeConf series took place in Hollywood in 2016. This year's event focused on systems engineering projects, practices, and programs in the open source community.
For more information on this year's CodeConf, go to:
https://codeconf.com/
A
Howdy
there
we
go
yeah
I'm
here
to
talk
about
rust
systems,
programming
for
web
developers.
I
will
talk
about
how
web
developers
can
become
systems,
programmers
not
how
to
apply
systems
programming
to
web
development,
and
for
anyone
not
aware
rust
is
a
new
language
by
Mozilla,
that's
kind
of
in
that
C++
space.
A
And
when
you
start
talking
about
how
you're
going
to
grow
the
rust
community
very
quickly,
you
people
start
talking
about
well,
do
you
think
rust
is
going
to
kind
of
beat
C++
like
it's
going
to
take
all
those
people
and
move
them
over
from
C++
to
rust?
I
think
this
is
kind
of
short-sighted,
like
a
misguided
way
of
thinking
about
how
you're
going
to
grow
a
new
language.
A
So
I
argue
instead,
let's
look
for
a
different
way
to
actually
grow
the
rust
community,
and
if
you
look
at
web
developers,
that's
one
of
the
fastest-growing
and
largest
groups
of
developers
in
our
community
right
now
and
I.
Think
rust
will
make
systems
program,
programming
more
accessible
to
all
those
web
developers.
So,
rather
than
talking
about
you
know,
how
do
we
just
take
this
zero-sum
pie
and
kind
of
shift?
A
It
around
let's
talk
about
how
rust
can
actually
make
that
pie,
bigger
and
grow
the
overall
systems,
programming
community
I
think
there's
some
historical
precedents
for
this
idea.
If
people
remember
when
rails
1.0
came
out,
there
are
many
discussions
about
whether
rails
would
sort
of
take
over
PHP
as
the
most
common
web
language.
As
we
now
know
that
didn't
happen.
Php
is
by
far
still
the
most
popular
programming
language
in
the
web,
due
to
things
like
WordPress
and
rails
has
allowed
Ruby
to
sort
of
act
out
a
pretty
sizable
chunk
of
the
web
developer
space.
A
I
would
argue
that
whatever
language
you
use
has
been
influenced
by
these
tools
and
the
way
you
operationalize
that
code
in
production
today
and
more
recently,
we're
in
this
peak
node
sort
of
a
time
where
you
can
take
any
UI
developer
slap,
some
note
on
them.
You
have
a
full
stack
engineer
right
and
what's
interesting
about
node
when
you
look
at
it,
node
doesn't
actually
introduce
like
new
technology
concepts.
Async
I/o
libraries
that
existed
for
decades
and
also
Rhino,
which
is
a
Java
JavaScript
interpreter,
has
existed
for
a
long
time
as
well.
A
And
so
what
note
came
out
you
have
all
these
server-side
developers,
myself
included,
going
I,
don't
get
it
like
it?
That's
not
going
to
replace
Ruby
or
Python
or
PHP
like.
Why
are
people
so
excited
about
this
thing
and
we
sort
of
missed
this
whole
movement,
whereas
Webb's
continuing
to
eat
the
desktop,
and
these
client-side
developers
are
under
all
this
pressure
that
both
these
really
rich?
You
know
interactive
user
experiences
and
they're
trying
to
talk
to
these
server-side
developers
and
feel
like
we
needed
to
work.
A
Better
and
and
again
we
missed
it.
A
lot
of
the
server-side
developers
are
putting
up
post
like
demo.
Gs
is
a
cancer
and
putting
up
benchmarks
like
Fibonacci,
doesn't
run
well
on
node,
and
we
just
sort
of
totally
missed
it.
I
think
something
is
similar,
can
kind
of
be
going
on
with
systems
programming
right
now,
I
think
systems
programming
is
becoming
a
little
more
in
vogue
as
of
late
and
we're
starting
to
see
people
getting
involved
from
outside
traditional
systems.
Programming
communities,
and
so
we
can
kind
of
look
at
like
well.
A
Why
is
this
and
I
would
argue
that
the
modern
web
stack
is
getting
a
lot
more
complex
sort
of
gone
are
the
days
where
you
can
kind
of
take
Apache
mod
PHP
instead
of
a
my
sequel
database
and
have
a
web
server
that
should
have
runs,
and
instead
of
satisfies
the
business
right
now
we
have
services
and
even
micro
services
and
we're
splitting
up
even
front-end
and
server-side
concern.
So
what
happens?
Is
we
introduce
all
these
different
components
into
our
production
environment?
A
lot
of
these
components
are
written
in
C
or
C++.
A
The
few
people
that
are
supporting
these
that
write,
C
or
C++
and
what
happens
is
those
people,
those
open-source
maintainer
x',
are
only
able
to
keep
up
with
the
sort
of
most
high
priority
tasks
like
they're
not
paid
for
serve
a
volunteer,
and
that
means
they
don't
have
time
for
answering
things
like
documentation.
I'd
also
argue
that
they
don't
have
time
to
actually
think
ahead
to
there's
being
so
tactical,
and
we
can
see
this
on.
A
Twitter
people
are
burning
out,
but,
there's
being
so
a
tactical
and
kind
of
maintaining
these
things
that
they're
not
able
to
think.
What's
the
you
know,
what's
the
future
look
like
or
how
can
I
improve
this
by
orders
of
magnitude,
so
the
hint
at
the
state
of
the
arts
being
hindered
but
I
also
thinks
for
web
developers.
This
is
a
disadvantage
to
us,
because
if
we
rely
on
people
that
aren't
in
web
development
writing
these
tools
for
us
we're
missing
core
use
cases.
A
We've
seen
this
the
browsers
used
to
have
standards
written
by
tc39
that
missed
all
sorts
of
use
cases,
and
that's
because
tc39
man
was
made
up
of
people
who
were
not
writing
for
the
web.
That's
changed
recently
and
we're
getting
better
standards
that
come
out
of
it,
and
we
see
this
in
the
server-side
development
too
I
write,
PHP,
there's
a
class
called
PDO
for
PHP
data
object
and
when
you
instantiate
this
class
for
database
access,
we
connect
to
the
database.
A
Any
web
developer
knows
that
the
biggest
bottleneck,
usually
the
biggest
bottleneck
to
your
application,
is
database,
and
so
that's
a
core
use
case.
Myths,
where
the
person
who
wrote
PDO
was
a
great
C
developer
to
them,
as
was,
but
he
was
not
a
web
developer.
So
she
missed
this
core
use
case
and
I
was
like
a
decade
ago.
We
still
work
around
this
today
in
in
PHP
code,
and
we
asked
want
why
aren't
people
getting
more
involved?
Why
aren't
web
developers
sort
of
you
know
moving
in
droves
to
go
solve
these
problems?
A
There's
a
lot
of
sort
of
barriers
to
entry
here,
right,
first
and
foremost
web
developers.
They
prefer
garbage-collected
languages,
but
if
we're
trying
to
write
systems
code
word,
it
really
matters.
We
can't
sort
of
afford
the
tax
of
garbage
collection.
So,
as
a
web
developer,
you
have
to
actually
start
dealing
with
memory
management,
the
allocating
and
the
freeing
of
memory
in
C
or
C++.
That
has
a
lot
of
foot
guns.
Put
yourself
in
the
shoes
of
a
web
developer,
who's
trying
to
solve
some
pain
point
to
scratch.
A
Some
itch,
probably
they're
out
the
workplace
where
they're
having
this
problem
because
we're
at
you
know
web
scale
and
they're
like
hey
I'm,
going
to
write
some
C
or
C++
to
Co
solve
this
problem
and
they
write
some
code.
It
compiles
no
warnings,
even
if
it
have
W
all
turned
on
no
warnings.
They
ship
at
your
production
and
just
blows
up
spectacularly
in
their
face
right.
Either
it's
seg
faults
or
they
weren't
careful
enough
and
they
introduced
some
big
security
vulnerability.
That's
just
a
tough
order
of
business.
For
someone
to
do
and
I
think
thread.
A
Safeties
are
much
the
same
boat.
Even
the
most
experienced
C++
developers
continue
to
make
mistakes
when
it
comes
to
threads.
In
fact,
the
whole
reason
Mozilla
started
to
actually
look
at
funding.
Rust
was
because
they
would
go
into
these
competitions
like
poned
own,
where
all
these
browsers
would
be
sort
of
battle
tested
for
security
issues
and
threads
consistently
were
the
main
thing
that
security
researchers
attacked
to
exploit
the
Firefox
browser.
I.
Think.
Third,
when
you
look
at
C
or
C++,
this
is
X.
A
It's
not
a
very
expressive
language
right,
so
web
developers,
especially
if
you
prefer
a
ruby
or
a
Python.
You
put
a
lot
of
stock
and
the
fact
that
these
languages
are
not
only
nice
to
write
but
nice
to
read.
Sandi
Metz
has
even
been
quoted
as
saying
I
will
give
up
some
CPU
cycles
to
make
my
code
more
readable
and
more
maintainable,
and
if
you
sort
of
hop
into
some,
you
know
popular
C
or
C++
repositories
out
there,
it's
quite
difficult
to
read.
You
have
a
lot
of
pointer
indirection.
A
You
have
a
lot
of
macros
being
defined.
You
have
a
lot
of
code
where
the
intent
is
not
clear
because
they
have
modify
the
code
in
the
name
of
performance,
and
so,
if
you're,
trying
to
get
involved
in
that
language
or
into
that
program,
I'm.
Sorry,
that's
just
a
tough
it's
something
to
do
so,
coincidentally,
I
think
rust
solves
these
three
things
pretty
well.
A
So
it's
this
concept
of
ownership,
that
sort
of
solves
these
first,
two
things
in
rust
and
ownership
is
a
set
of
guidelines
or
principles,
but
actually
exists
as
conventions
in
C++,
but
that
are
actually
codified
in
the
compiler
in
the
rust
compiler.
The
piece
of
the
compiler
is
called
the
borrow
checker,
and
that
means
the
compiler
at
compile.
A
Not
all
memory
leaks,
that's
a
halting
problem,
that's
pretty
much
impossible,
but
a
lot
of
the
the
ones
that
a
compiler
can
do
are
automatically
removed
and
what
we
sort
of
see
as
people
that
are
web
developers
or
just
non.
You
know
super
not
experienced
C++
developers,
they
start
writing
rust
code
is
that's
a
compiler.
It
gets
in
their
way
right,
they're.
A
Trying
to
basically,
you
know,
do
something
new
to
solve
a
problem
and
they
write
it
in
a
way
that
they
had
write
some
sort
of
scripting
language
to
solve
the
problem
and
the
compiler
to
start
to
yelling
at
them,
and
because
it's
a
computer
doesn't
care
how
you
feel
doesn't
care,
how
frustrated
you
get
it
forces
you
to
ax,
start
changing
your
code
and
writing
in
a
way
that's
safe
and
it
won't.
Let
you
get
around
that.
A
What
starts
to
happen,
though,
is
what
we've
noticed
is
that
people
start
to
sort
of
learn
ahead
of
time
that
the
compiler
tell
me
this
is
wrong,
I'm,
just
going
to
write
it
this
other
way
instead,
so
that,
even
if
they
stop
writing
Russ
and
actually
go
back
and
write
C
rat
C++,
they
can
actually
into
it
these
ownership
guidelines
and
principles
that
are
conventions
in
C
or
C++,
and
actually
go
off
and
be
even
successful
systems.
Programmers
in
those
languages,
so
the
compiler
starts
acting
like
this.
A
This
teacher,
in
addition,
we'd
also
get
the
second-order
effect
where,
if
you
are
someone
who
is
new
to
a
community,
your
web
developer,
who
wants
to
get
involved
in
systems
programming?
Most
of
us
do
that
through
open
source-
and
you
know
many
languages,
not
even
just
C,
C
or
C++,
but
even
our
scripting
languages.
A
It
actually
moves
all
of
these
sort
of
common
errors
and
use
cases
from
the
code,
and
even
if
you
don't
have
tests
many
times,
you
don't
have
tests
when
you're
writing
large
portions
of
rust.
You
have
all
this
confidence
that
the
code
pretty
much
does
what
it
says
it
does.
Now.
You
may
miss
domain
logic
issues
you
might
have
like
bugs
in
your
domain
logic
or
business
logic,
but
you're
pretty
reasonably
assured
that
you
can
contribute
that
code
and
it
won't
like
sec
fault
in
production
and
cause
someone
a
lot
of
pain.
A
You
can
have
you
know,
code
that
looks
like
Ruby
when
you're
writing
it
in
your
editor,
but
when
it
compiles
down
into
assembler
and
actually
is
running
like
you
wrote,
high-performance
C
now
this
is
my
only
code
sample
and
that's
talk,
but
I
thought
this
was
just
a
really
succinct
way
to
kind
of
demonstrate.
This
idea
of
zero
cost
abstractions.
A
So
here
we
have
a
list
of
numbers
1
through
10,
and
we
are
mapping
over
those
numbers
and
multiplying
by
this
by
2,
then
filtering
over
those
numbers
and
dropping
any
ones
that
are
greater
than
5
and
then
it's
finally
folding
over
those
numbers
to
accumulate
those
values
into
a
single
result.
Now,
if
we
were
to
write
this
in
Ruby
or
type
on,
this
would
be
free
passes
over
that
list
right
and
if
we
were
to
then
take
this
code
and
try
to
actually
say
well,
we
need
to
make
it
more
performant.
A
We
need
to
rate
this
and
like
see
you
would
have
to
manually
transform
this
from
free
passes
to
a
single
pass,
not
only
taking
introduce
bugs,
but
you
actually
then
sort
of
lose
the
intent
of
the
code
rewriting
and
just
make
it
harder
to
read
and
maintain
now
with
the
rust
you.
Actually,
this
is
working
rust
code.
You
write
it
like
this
and
then
Ross
uses
LLVM
just
to
compile
it
down
and
make
it
fast.
A
A
A
lot
of
people
actually
think
about
rust.
They
hear
hey
that
the
compilers
li
tough
to
work
with,
and
it's
sort
of
hard
to
get
involved
now.
I
think
that's
true,
but
I
don't
think.
Russ
is
sort
of
gone
to
the
extremes.
A
lot
of
people
think
it
has
I.
Think
Russ
is
a
very
pragmatic
language.
It
goes
to
solve
real
world
problems,
which
should
be
of
importance
to
web
developers
and
I
call
like
this
notion,
like
optional
correctness.
A
So
if
you
are
writing
your
code
and
rust
and
you're
prototyping,
something
out,
you
may
not
want
to
handle
all
the
error
conditions
now.
Russ
has
these
return
types
called
options
and
results,
and
what
you
can
do
is
you
can
just
unwrap
these
things
and,
if
you're
in
the
happy
path,
if
things
are
working
correctly,
you
get
your
value
back.
A
You
move
on,
but
if
there
is
an
error,
the
code
blows
up
right
there
like
in
pre-production,
like
when
you're
writing
the
code
and
that's
fine
you're,
not
you're
prototyping
right,
like
you're,
not
you're,
not
actually
trying
to
ship
this
yet
and
when
you
actually
finally
solve
the
problem,
you're
you're
done
spelunking
or
exploring
to
this
problem
space.
You
can
go
back
and
actually
remove
those
unwraps
and
actually
handle
the
errors
properly.
This
is
a
nice.
A
You
know:
we've
tried
to
solve
the
same
problems,
other
languages
like
Haskell,
but
they
forced
you
to
sort
of
handle
all
the
conditions
upfront
before
you
really
get
something
working.
I.
Think
you
know
we
can
extend
this
idea
of
optional
correctness
even
to
the
result
and
option
types
themselves.
If
you
are
recognize
these
terms,
these
are
similar
names
with
exact
names
to
monads,
but
it
rusts
they're,
not
actually
true
monads.
They
were
world
more
pragmatic.
A
You
can
actually
exit
the
function
or
even
the
entire
program
when
you
start
destructing
these
types,
which
is
really
nice
if
you're
handling
errors.
So
again,
you
rust
times
like
this
very
pragmatic
approach
to
solving
problems.
They're
not
worrying
about
like
theoretical
correctness
and
then
the
most
common
way
you
can
sort
of
be
you
can
opt
out
of
correctness
in
rust,
is
to
wrap
your
code
in
an
unsafe
block.
A
So
as
nice
as
the
Russ
compiler
is
there
are
times
when
you
have
to
actually
do
unsafe
things
either
the
problem
requires
it
or
you're,
actually
interacting
with
all
the
other
languages
out
there,
whether
it's
C++
or
whether
it's
a
scripting
language,
you
have
to
have
some
some
layer
of
safety
and
Russ
allows
you
to
sort
of
demarcate
this
and
so
Louis.
You
know
99%,
your
code
can
be
safe
and
you
can
opt
out
for
that
1%
of
code
that
you
now
need
to
really
focus
on
and
actually
hints
to
everyone
else.
A
This
is
what
you
need
to
focus
on,
because
it
wraps
it
explicitly
in
those
unsafe
blocks,
and
this
is
why
I
think
Russ
has
such
a
nice
for
in
foreign
function.
Interface
story.
So
if
you're
a
web
developer
you're
trying
to
get
involved
in
systems
programming,
you
probably
don't
want
to
take
your
entire
program
and
write
the
entire
thing
in
a
new
language.
Not
only
is
that
you
know
take
a
lot
of
time
as
a
lot
of
risks.
There
is
probably
not
worth
it.
A
A
lot
of
the
code
probably
actually
works,
fine
and
you're
holding
in
on
a
few
problem
spots.
What
you
actually
can
do
with
Russ
since
the
the
FF
is
so
good.
You
can
profile
your
code,
find
the
hotspots
and
then
rewrite
those
in
Russ
I've
done
that
myself.
I
took
a
Gary
Bernhardt
selector
program,
which
is
like
a
fuzzy
matcher
over
text
for
searching.
Do
you
like
text
with
on
your
editor
and
stuff
and
I?
A
Looked
at
it
in
the
search
algorithm
was
the
hottest
part
of
the
code
and
because
it
was
Ruby
it
just
wasn't
as
fast
as
it
needed
to
be.
I
rewrote
that
in
rust
it
was
actually
pretty
easy
just
to
compile
that
rust
into
a
library
and
interface
it
into
the
Ruby
code
and
there's
actually
lots
of
examples
out
there.
Where
people
are
doing
this
now,
you
can
do
it.
A
Ruby,
Python
and
PHP
pretty
easily
those
all
written
in
C,
and
now
you
can
even
do
it
in
node,
which
is
C++,
but
there
are
now
facilities
to
do
that,
and
even
entire
layers
of
libraries
that
make
that
really
easy
for
you
to
get
involved
in
and
have
to
worry
about
some
of
the
nitty-gritty
details
at
the
flip
side.
Q2.
So
C
is
everywhere
right,
pretty
much
everything
at
when
you
boil
it
down
to
is
on
C.
A
So
if
you
are
a
developer,
you
want
to
get
involved
in
a
existing
project,
that's
written
in
C
or
C++.
You
don't
actually
have
to
write
C
or
C++.
You
can
actually
write
rust
and
interface
that
into
C
or
C++
directly.
So
you
can
start
augmenting
bits
of
common
libraries
out
there
like
we're
not
going
to
rewrite
the
Linux
kernel
and
rust.
We've
seen
that
sort
on
that
orange
website
out
there,
people
sort
of
sometimes
say:
oh
we're
going
to
rewrite
this
entire
Linux
kernel,
it'll
rust,
it's
not
going
to
happen.
A
What
we
can
do
is
we
can
introduce.
You
know
bits
of
rust
into
the
ecosystem
and
that's
actually
what
Mozilla
is
doing
with
the
Firefox
browser.
That's
all
written
in
C++,
but
now
I'm
URL
handling
in
a
Firefox
preview,
is
handled
by
Roscoe,
so
I
kind
of
want
to
leave
us
with
this.
This
idea
that
you
know
systems
programming
is
hard
because
systems
are
hard.
A
It's
hard
to
write
drivers
for
Linux
kernel,
it's
hard
to
make
a
program
like
engine
X
run
really
fast,
but
we
should
use
a
language
that
actually
solves
all
the
problems
that
can
be
solved
with
a
compiler
and
then
use
the
human
brain
to
actually
focus
on
things
like
optimization
or
reasoning
about
really
hard
problem
spaces.
So,
if
you're
interested
in
rust,
there
are
a
number
of
links
on
these
slides,
you
can
jump
into
whether
your
web
developer
or
otherwise.
Some
of
these
are
official
links.
A
Some
of
these
are
community
driven
links,
I
think
they're,
all
good
and
also,
if
you
are
in
LA
local
I,
run
the
La
Russa
meetup,
so
I
encourage
you,
whether
you're
brand
new
to
software
development
or
whether
your
experience,
if
you're
interested
in
learning
rust,
we
meet
in
the
middle
of
the
month
on
Wednesdays
in
Culver,
City,
pretty
close
nearby
and
we're
a
very
welcoming
group.
So
you
can
get
involved.
We
we
sort
of
specialize
in
sort
of
ramping
people
up
and
we
know
you're,
probably
not
writing
rust
at
work.
A
So
we
let
you
do
that
at
these
meetups
so
come
on
and
join
us
again.
My
name
is
Herman
I
work
at
Nordstrom,
Rack,
comm,
slash
hautelook.
Thanks
to
my
team
for
coming
on
and
watching
me.
Of
course
we
are
hiring
get
at
us
there's.
My
information.
If
you
want
to
learn
more
to
please
hit
me
up
I'm
happy
to
talk
about
this
stuff.
A
I
have
lots
of
good
blog
posts
about
getting
introduced
to
rusts,
especially
if
you're
trying
to
reason
about
various
things,
and
you
don't
understand
some
of
the
different
ownership
types
of
rust
check.
Those
out
I
don't
have
time
for
questions,
but
please
get
at
me
at
the
at
the
lunch
area,
I'm
happy
to
talk
through
things
with
you
and
answer
anything
there.
Thank
you.