►
Description
Scale By the Bay 2019 is held on November 13-15 in sunny Oakland, California, on the shores of Lake Merritt: https://scale.bythebay.io. Join us!
-----
Bryan, the CTO of Joyent, and a core contributor to Solaris, ZFS, and DTrace, formerly a Distinguished Engineer at Sun, has recently picked up Rust. He'll share his experience with us.
A
Good
morning
everybody
it's
great
to
be
here
I.
This
is
definitely
the
first
time,
maybe
the
only
time
in
my
life
that
I'm
in
the
functional
programming
track.
That
is
definitely
a
first.
So
it's
exciting
because
often
on
honestly
functional
languages
have
not
really
functional.
Programming
has
not
really
been
on
the
menu
for
me
as
a
system
software
programmer
it
kind
of
actually
entered
the
menu.
Ironically
enough
with
JavaScript
I
mean
I'm
embarrassed
to
say
this,
but
I
I
really
I
mean
I.
Yes,
my
degrees
in
computer
science.
A
Oh
my
god,
that's
a
real
language
here
in
terms
of
JavaScript.
It's
not
just
for
blank
tags
like
I'm,
actually
doing
interesting
things
and
I,
actually,
like.
Oh,
my
god,
I,
actually
I
I'm
learning
what
a
closure
is
I'm.
Actually
I
am
appreciating
a
lambda
I'm,
actually
appreciating
this
stuff,
so
that
was
great,
but
in
JavaScript
has
been
great
but
and
we've
used
to
Detroit
for
a
bunch
of
different
reasons.
But
the
truth
is
that
in
the
deeper
parts
of
system
software,
we
have
not
really
had
that
kind
of
power.
A
That
that
programmatic
power,
we've
proven
kind
of
stuck
and
I,
think
we're
about
to
get
unstuck
and
I
want
to
kind
of
explain
what
what
I'm
seeing
there
I
want
to
talk.
First
about
about
platform,
values
and
software
values,
because
the
older
I
get
the
more
I
believe
that
that
values
are
really
core
to
the
decisions
that
we
make.
So
what
do
I
mean
by
by
values?
So
values
are
positive
traits
that
you
are
choosing
amongst.
A
So
we
all
that
there
are
lots
of
kind
of
positive
things,
but
our
own
individual
values
will
dictate
when,
if
we,
when
we
have
to
choose
between
two
things,
how
we
actually
make
that
choice
and
different
platforms
make
that
choice
differently
and
too
often
I
think
that
we
look
at
the
different
choices
that
a
different
platform
has
made
and
we
we
will
criticize
those
choices
or
we
will
embrace
those
choices.
But
we're
actually
doing
is.
We
are
commenting
on
our
own
values
relative
to
the
values,
perhaps
of
a
different
system.
A
Do
the
values
here
reflect
the
values
that
I
want
for
this
thing,
especially
when
community
is
so
important,
I
mean
in
an
open
source,
world
you're,
selecting
community
as
much
as
you're,
selecting
anything
else
and
I've
learned
this
the
hard
way
where
you've
got,
because
if
you
like
I
love
the
technology
and
the
community
is
I've,
got
come
comes
vicious
with,
but
I
really
love
the
technology.
If
the
community
doesn't
reflect
your
values,
you
will
find
that
the
software
will
come
to
not
reflect
your
values
as
well.
A
So
you
really
need
to
need
to
define
the
right
community
for
the
values
the
right
values,
then
for
it
for
the
job,
the
right
software
for
the
value.
So
what's
gonna
make
this
a
little
more
specific
here,
so
this
is
just
kind
of
a
scattering
of
random
values.
These
are.
This
is
not
a
very
well
organized
list.
I
guess
it's
alphabetical,
I
guess
I
could
make
it
alphabetical
other
than
that.
It's
not
really
sorted.
It's
not
meant
to
be
exhaustive.
A
There
are
lots
more
values
than
this,
and
each
of
these
values
kind
of
mean
different
things
to
different
people.
So
there's
a
lot
of
nuance
here,
but
we
can
kind
of
generally
agree
what
it
means
to
have
performances
of
value,
what
it
means
to
have
robustness
as
a
value
or
debug
ability
as
a
value
or
composability
as
a
value
or
expressiveness.
As
of
you,
and
you
can't
have
it
all,
you
can't
choose
all
of
these
things.
We
can
all
agree
that
each
of
these
things
is
important.
A
I,
don't
think
any
of
us
would
say
that
that
value
is
just
garbage
and
you
should
never
want
it
right.
I
mean
for
I,
don't
know.
Maybe
there
are
some
things
up
here,
but
I
think
that
in
general
we
would
say
you
know
all
of
these
things
are
important,
they're
good,
they
have
their
place.
But
the
real
question
is:
when
you
have
to
make
a
choice
between
two
of
them.
What
do
you
choose
and
those?
A
What
that
choice,
that
you
make
you
being
a
software
platform,
a
language,
a
community,
that
choice,
reflects
the
core
values
of
that
that
platform
or
language,
and
you
can't
have
every
value,
be
a
core
value.
So
what
are
the
core
values
of
some
of
these
things?
Because
these
things
are
in
tension
and
I
think
that
they
do?
A
When
you
have
these
core
values,
they're
going
to
attract
like-minded
folks
and
as
a
result,
they
become
self
reinforcing,
because
those
who
are
attracted
to
those
values
are
attracted
to
the
software
and
then
they
want
to
defend
those
values
in
the
software.
They
want
those
values
to
remain
consistent
so
that
they
there's
a
self-fulfilling
prophecy
here.
So
let's
look
at
these
values
so
kind
of
grayed
out
the
values
that
they
don't
have
and
say.
You
know
the
history
of
C
is
pretty
interesting.
A
A
If
slightly
units
was
developed
originally
all
in
assembly-
and
there
was
an
opera,
there
was
a
language
called
B
that
was
kind
of
floating
around,
but
they
didn't
really
use
B
for
very
much
B
was
slow,
so
B
was
used
for
some
ancillary
parts
of
the
operating
system,
and
they
they
saw
the
need
to
develop
a
higher-level
language,
a
structured
language,
although
the
higher
level
came
first
that
would
allow
them
to
not
have
to
employ
in
the
operating
system
in
assembly.
That
is
that
the
birthplace
of
C
is:
we
want
effectively
a
better
assembly.
A
We
want
a
non
machine,
specific
assembly
and
that's
what
C
is
see
is
effectively
portably
assemble
portable
assembly.
The
a
number
one
goal
of
C
is:
is
performance
and
I
add
interoperability
that
are
as
well,
because
it
is
just
models.
The
Machine
C
is
designed
to
interoperate
with
anything
that
can
execute
on
the
machine
effectively,
so
C
interoperates
with
assembly.
It
can
interoperate
with
effectively
anything
that
is
going
to
actually
operate
on
the
machine,
so
interoperability
is
very
important
portability.
These
are
important
and
then
simplicity.
A
One
of
the
things
that's
interesting
about
C
is
C
only
grew
those
things
that
were
needed
to
implement
UNIX,
so
they
didn't
add
structures
to
UNIX
or
just
C
until
they
realize
they
needed
them
named
one
UNIX,
so
C,
it
really
didn't
have
structures
seems
like
what
do
you?
What
does
he
have?
If
it
doesn't
have
structures
seems
like
it
has
precious
precious
little,
but
assembly
doesn't
have
structures.
A
So
why
would
you
and
then
that
you
know
what
structures
would
make
this
a
lot
easier,
so
they
added
structures,
okay,
but
they
kind
of
stopped
there
and
C
has
retained
that
minimalist,
aesthetic
which
I
think
is
very
core
to
two
C's
value.
So
this
is
what
I
would
say.
These
values
are,
and
it's
not
that
C
doesn't
care
about
these
other
things.
It's
just
that
it
deliberately
if
it
has
to
make
a
choice
between
these
or
when
it
had
to
make
a
choice
between
these.
A
These
are
the
ones
that
that
it
chose,
and
admittedly
C
is
also
in
a
time
when
a
lot
of
these
things
are
much
more
profound
tension,
performance
and
expressiveness,
for
example,
we're
very
much
in
tension
and
that
they
chose
performance
just
throw
that
as
long
as
doing
one
letter,
languages
in
terms
of
B
and
C
might
as
well
throw
K
in
there.
It's
got
nothing
to
do
with
system
software
enough
people
know
K,
K
and
Q.
It's
follow-on
were
developed
by
again
Arthur
Whitney,
who
is
definitely
unlike
a
different
astral
plane.
A
So
Arthur
believes
that
the
Arthur's
aesthetic
is
all
around
minimalism
and
expressiveness.
Arthur
Arthur
learned
APL
from
Ken
Iverson
at
age,
four
I'm,
not
making
this
up
he's
like
Ken,
Iverson's,
neighbor
and
further
Arthur
has
the
belief
which
I
admire
and
I
love
and
I
I
mean
I.
I,
don't
want
to
like
III.
Don't
want
to
talk
him
out
of
this
belief
that
he
can
teach
any
four-year-old
API.
A
Now,
when
he
told
me
this
I
had
a
four
year
old,
that
I
knew
for
a
fact
could
not
be
taught
APL
I
mean
I'm,
Betty
and,
and
he's
like
you
should
bring
your
four
year
old
and
I
will
teach
them.
Aap
I'm
like
this
is
gonna
end
poorly
for
everybody,
because
I
you
are
not
gonna,
be
able
to
teach
him
APL
and
he's
gonna
be
very
upset
having
to
learn
aap
I
think
this
is
not
gonna
do
well
we're
not
I'm,
not
gonna.
A
Call
this
Bluff,
but
I
I
I
admire
the
beauty
of
a
brain
that
believes
that
APL
can
be
taught
to
a
four-year-old.
That's
that's
amazing
to
me
on,
but
Kay's
only
values
are
in
that
expressiveness
Arthur
wants
to
write
a
program
and
I.
Guess
it's
not
funny
I
shouldn't
say
without
laughing
in
as
few
characters
as
possible.
I
mean
that
is
what
beauty
is
Arthur
fewest
number
of
characters.
I,
don't
know
if
he
feels
he's
gonna
be
vividly
punished
for
the
number
of
characters
uses
I,
don't
quite
understand
what
drives
that.
A
But
that's
what
drives
that
and-
and
he
will
make
code
denser
and
denser
and
denser
and
denser-
is
it
readable?
It
is
emphatically
not
readable
and
it
looks
like
you
know,
and
from
if
you're
of
my
vintage
it
looks
like
your
mom
picked
up
the
phone
when
you
were
on
the
modem
and
you
get
like
a
bunch
of
line
noise
like
that's
like
compilable,
K,
I,
think,
but
it's
beautiful
alright.
So
that's
in,
but
these
are
the
only
values
like
don't
care.
Do
we
dead?
We
don't
get
maintainability
readability,
no,
don't
care!
A
We
care
about
its
expressiveness
in
performance.
That's
it
performs
very,
very
well
and
used
often
for
market
facing
kind
of
operations.
I
just
gotta
throw
this
in
there
for
another
one.
That's
quick!
That's
kind
of
clarifying!
You
know,
OpenBSD
the
operating
system,
security,
end
of
core
values,
the
there
is
no
other
core
value
in
open
BSD
in
that
and
that
that's
not
I'm
not
being
perative.
It's
actually
incredibly
clarifying
when
you
have
a
system
that
is
so
upfront
and
transparent
about.
A
This
is
what
we
care
about
and
we
don't
care
if
we're
gonna
make
the
system
much
slower
to
make
it
secure.
That's
what
we're
gonna
do
if
we
need
to
turn
off
hyper-threading,
because
we
believe
that
hyper
threading
is
unsafe
at
any
speed.
That's
what
we're
gonna
go.
Do
and
you're
gonna
lose
half
your
virtual
cores,
but
too
bad.
They
were
never
secure.
They
were
always
vulnerable
to
side
channel
attacks,
but
it's
all
true.
Actually,
that's
all
that.
That's
a
totally
reasonable
if
position
an
admirable
position.
A
This
is
what
OpenBSD
cares
about
and
and
more
power
to
them.
I
just
I
love
auch
gotta,
lock
in
there
just
give
you
kind
of
some
different
examples.
Auch
is
really
about.
Like
writing.
Programs
quickly.
I
write,
I
mean
I,
don't
know
about
you,
but
I.
You
know
I
write
awk
on
a
daily
basis,
I
write
three
or
four
Ockham's
day
like
I
just
and
these
are
one-liners
right.
These
are
super
quick
programs,
but
awk
is
really
beautiful.
In
that,
then
I
can
write
something
super
quickly.
It's
very
simple:
it's
pretty
expressive.
A
As
these
things
go,
you
can
do
a
lot
with
a
little
anak.
It's
very
approachable.
You
can
get
anyone
to
be
if
you've
read
the
awk
programming
language,
so
awk
named
because
of
aho
Weinberger
and
Kernighan.
The
three
people
that
invented
it,
the
ark
programming
language
I
think,
is
an
absolute
model
of
programming
language
documentation.
So
you
you
get
the
awk
program
language.
It's
like
130
pages
the
book.
It's
beautifully
written,
beautifully,
typeset
you'll,
read
it
in
like
two
hours
and
then
you're
done
like
that's
it.
You
know
all
about.
A
There's,
there's
nothing
more
to
know
about
Ock
like
you
actually
learned
it
all
the
end,
and
it's
there's
something
that
is
great
and
beautiful
by
that
it's
simple,
its
approachable
and
so
on.
I
think
you
might
be
able
to
teach
a
four-year-old
awk.
Maybe
you
know
that's
crazy.
You
can't
do
that.
I
died,
but
maybe
a
seven-year-old
I'm.
A
This
one
I
think
it's
a
useful
exercise
to
think
about
like
what
are
the
core
values
for
the
things
that
I
implement
in
the
things
that
are
important
to
me,
because
that's
probably
why
they're
important
to
you?
That's
probably
why
you
gravitated
them
at
some
level
in
what
I
see
in
Scala
is
certainly
expressiveness.
Writing
is
very
important.
I
think
you've
got
to
put
interoperability
way
way
way
up
there.
I
mean
the
whole
point
of
Scala
is
to
be
able
to
interact
with
the
Java
ecosystem
at
large.
A
That's
a
very
core
principle
to
me:
that's
a
core
value.
I
mean
I,
remember
actually
seeing
what
I
think
must
have
been
one
of
Martin's
very
first
talks
on
Scala
back
and
I,
think
2004
and
the
this
was
a
big
deal.
The
ability
to
reuse
java
classes
in
a
language
that
provided
integrity
and
robustness
and
expressiveness
and
composability
and
I'm
not
saying
that
Scala
doesn't
care
about
the
things
that
that
aren't
bolded
here,
but
just
if
it
has
to
choose
this
is
what
scholars
gonna
choose.
A
A
It
was
interesting
too,
that
eliminating
some
of
the
things
like
the
XML
in
URLs
I
did
not
know
that
XML
literals,
but
eliminating
some
of
things
that
we
no
longer
need
because
they're
not
gonna,
serve
these
values,
I'm,
not
sure
where
xml
literals
fall
on
the
values
and
the
moon,
Ranelagh,
okay,
so
the
there
the
challenge
for
that
we
have
in
system
software.
That
is
not
necessarily
a
challenge
that
you
might
have
in
software.
Your
writing,
but
in
the
in
in
the
software
in
the
system,
software
that
is
beneath
you
or
beneath
us.
A
That
is
that
that
is,
that
is
say.
It
comprises
the
the
foundation
upon
which
we
build.
The
values
are
dictated
by
those
who
will
use
the
software,
it's
dictated
by
the
expectations
like
the
the
an
operating
system.
That,
for
example,
does
not
hold
of
the
values
around
say:
robustness
or
safety
or
or
security.
A
That
operating
system
is
one
that
is
not
long
for
this
universe,
because
you're
not
gonna
want
to
use
it.
No
one
wants
to
have
an
operating
system
that
panics
on
them.
No
one
wants
have
an
operating
system
and
our
expectations
for
the
operon
system
and
for
system
software
are
very,
very,
very
high
and
rightfully
so
they
should
be
high
on
and
so
in
an
in
particular.
A
If
there
are
certain
values
that,
if
your
system
software
doesn't
have
it,
your
software
can't
have
it,
and
we
are
learning
this
the
hard
way,
because
these
values
go
even
deeper
into
security.
Right
I
mean
2018
has
been
my
Anna's
horrible
us,
because
of-
and
it
was
it
was
on.
You
know
January
2nd
of
2018
when
I'm
looking
at
this
hacker
news
story
that
someone
trying
to
kind
of
reverse
engineer
some
patches
that
are
being
floated
against
the
Linux
kernel
thinking.
A
There
may
be
a
really
serious
security
vulnerability
here
with
Intel
and
the
US,
and
that
was
the
beginning
of
the
end
for
my
2018,
because
2018
has
taught
us
that
that
security,
what
was
ultimately
subservient
to
performance
in
the
design
of
the
microprocessor,
and
we
were
all
complicit
in
that
by
the
way
like.
What's
not
it's
easy
to
kind
of
like
blame
Intel
for
that,
but
the
reality
was
we
were
all
complicit
in
that
we
that's
what
we
demanded
the
problem.
A
A
It's
very
painful
when
you're,
when
the
the
infrastructure,
the
layer
that
you
depend
on,
because
we
all
depend
on
layers
beneath
us
when
the
layer
that
kind
of
a
jack-in-the-box
hey,
surprise,
I,
don't
hold
the
values
you
thought
I
held.
It's
like
okay,
well,
I
guess:
I
will
cancel
what
I
was
gonna,
do
for
2018
and
spend
the
time
getting
the
system
back
to
where
I
thought
it
was
on
on
December
31st
2017,
which
is
what
we
have
effectively
done.
It's
been.
It's
been
very
frustrating
in
that
regard,
but
that's
a
four
system
software.
A
We
have
to
hold
these
values.
It
is
essential.
So
these
are
the
values
that
we
demand
of
system
software.
It's
got
to
be
compatible
right.
You
you're
not
gonna
an
upgrade
to
a
microprocessor
to
an
operating
system
to
a
database
when
that
breaks
your
software,
that's
not.
Okay,
it's
got
to
be
developed.
We
have
to
understand.
What's
going
on
why
things
are
failing,
you've
got
to
have
integrity
as
a
core
value.
You
can't
have
data
corruption.
You
need
performance,
I
really
wish
we
get
just
like.
Can
we
just
get
rid
of
performance?
A
Then
it'll
be
fine
and
we
don't
need
performance.
You
know
a
the
the
late
great
Roger,
Faulkner
I
worked
with
at
Sun
Microsystems
for
a
long
time,
which
said
that
performance
is
the
root
of
all
evil
and
and
he's
right
performance
is
the
root
of
all
evil.
If
we
are
are
happy
with
our
systems
not
performing
well,
things
get
a
lot
easier,
but
if
that's
not,
we
don't
want
to
do
that
right.
Performance
is
important.
Performance
drives
right
to
the
economics
of
what
we're
doing.
A
It's,
not
okay,
to
be
wasting
cycles
that
we
don't
need
to
waste.
We
actually
have
to
have
performance
as
a
constraint,
and
this
can
be
brutal
by
the
way,
especially
when
the
numbers
are
small.
It's
like
man.
This
thing
is
like
2%,
faster
than
you
guys,
just
like
that.
2%
is
brutal
to
get
out
of,
but
it's
important.
It
should
be
important.
It's
important
that
we
hold
that
value
for
our
system,
software,
it's
got
to
be
resilient.
It's
got
to
be
robust,
it's
got
to
be
safe.
It's
got
to
be
secure.
A
We
that
that's
paramount
that
it's
secure,
it's
be
stable.
It's
gonna
be
thorough
in
that
our
system,
software,
our
microprocessors,
our
operating
systems,
even
our
databases,
we
need
them
to
support
a
wide
range
of
things.
They.
These
are
not
purpose-built
things
we
can't
afford
for
them
to
be
purpose-built
things.
They
have
to
be
generic.
That
generic
ism
requires
a
thoroughness
that
is
actually
really
challenging.
We
got
to
be
transparent.
We
got
any
kind
of
the
day
of
proprietary
glop.
Well,
it
was
but
it
behind
us
and
then
that's
actually.
A
This
is
coming
back
actually
with
the
whole
cloud
thing
so
I'm
we
work
for
a
cloud
cloud
provider,
although
our
software's
all
open-source,
but
right
now
us
compute
is
being
reprioritized
by
the
by
the
cloud
providers.
So
transparency
may
be
fading
as
a
value.
I
hope
that
we'd
go
and
demand
that
it
back
again.
Okay,
so
I
just
wanna
remind
you
with
the
platform
that
the
core
values
of
C
are
so
we're
just
gonna
kinda.
Do
this
all
right!
So
that's
what
we
demand!
That's
C,
what
we
demand!
C!
A
It's
like
right
eye,
left
eye
right,
eye,
left,
eye
right,
eye,
left
eye,
all
right,
there's
only
one
value.
These
things
have
in
common
performance.
That's
it
everything
else,
and
this
is
actually-
and
you
know
what
Roger
accepted
Roger
passed
away
a
couple
years
ago.
Roger
you
are
haunting
us
from
the
grave
because
you
are
actually
all
right.
Ron
performance
actually
is
the
root
of
all
evil
here,
because
if
it
performance
ultimately
in
terms
of
the
values
we
demand
for
system
software,
we
do
demand
performance
over
all
else.
A
Just
look
at
history's
graveyard
of
systems
that
did
deliver
and
you
will
find
people
that
that
talk
about
you
know,
capability
based
systems
or
micro,
no
based
systems
or
other
other
systems
that
ultimately
fell
down
on
this
most
important
criteria
and
I
say
how
you
sort
fork
UNIX,
so
I
love
my
kernel,
so
I'm
not
I'm,
not
trying
to
pick
I
pick
at
wounds,
but
performance,
ultimately
is
is
the
most
important
thing.
So
that's
C
C
is
clearly
I
mean
we
kind
of
got
in
there
with
C,
but
it's
been
really
painful.
A
Well,
what
about
C++
all
right?
Well,
this
might
be
for
C++,
so
so
C++,
okay,
so
we're
definitely
gonna
get
rid
of
simplicity.
I
don't
have
a
way
of
saying
there
should
be
a
way
of
like
I
need
a
strikeout
to
be
like
I
hate
simplicity
like
that's,
like
I,
am
actually
anti
simplicity
cross
that
one
out
so
see.
West
boss
is
like
anti
simplicity
and
then
I
also
decided
that
again,
in
my
kind
of
as
long
as
I
am
issuing
fatwas
against
programming
languages,
I
I
decided
that
expressiveness
is
important.
A
Interoperability
is
actually
less
important
to
C++.
C++
has
actually
made
choices,
yes,
C++
is
a
better
C
and
yes,
I
think
it
can
still
compile
C,
although
that
becomes
less
and
less
important
over
time,
but
the
C++
struggles
with
interoperability
at
a
deeper
level,
where
you
have
components
that
are
written
in
non
C++,
trying
to
cooperate
with
components
that
are
written
in
C++.
It
is
possible,
but
very
very
painful
and
C++
does
not
make
it
easy
across
the
board.
I
mean
it
starts
with
name
mangling
and
gets
much
much
worse.
It's
really
really
painful.
A
To
make
software
you
have
to
design
your
C++
to
explicitly
interoperate
with
C,
which
is
very
frustrating,
because
you
have
these
software
out
there,
that
it's
actually
only
in
C++
is
gonna,
be
very
hard
to
actually
get
a
dinner
operate
with
C.
So
this
gives
us
the
this.
This
tremendous
divide,
this
tremendous
disconnect
between
the
values
that
that
the
system
software
programming
languages
have
had
in
a
way
performance
and
then
nothing
else
and
the
values
that
we
need
for
the
software.
We
have
have
all
these
other
values.
Now
we've
gotten
there.
A
It's
been
a
long,
painful,
arduous
path.
The
reality
is
our
system.
Software
does
work,
it
is
actually
it
does
have
all
these
other
values
it
does.
It
is
stable,
it
is
sick,
it
is
I
mean
it
is
relatively
stable.
It
is
relatively
secure
or
I
thought
it
was
secured
on
on
December
31st
2017
anyway,
it
is
relatively
safe,
relatively
robust
does
perform
well,
but
we've
gotten
there,
the
painful
way
it
has
taken
us
a
very
long
time.
We've
written
a
lot
of
bespoke
tooling.
Now,
we've
also
gotten
very
good
at
it.
A
I'm
good
at
writing.
My
C
does
not.
It
is
not
going
to
dereference
memory,
it
does
not
have.
That
is
not
a
failure
mode
that
I
have
in
the
C
that
I
write
because
I've
been
doing
this
for
a
long
time
and
I
know
how
to
malloc
and
free
and
I
know
how
to
create
dynamic
data
structures
and
do
that
do
so
completely
safely
and
I
can
very
quickly
that's
good.
It
was
very
painful
and
the
truth
is.
It
is
very
much
dependent
on
me,
the
programmer
and
my
reviewers
and
my
testing,
and
so
on.
A
There's
no
net
that
is
provided
by
the
language
at
all.
The
language
is
allowing
me
to
do
whatever
I
want
it's.
You
know
it's
like
a
Montessori
Preschool
as
long
as
we
all
worship
at
the
old
or
at
the
altar
of
performance.
So
the
you
know
the
question
is
like
it
can
we
do
better
because
we've
succeeded
despite
the
language
not
because
of
it
is
there
an
opportunity
to
better
and
I
was
actually
at
the
point
where
I
was
beginning
to
despair,
a
little
bit
where
I
had?
A
And
yes,
there
are
the
language
to
come
out.
You
may
be
familiar
with
giant
because
of
nodejs
I.
Had
this
like
great
belief
that
no
js'
was
going
to
be
what
would
save
us
all
yeah
and
if
you
would
be
like
no,
that's
just
JavaScript
I'm
like
I,
know,
I
know
it's
just
Josh,
but
I
wanted
so
much
better
I
wanted
so
much
better
for
JavaScript
it
wasn't
gonna
be
JavaScript.
It
was
gonna,
be
a
dynamic
language
in
which
we
could
write
robust
server-side
software,
and
it's
just
JavaScript.
It's
just
JavaScript
dude
I.
A
It
is
just
JavaScript
and
and
what
I
mean
by
that
is
the
values
that
JavaScript
has
aren't
bad
values,
but
they
are
not
the
values
that
we
have
for
system
software
that
defies
JavaScript,
as
is
really
around
velocity
and
especially
approachability.
We
want
as
many
people
as
possible
to
be
able
to
write
JavaScript,
and
that
is
not
that's
I,
think
that's
a
great
ambition
and
there's
nothing
wrong
with
that
value.
It
is
antithetical
to
system
software
because
that
does
become
in
tension
and
suck.
A
If
we
want
to
choose
an
abstraction
that
allows
ten
thousand
more
people
to
write
software,
but
that
soft
word
will
be
rife
with
edge
conditions
that
they
will
probably
never
encounter.
Should
we
do
it
if
your
first
value
is
robustus,
you
say
no,
of
course,
not.
If
your
first
value
is
approachability
and
and
growth,
then
yes,
of
course
you
should-
and
that
is
the
fundamental
tension
for
us.
So
I
want
us
to
do
better.
A
I
I
was
I
was
beginning
to
despair,
because
I
didn't
see
a
language
that
was
that
was
really
offering
fundamentally
different
values,
and
then
along
came
rust
and
now
along
came
rust.
Rust
has
been
around
for
a
long
time
started
actually
a
long
long
long
time
ago,
started
in
like
2006
or
just
a
little
bit
later,
but
rust
has
kind
of
has
grown
over
time
and
I
like
I.
A
Think
many
people
have
been
increasingly
rust
curious
over
the
years
right
and
my
my
rust
curiosity
has
has
grown
over
the
years,
because
rust
has
this
incredibly
interesting
system
of
ownership
where,
whereby
you
are
the
programmer,
are
going
to
work
with
the
compiler
to
figure
out
who
owns
what?
When
who
owns
what
piece
of
memory
the
compiler
is,
gonna
restrict
what
you
do
and
you're
not
going
to
burst
into
tears
when
it
does
it.
That's
like
that.
That's
the
bargain
that
you're
gonna
have
with
the
compiler.
A
As
a
result,
the
compiler
knows
when
things
need
to
be
allocated
and
when
things
need
to
be
de-allocated
when
they're
that
are
still
reference
to
this,
and
when
there
is
no
longer
reference
to
and
you're
gonna
work
with
it
and
as
a
result,
you
get
the
denied,
then
the
dynamicism
that
you
get
in
a
garbage
collected
language,
but
the
performance
of
explicit
memory
management-
and
this
is
amazing
and
importantly
unlike
see,
rust-
is
highly
composable.
So
the
big
problem
with
see
I
mean
this
is
always
the
problem
right.
It's
not
it's,
not
you!
It's!
A
The
other
person
like
I
know
how
to
write
memory
say:
I
know
how
to
actually
deal
with
memory
safely,
but
calling
you
to
a
library
that
jerk
no
I
don't
know
how
to
do
a
memory
safely
or,
but
it's
even
worse
than
that
right,
because
what
where
things
get
dropped
is
in
the
boundary
is
in
the
the
library
is
allocating
something
on
your
behalf
that
you
are
explicitly
or
implicitly
expected
to
free
or
deallocate.
You
lose
track
of
that.
You've
got
a
memory
leak
memory.
A
Corruption
are
worse,
it
is
very
hard,
even
if
you're
very
good
at
seeing
a
between
here
career,
it's
very
hard
to
compose
it.
So
what
we
end
up
doing
is
having
these
very
minimal
kind
of
structures
where
we
embed
these
things
in
larger
structures
and
we're
able
to
do
so
totally
safely,
but
ultimately,
sub-optimally
rust
actually
allows
us
to
have
higher
performing
primitives
and
so
as
a
result
and
I'll
come
back
to
the
rust
values.
A
But
in
in
my
experience-
and
this
is
my
experience-
I'm
not
trying
to
draw
a
large
conclusions-
this
is
a
bit
of
software.
That
is
what
I
was
alluding
to
us
on
in
the
panel
that
I'd
written
in
C
and
I'd
kind
of
written
in
you
know,
hand
optimized,
C
I,
went
to
rewrite
it
and
rust,
because
I
was
increasingly
rust,
curious
and
wanted
to
finally
say
that
rust,
curiosity
by
writing
some
real
rust
after
a
lot
of
back
and
forth
of
the
compiler
some
tears
that
I
wiped
away.
A
Do
it
like
let
the
wookie
win
is
my
advice
when
you're
dealing
with
rust
that
what
you
want
to
rust
wants
you
to
do
things
certain
ways
and
you're
much
better
off
doing
things.
The
way
rust
wants
you
to
do
it
so
I
did
it
in
a
way
that
was
obviously
suboptimal,
but
fine
I
can
get
it
to
compile
I
just
gotta
like
I,
don't
even
care
about
performance
anymore.
Just
let
me
get
this
thing
working
and
then
and
I
know
it's
gonna
perform
terribly
and
then
I
ran
it
and
it
outperformed
my
C.
A
It's
like
what.
How
did
that
happen?
How
and
I
took
it
apart
and
how
did
I
outperform
I
see?
Well,
this
particular
software
spends
all
of
its
time
rebalancing
a
binary
tree
and
in
rust
the
primitive
that
I
was
using
was
an
AVL
tree,
which
is
the
thing
we've
used
for
ever
and
I've
got
a
very
robust,
AVL
tree
implementation
that
I've
used
in
rust.
You
don't
have
to
AVL
tree.
Actually
the
betray
B
tree.
You
may
remember
from
databases
right,
but
the
rust
observation
is
actually
with
the
memory
hierarchy
being
what
it
is.
A
A
beech
tree
actually
makes
sense.
Just
in
software,
that's
not
talking
to
disk,
you
can
view
DRAM
as
the
disk
that
you're
talking
to
and
a
beech
tree
actually
makes
a
lot
more
sense.
Beech
trees,
a
pain
in
the
butt
to
implement,
but
with
rust
you
can
just
use
it.
You
don't
have
to
actually
know
any
of
the
implementation
details
of
it
and,
as
a
result,
it
outperformed
my
safe
in
large
part
because
the
data
structure,
but
also
because
there
are
optimizations
that
Russ
can
make
that
C
could
not
make.
A
And
then,
of
course
it
was
like
wow.
That's
a
GCC
issue.
How
about
clang
I'm
like
clang
is
not
gonna.
Fundamentally
change.
The
physics
of
my
C,
which
it
doesn't
like
clang,
makes
it
a
little
bit
better.
This
is
the
lower
is
better
here.
So
this
was
really
interesting
to
me
and
it
shows
the
the
kind
of
the
core
values
of
Russ.
A
So,
yes
performance,
it
has
to
be
performance,
it
kind
of
the
epicenter
of
the
universe,
but
you
get
that
composability,
the
expressiveness
that
you
in
the
scala
world
have
had
for
a
long
time.
We
now
get
this
to
have
this
at
a
much
lower
level.
We
get
safety,
we
get
security,
we
get
rigor,
we
get
robustness,
we
get
integrity
and,
very
importantly,
we
get
interoperability,
and
this
is
actually
the
difference
between
rust
and
other
languages
that
look
somewhat
similar
is
rusts.
Emphasis
on
interoperability,
rust
does
not
aspire
to
rewrite.
Everything
in
rust.
A
Rust
is
trying
to
cooperate
with
those
systems
that
already
exist,
so
it's
not
just
ownership.
The
I
know
that
you
know,
and
you
would
be
right
to
be
annoyed
when
a
bunch
of
systems
people
discover
algebraic
types
like
it's
a
brand
new
invention.
It's
like
hey,
I,
just
found
out
like
I'm,
getting
clean
water
out
of
the
tap
I,
don't
have
to
boy
you're,
just
like
yes,
you
knucklehead,
like
yes,
you,
clean
water.
It's
valuable,
like
your
babies,
are
no
longer
dying.
A
It's
amazing,
but
algebraic
types,
okay
and
I
knew
about
algebraic
types
in
the
abstract,
but
to
actually
be
able
to
see
how
algebraic
types
can
be
used
for
really
concise
error
handling.
You
can
make
much
more
robust
stuff
and
again
you
know
this
I'm
actually
I'm
literally
preaching
to
the
choir.
So
what
next
but
algebraic
types
are
amazing
and
they
are
amazing
for
reasons
beyond
what
I
appreciated
hygienic
macros,
true
story.
I
did
not
know
how
to
spell
hygienic
before
rust.
Hygienic
is
kind
of
a
pain
in
the
butt.
A
You
got
that
second
eye
in
there
like.
What's
that
doing
there,
but
the
the
eye
I
have
been
so
far
from
hygienic
macros
that
I
literally
didn't
know
how
to
spell
it
now.
Macros
are
a
key
for
us
and
C.
We
use
the
C
preprocessor.
All
the
time.
I
could
not
have
written
the
code
that
I've
written
in
my
career
without
C
preprocessor
macros,
are
very
important.
The
macros
and
rust
are
amazing.
The
foreign
function
interface
is
what
allows
it
to
interact
with
C
based
systems.
A
It's
outstanding
and
then
there's
this
unsafe
keyword,
which
is
this
kind
of
get-out-of-jail
kind
of
like
a
furlough
program.
You
get
to
go
away
a
conjugal
visit
with
your
memory.
You
don't
actually
sometimes
these
metaphors
occur
to
me
on
the
fly
and
I
realize
like
as
it's
going
out
of
my
mouth.
The
other
part
of
my
brain
is
like
no,
let's
kind
of
let's
pull
that
one
back.
A
Please
pull
them
out
here
that
one's
gone
all
right,
fine,
never
mind
it's
been,
it's
been
tweeted
forget
it,
but
the
the
unsafe
keyword
allows
you
to
relax
certain
restrictions
that
Russ
puts
in
place.
That
allows
you
to
then
in
very
isolated
parts,
actually
leverage
what
you
know
of
memory
and
to
build
even
higher,
performing
things
better
things,
but
you've
really
can
find
that
unsafety,
so
I
think
actually
unsafe
keyword
is
terrific.
Terrific
community,
thriving
ecosystem
I
mean
there's
a
lot
to
love
about
it.
So
that's
the
promise
of
rust
there.
A
Where
did
all
this
cognitive
load
come
from,
like
I
I'm,
much
more
used
to
being
able
to
just
kind
of
like
push
it
into
production,
but
I
know,
there's
a
lot
more
cognitive
load,
a
lot
more
things
you
need
to
think
about,
and
Russ
complains
about
things
that
seem
very,
very,
very
pedantic
and
it
can
take
a
while
to
realize
that
oh
rest
is
right.
Actually,
rust
is
right,
there's
an
actual
real
issue
here.
A
I
mean
there
are
a
couple
instances
where
people
are
convinced
they're
having
a
fruitless
argument
with
a
compiler,
because
the
compiler
is
wrong
and
they
realize
the
compiler
is
actually
right.
So
it's
a
really
interesting
that,
regarding
it
restricts
what
we
can
do.
It
can
be
very,
very
frustrating.
A
This
is
a
quote
from
from
the
programming
rossbach,
which
I
love
that
they
you
have
a
period
of
intense
arguing
with
a
compiler
at
the
end
of
which
the
code
looks
rather
nice,
as
if
it'd
been
a
breeze
to
write
and
runs
beautifully,
but
there's
no
way
that
code
is
like
you
don't
get
the
screams
of
pain
that
the
developer
had
in
getting
that.
That
kind
of
beautiful
code
that
beautiful
artifact,
so
the
the
the
peril
of
rust,
is
that
it's
got
less
of
an
advantage.
I
think
when
we
are
reimplemented
extant
systems.
A
So
when
the
software
already
works,
it's
less
clear
to
me,
especially
you've
got
multiple
own
data
structures
like
an
OS
kernel.
I
think
that's
gonna
be
brutal
for
rust,
but
there
are
a
lot
of
opportunities
for
us
and
start
to
kind
of
speed
through
here
at
the
end.
But
there
are
a
lot
of
opportunities
for
rust
because
of
its
interoperability
as
a
core
value.
A
God
bless
that
interoperability
and
performance
is
a
core
value
because
it
allows
us
to
do
with
rust
what
we
did
with
C,
which
is
take
an
iterative
approach,
start
rewriting
things
in
rust.
We
don't
have
to
rewrite
the
entire
world
in
rust.
We
can
start
rewriting
parts
of
Ross
and
I
think
this
is
something
that
the
scholar
community
really
gets
from
its
interoperability
with
Java,
but
I
think
we're
really
learning
it
in
system
software
and
so
I
think
it's
it's
a
new
dawn
of
development.
A
In
that
regard,
the
system
is
obviously
much
they're
much
broader
than
just
the
operating
system.
There
are
a
lot
of
use
global
components
that
are
a
natural
fit
for
rust.
If
I
were
writing
system
D
today,
I
mean
I,
didn't
write
system
B,
but
if
one
were
right
actually
mentioned
system
B,
if
one
were
writing
a
user
level
facility
to
manage
software
as
a
service,
I
would
write
that
in
rust,
absolutely
and
in
particular,
just
to
close
with
the
other
body
of
software
that
I
really
want
to
see.
A
Rewritten
is
the
software
that
you
can't
see
and
I
can't
see,
and
none
of
us
can
see
the
software
that
works
beneath
us
is
firmware.
I've
been
fond
of
saying,
but
I
believe
it
fervently
that
we
are
engaged
in
a
war
with
firmware.
It
is
humanity
versus
firmware,
and
everyone
needs
to
pick
a
side.
So
I
hope
that
you
pick
the
side
of
humanity
and
I
think
there's
a
lot
of
opportunity
to
rewrite
that
Louis.
A
All
the
software
which
I
honestly
is
still
in
assembly
or
C
I
think
there's
a
lot
of
opportunity
to
rewrite
that
in
Rus,
so
I
think
the
you
know,
one
of
the
things
that
the
Rus
community
says
over
and
over
again
is
we
can
have
nice
things
and
I
think
that
that
is
very
much
borne
out
by
Rus
values.
The
values
themselves
are
a
great
fit
for
system
software.
It
doesn't
mean
it's
a
fit
for
everything
and
you
shouldn't.
A
B
A
A
C
So
what
do
you
think
of
the
idea
of
what
systems
for
every
but
there's
other
spaces,
where
it's
very
important
to
just
in
yes,
we're
worse,
they
did
what
was
intended
right.
You
see
a
role
for
us
not
just
as
a
system
software
but,
for
example,
like
cooperating
what
they
did
game
or
as
some
kind
of
date,
libraries,
and
where
you
can
combine
the
two
system.
A
And
I'd
say
any
place
where
these
values
are
important.
Russ
is
gonna,
have
a
place
and
in
particular
where
these
are
the
choices
you
want
to
make,
and
in
particular
particular
where
performance
is
the
is
your
top
choice.
If,
if
performance
is
your
overarching
value,
I
think
rust
is
absolutely
gonna
have
a
place
all
right,
I
think
I'm
out
of
time.
Thank
you
very
much.
Everybody.