►
Description
All Rustaceans know that Rust’s borrow checker is merciless to newcomers. This talk covers the pain points encountered by me, back when I was a newcomer to Rust (and systems, in general). We’ll see a variety of situations which are totally normal in a number of high-level languages but not in Rust, how the same code differed in Rust, how the errors made sense after a while, and how that changed me to think about approaching problems from there on. If you’re looking for motivation to get into Rust, or if it made you angry or scared you away at some point, then this talk is for you!
Find slides here: https://reveal.waffles.space/presentations/rustcon-asia/#/
Follow us on Twitter: https://twitter.com/RustConAsia
A
Hello:
everyone,
okay,
that's
a
lot
of
people
and
I
feel
pretty
nervous,
but
anyway
welcome
thanks
for
coming
by
today,
I'm
gonna
tell
you
a
story,
a
story
of
how
Russ
taught
me
to
think
about
systems.
Before
we
start
I'd
like
to
introduce
myself,
I
am
Ravi.
I
am
a
full-stack
developer,
who
loves,
frost,
swift,
typescript
Cuban.
It
is
among
other
things,
and
you
can
find
me
in
github
and
Twitter
in
that
handle
and
if
you
have
trouble
pronouncing
my
name,
you
could
just
call
me
waffles.
A
A
The
first
thing
is
most
of
the
people-
love
frost,
that's
based
on
this
hacker
flow
survey
over
the
past
four
years,
and
and
if
you
visit,
Twitter
or
hack
news
or
credit
or
whatever,
you
can
find
people
praising
about
frost
every
now
and
then
and
that's
one
of
the
proof.
On
the
other
hand,
if
you
see
the
newcomers
almost
all
the
time,
they
are
convincing
the
compiler
that
their
code
is
fine,
and
this
is
perfectly
normal
for
anyone
getting
into
rust.
A
I'm,
pretty
sure
everyone
who
tries
to
compile
something
into
us
may
have
encountered
this
at
some
point
in
their
a
station
lifetime
the
goal.
So
the
goal
is
not
to
eliminate
this
problem
and
write
error-free
code.
Instead,
the
goal
is
to
understand
what
those
errors
mean
and
how
we
can
get
around
those
errors.
Just
like
how
we
deal
with
every
I
know
that
the
bar
ticker
could
be
rather
daunting
for
and
frustrating
for
newcomers,
particularly
for
folks
from
high-level
languages,
and
that
were
I
present
you
my
story,
and
it's
not
it's
not
just
a
story.
A
A
Okay.
So
let's
start
with
variable
bindings
in
so.
The
first
example
is
in
Python:
it's
snippet.
It's
somewhat
simpler
to
read:
I
guess
it's
a
list
of
integers
and
those
are
bound
to
the
variable
a
and
then
we
are
binding
a
to
B.
And
finally,
we
are
printing
the
contents
of
a
and
B.
If
we
were
to
write
the
same
thing
in
Swift,
we
would
do
something
like
that
and
both
things
work.
If
you
run
it,
you
won't
encounter
any
errors
and
that's
totally
normal.
A
But
if
you
do
the
same
thing
in
rust,
this
is
perfectly
normal
right,
you're,
just
declaring
a
variable
and
you're
putting
the
contents.
But
if
you
try
to
compile
compile
it,
the
body
circuit
won't
allow
you
to
and
that
bring
that
kind
of
stopped
me
when
I
tried
Ross
for
the
first
time
so
I
began
to
read
the
book
when
I.
Try,
trust
Python
was
my
only
background.
So
this
is
how
I
thought
of
memory.
A
So
memory
is
a
contiguous
set
of
blocks
and
the
program
requests.
The
operating
system
and
the
operating
system
gives
gives
blocks
to
the
program
and
the
program
freezes
them
in
the
end.
Now
that's
partially
true,
but
not
exactly
when
about
four
years
back
when
the
Ross
book
started
thanks
to
Steve
cloud,
Nick
and
others
in
the
documentation
team,
it
began
with
the
differentiation
of
the
stack
with
a
heap
and
there's
this
whole
new
process
of
thinking.
A
A
The
result
has
got
to
do
with
the
outcome
of
this
in
Python
you
get
true
and
in
Swift
the
Equality
itself
is
false,
and
that's
because
and
now
I'm
curious.
Why?
Because
I
just
tried
to
add
in
Python
a
loss.
If
then,
now,
I,
don't
know
why
that
happened.
So
I
investigated
and
I
figure
out
that
everything
is
an
object
in
Python
everything.
A
That
means
the
a
and
B
the
both
variables
are
pointing
to
the
same
list
and
whereas
in
Swift
it's
not
the
same
object,
it
uses
something
called
copy-on-write.
So
when
you
change
B
B
gets
a
new
copy
of
that
list.
So
the
change
is
reflected
in
B,
not
in
a
if
you
have
used
for
us
before,
then
you
would
be
familiar
with
cow
clone
on
right
pointer.
A
So
that's
how
Swift
works
and
if
you
think
about
it
these
languages
to
take
care
of
these
decisions
implicitly
because
they
don't
trust
the
programmer,
because
programmers
are
known
to
do
bad
things
like
not
freeing
what
they
are
locate.
So
the
languages
take
care
of
the
decisions
and
make
make
the
environment
make
the
program
safe.
A
Now
I
go
on
figuring
out
why
all
the
high
level
languages
do
that
and
almost
all
the
high
level
languages,
safe
languages,
guarantee
memory
safety
through
a
bite
and
they
I'm
sorry
I
missed
it.
So
they
are
built
on
the
premise
that
variables
can
be
used
any
number
of
times,
and
this
means
you
only
have
one
or
the
other
way.
One
way
you
go
for
references
like
Python
or
the
other
way
you
copy
everything
like
Swift
but
reference.
This
is
a
bad
idea.
A
We
know
that
through
C
C++,
so
we
are
left
with
copying,
but
doing
that
all
the
time
is
also
bad
is
equally
bad.
So
now
we
have
Ferris
coming
in
and
saying
okay,
but
we
can
copy
some
values,
for
example,
integers
pointers
and
characters.
Basically,
everything
that
could
be
in
the
stack
can
be
copied
safely
and
what
about
the
other
values?
A
In
order
to
solve
this
problem,
rust,
take
some
ideas
from
something
called
affine
types.
What
this
does
is
that
a
resource
can
what
this
says
is
that
a
resource
can
only
be
used
once,
and
this
may
sound
similar,
similar
to
what
the
ownership
model
does
when
we
use
something
in
broth,
we
can
only
use
once
that
is
own
types
can
only
be
used
once
and
that
kind
of
struck
me
it
when
I
thought
about
it,
it
didn't
it
didn't,
really
mean
much,
but
eventually
I
kind
of
got
the
point.
A
Moving
on
to
the
next
situation,
why
this
and
pointers
are
hot
in
C,
at
least
when
I
tried
C
yeah.
That
was
the
only
one
that
scared
me
away
so
and
I
never
tried
C
after
that,
I
couldn't
recall
all
my
struggles
with
the
Ross
compiler
from
three
years
bags.
Let's
go
for
a
thought:
experiment!
I
am
I
let's
imagine
me.
A
So
I
start
with
the
search
for
reading
lines
from
a
CDN
and
the
communities
kind
of
trade.
You
always
have
a
highly
voted
answer
in
Stack
Overflow
and
then
I'd
go
for
splitting
strings
and
I
kind
of
put
together
my
prototype
for
reading
strings
from
the
standard
input
and
output
again
and
I,
try
to
compile
it
and
it
doesn't
compile,
because
I
now
see
that
the
collection
type
such
as
vectors
don't
implement
the
display
trade.
A
Okay,
so
I
try
to
implement
the
display,
display
trade
and
I
regret
doing
that
and
eventually
I
ditch
might
display
trade
and
go
for
sir
Jason
now
comes
the
first
Porsche
Carerra
temporary
value
drop.
Well
borrow.
Okay
and
Russ
tells
me
that
and
points
at
the
exact
line
where
it
happens
and
asked
me
to
create
a
lead
binding
for
that
line.
Okay,
I
do
that
and
now
it
compiles
and
I
couldn't
understand
a
thing
so
I
researched.
A
What
had
just
happened
and
I
realized
that
the
s3
in
lock
method
returns
a
handle,
the
handle
implements
puff,
read
and
the
buff
read
gives
you
the
lines
it
trader,
which
returns,
which
yields
a
result
of
string
for
every
time.
You
call
the
function.
It
sorry.
Every
time
you
trade
and
the
split
method
that
I
used
creates
references
on
that
string,
the
string
that
gets
dropped
and
the
references
get
collected
into
the
vector,
that's
a
classic
use
of
Freiburg
and
Russ-
has
stopped
us
from
doing
that.
A
Moving
on
now,
I'm
kind
of
familiar
with
some
of
the
errors
in
the
compiler
and
I
am
having
this
dinner
not
to
navigate
this
I'm
going
for
this
iterator
implementation,
so
that
I
can
do
things
in
a
nice
way.
So
I
just
called
that
struct
with
using
it
for
it
for
loop
and
I'll,
get
the
lines,
the
JSON
lines
and
that's
easier
to
work
with
so
I
start
from
the
beginning.
I
know
returns,
SVN,
lock,
so
I
just
put
it
there
and
it
says
it's
missing.
A
Lifetime
specifier
I
have
no
idea
what
it
does
so
I
searched
around
and
eventually
I
found
find
that
the
dark
documentation
say
something
like
a
now
I,
don't
know
what
that
a
is
I'll
just
put
it
there
and
it
says,
use
of
undeclared
lifetime,
and
it
tells
me
what
change
I
should
make
like
changing
the
struct
to
use
that
lifetime
and
I
had
that.
Okay
and
it
compiles
again
now
I
want
to
figure
out
why
it
works
and
that's
part
of
the
programming
workflow
right.
A
So
you
could,
it
doesn't
compile
you
shout
at
the
computer
if
it
does
compile
you
shadowed,
computer
and
I
go
on
a
quest
to
find
what
just
happened.
I
see
that
the
study
in
struct
looks
something
like
that.
Okay
and
the
loc
method
currently
looks
like
that.
But
previously
it
looks
something
like
that:
I
mean
about
three
years
back
so
now
the
STD
in
lock.
This
fact
has
its
label.
But
then
you
see
that
there's
a
mutex,
odd
and
the
label
is
now
in
the
mutex
guard.
A
So
you
follow
along
and
you
find
music
squad
now,
I
see
a
reference
holding
that
label
and
now
I
finally
see
it.
Okay,
so
references
have
a
label.
That's
great!
Oh
I,
just
missed
this
slide
now
I
realize
something's
a
study.
In
luck,
the
struck
which
we
just
saw
borrows
STD
in
and
the
borrow
constrains
the
owner
from
moving
somewhere
else,
and
that
made
sense.
A
I'm
unsatisfied
I
am
looking
for
a
way
to
improve
things,
and
these
are
all
the
improvements
that
I
come
up
with.
The
attire
should
handle
everything
like
when
I
call
for
line
in
date
for
every
iteration.
The
line
should
give
me
the
Jason.
The
valid
JSON
output
that
I
should
get
I
shouldn't
have
to
deal
with
anything
anything
on
my
own.
A
They
trailer
should
work
on
all
readers.
That
means
a
file
should
it
should
work.
It
should
work
on
TCP
streams
and
write
this
same
thing
now,
I'm
kind
of
at
this
point,
I'm
kind
of
familiar
with
the
lifetime
errors
from
Rossi
and
I
kind
of
like
it,
so
I
go
I
purposefully,
go
for
something
like
this:
a
nightmare
spot
and.
A
A
That's
what
we're
that's
where
our
problem
is.
Instead
of
passing
a
mutable
reference
that
is
giving
right
axis,
I
am
giving
readable
axis.
It's
just
a
reference
and
must
prevents
that
and
it's
pretty
cool,
because
those
are
two
different
types.
According
to
rust,
a
readable
reference
is
completely
different
from
the
writable
reference.
A
Okay,
so
I
change
that
and
it
works
now,
I'm
doing
something
like
that:
I'm
dropping
the
bytes
vector
after
initializing,
the
trader,
so
I'm
creating
another
use,
have
free
out
of
thin
air
and
Russ
prevents
that
again,
but
the
bar
to
go
saves
the
day
and
what
about
now?
I
am
mutating
the
vector
after
creating
the
trader.
So
this
means
the
vector
could
have
reached
its
capacity
at
this
point
and
may
have
relocated
elsewhere
in
the
heap,
and
the
point
was
now
somewhere
else
and
rust.
Doesn't
allow
allowed
that.
Allow
me
to
do
that
either.
A
We
have
a
conference
II
example
in
Python
and
I
have
a
list
of
values,
a
list
of
integers
and
it's
stored
in
the
variable
values,
and
the
do
work
function
is
capturing
context
from
the
global
scope
and
it's
incrementing
the
values
50
times.
For
no
reason,
I
know
it's
a
dumb
function,
but
the
point
is
just
stay
with
me
and
we'll
see:
I'm
launching
a
thread
targeting
not
just
a
thread.
Twenty
threats
targeting
do
work.
Keen
breeders
may
notice
a
problem
with
this
step.
A
If
we
were
to
repeat
that
in
Swift
we
will
be
using
array
and
we
have
the
same,
do
work
function,
and
so,
if
we,
the
the
normal
approach,
is
to
go
for
the
Grand
Central
Dispatch
in
sort
of
threads.
So
using
that
and
we
have
a
semaphore,
we
have
dispatch
group
which
acts
like
a
semaphore
for
us
to
wait
for
things
and
eventually
we
will
print
the
value
open,
the
song.
It
does
the
same
thing
and
it
has
similar
results.
A
A
Okay,
if,
if
you
know
Russ,
then
you
would
say
that
this
program
is
horribly
wrong
and
I
would
agree
with
you,
because
it
doesn't
compile,
and
it
says
the
closure
may
outlive
the
current
function,
which
means
the
vector
that
we
had
may
move
may
get
lost
because
threads,
we
don't
know
the
lifetime
of
the
threads
different
threads
could
live
for
different
times
and
which
means
if
the
vector
R,
which
is
part
of
this
function,
gets
dropped
in
the
end.
And
what
else
is
there
in
the
thread?
A
Okay,
so
Brust
asks
you
to
think
about
your
decisions
like
it
asks
you.
What
exactly
do
you
want?
Do
we
want
to
clone
or
ritto?
No,
we
don't
want
that.
We
want
writable
access
from
all
the
threads,
so
rust
brings
you
to
two
elegant
solutions
to
this.
The
send
and
sink
markers
sense
says
that
passing
by
value
is
safe
and
sinks
is
that
passing
by
reference
is
safe
and
now
there's
an
endless
discovery
going
on
and
I
have
come
up
with
some
realizations.
A
A
We
have
vector
of
some
type
and
it
it
doesn't.
Women
sense
ink
and
Static,
but
we
don't
want
to
clone
or
move
anywhere.
So
that's
not
a
choice
either.
Now
we
are
going
for
a
reference
counted
pointer
which
is
static,
but
then
it's
not
send.
It
only
allows
reference
methods
which
use
breathable
reference
instead
of
writable
reference
we
have
rough
saw
which,
which
is
sent,
and
it
does
allow
mutable
reference,
but
then
it's
not
sink.
A
A
This
brings
us
to
the
question
of
whether
R
Us
prevents
race
conditions.
No,
it
doesn't.
It
only
forces
you
to
think
about
it,
because
the
code
is
expressive
and
that's
one
other
thing
I
like
or
trust.
If
you
read
the
code,
you'll
know
what
exactly
you're
dealing
with
life,
unlike
other
languages,
rust,
doesn't
expect
you
to
know
things.
It
teaches
you
things
along
the
way
now
coming
back
to
how
the
last
four
years
were
for
me,
I
had
moments
like.
Why
doesn't
this
work,
or
what
do
you
even
want
from
me?