►
From YouTube: Concurrency in Rust
Description
Alex Crichton, of Mozilla Research, presents on the low level workings of concurrency in the Rust programming language.
Slides: http://people.mozilla.org/~acrichton/rust-talk-2014-08-27/#/
Presented at Pittsburgh Code & Supply, August 28th 2014. Find more at http://codeandsupply.co
A
Hello,
my
name
is
ops
right,
I
were
talking
about
today
and
concurrency
in
Brussels
kind
of
what
that
means
so
could
be
kind
of
different
from
the
elixir
of
OTP
talk.
This
is
more
kind
of
like
a
lower
down
on
the
stack
and
talking
about
kind
of
like
similarities
with
C++
and
C
multi-threading
and
our
concurrency.
It
things
like
that.
A
So
I
want
to
start
out
by
kind
of
just
talking
briefly
about
what
is
concurrency
like
what
does
it
mean
silent,
concurrency,
I,
just
googled
literally,
what
is
compare
to
see-
and
this
is
what
came
back
at
them
and
basically
what
it
is
is
kind
of
lots
of
things
flying
around
running
around
at
the
same
time.
But
the
the
key
aspect
here
is
the
same
time.
Things
are
running
in
parallel
via
two
threads
of
execution
that
are
actually
doing
something
simultaneously.
A
So
today
it's
with
multi-core
words
and
things
like
that,
and
this
is
where
there's
a
distinction
between
parallelism
and
concurrency
and,
in
my
mind,
I
think
this
is
always
getting
mixed
up.
But
I
think
this
is
the
one
but
actually
I
have
my
simultaneously
good.
Well,
we'll
talk
mainly
about
them
today,
so
the
next
thing
is
why.
A
Machines
like
why
can't
I
just
run
with
a
web
link
or
call
today,
and
the
reason
is
this:
whole
lack
of
Moore's
Law
Moore's
law
was
there
for
a
while,
but
now
it's
not
it's
not
there
anymore,
and
now
everyone
has
64
port
machines
about
laptops,
and
things
like
that,
so
this
is.
This
is
a
very
real
problem
today.
This
is
a
very
real
thing
which
everyone
new
to
programming
actually
really
needs
to
be
introduced
to,
because.
A
Kind
of
writing
on
one
thread:
they
don't
have
to
worry
about
a
whole
lot
of
things,
but
then
very
quickly.
You
run
these
problems
over
once
you
start
having
a
concurrent
application.
You
have
tons
of
problems,
tons
of
things
arise
and
so
I.
It
is
my
personal
belief
that
it
stays
dating
concurrency,
not
like
knowledge
about.
B
A
Familiarity
with
concurrency
is
a
must-have
and
ever
I'm
going
to
talk
about
some
of
these
sample
errors.
So
a
general
concurrency
is
seen
as
a
very
hard
topic,
there's
very
difficult
things
inside
of
it,
and
this
is
a
really
really
simple
example,
where
it's
kind
of
a
small
amount
of
concurrence
and
the
question
is
just
what
does
this
print
and
the.
A
A
B
A
Could
even
intermix
everything
made
for
many
for
two
new
lines
at
the
end,
depending
on
the
kind
of
buffered
was
going
on
with
the
standard
out
at
the
time.
So
it
turns
out
that
even
just
answering
this
simple
question
is
pretty
hard.
I
concur
asked
in
a
concurrent
setting
and
then
just
count
just
a
bit
of
an
idea
that
gets
used
to
concurrent
programming.
What
can
be
difficult
about
it?
The.
A
A
It
to
happen
this
way.
It
actually
happened.
This
way,
which
is
totally
separate.
You
totally
didn't
expect
that,
and
it
probably
caused
a
crash
right
there
in
Volkers
like
that,
so
race
conditions
are,
you
always
must
consider
them
we're
dealing
with
concurrent
programming,
and
you
kind
of
have
to
you
always
have
to
work
around.
A
That
always
expect
it,
and
concurrency
is
where
you
have
to
plan
for
every
single
situation
possible,
and
the
problem
is
that
state
space
of
every
single
situation
possible
it
explodes
really
really
rapidly,
so
it's
actually
very,
very
difficult
to
do
with
race
conditions
kind
of
all
a
general
level.
So
if
we
take
that
idea,
race
conditions,
that's
very
broad
topic
where
you
can
have
races
and
essentially
everything
what
kind
of
like
to
shrink
it
down
to
something
just
called
data
races.
A
So
data
races
is
something
unique
to
a
kind
of
very
low
level
dealing
with
the
hardware
dealing
with
compilers
and
things
like
that.
I,
don't
you
definitely
don't
see
data
races
when
you're,
probably
the
little
wide
elixir
ITP
of
having
sockets
and
databases,
and
things
like
that?
This
is
when
you're
dealing
with
just
the
raw
Hardware
of
the
machine
itself,
and
so
this
is
the
definition
of
data
races
that
I've
come
to
know.
It's
basically,
two
concurrent
accesses
to
the
same
memory
location,
which
is
crucial,
though
those
two
those
two
pieces
are
crucial
to
this.
A
A
nice
tooth
is
wantonness
and
synchronized,
and
one's
looks
to
write
on
I'll
talk
a
little
bit
more
about
those
in
a
bit,
but
data
races
in
general
are
where
C
compilers.
If
you
have
a
database,
it's
on
the
fly
behavior
and
what
that
means
is
it
could
turn
the
computer
off
it
could
make
pigs
come
out
the
printer.
It
can
do
anything
you
could
check
your
printer.
I
can
fax
random
things.
Places
like
anything,
could
happen
with
the
data
racing
on
the
front
behavior.
B
A
Oh-
and
this
is
probably
behind
race
conditions,
probably
like
on
how
many
terraces,
but
the
problem
here
is
deadline
which
what
means
is,
if
I
call
this
function
with
accounts,
1,
&,
2
and
someone
else
calls
it
with
accounts,
2,
&
1.
We
get
a
very
quick
deadlock
where
one
person
grabs
the
ones
lock
and
one
person
grabs
we
choose
lock
on
the
note.
Neither
one
can
progress,
so
deadlock
in
general
is
where
we
have
a
lot
of
Fred's
actors
whatever
in
the
system.
A
B
A
Is
another
big
problem
that
comes
up
with
a
lot
of
concurrent
program
so
to
kind
of
summarize,
a
lot
of
these
blogs
can
lead
to
things
like
psyche.
Faults
use
after
freeze,
double
freeze,
deadlock,
starvation,
spitting
some
hi
to
talk
about
all
these
in
detail,
but
one
of
the
big
things
is
every
single
one
of
these
is
exploitable,
which
means,
if
you
have
like
let's
say,
you're,
writing
up
an
SSL
and
all
of
a
sudden
you're
like
oh
I,
have
four
cores.
Let
me
actually
make
you
decrypt
all
incoming
connections
on
four
core
or
something.
A
So
it's
actually
really
hard
to
do
that,
because
how
are
you
certain?
A
hundred
percent
certain
that
you
do
not
have
any
databases?
You
don't
have
any
race
conditions.
You'll
have
any
of
this,
because
if
you
do
you're
also
in
a
very
exploit
piece
of
software-
and
you
probably
don't
want
to
be
therapists,
though
so
now
I'm
going
to
talk
about.
Where
does
rust
come
into
all
this?
So
this
is
rusts
pinch
on
on
the
website
pyramid
which
is
Rush's
assistant
programming,
language
that
runs
blazingly
fast,
prevents
almost
all
crashes
and
eliminates
terraces.
A
So
there's
two
key
aspects
that
I'm
a
kind
of
focusing
on
in
this
talk,
and
that
is
preventing
all
crashes
and
many
bitter
reasons.
So
I
showed
you
earlier
that
those
are
two
kind
of
the
two
veins
of
concurrent
programming.
That's
where
a
lot
of
bugs
come
from
cyclones
crashes,
all
these
fun
things
so
rust
completely
eliminates
them,
making
it
possible
to
write
in
general,
safe
code,
and
so
I'll
talk
a
little
bit
about
for
a.
A
A
Can
kind
of
see
some
concurrency
going
on
with
the
spots
actually
spawn
of
a
parallel
friend
excuse,
so
one
thing
which
is
really
really
big,
Duras,
there's
actually
kind
of
the
core
foundation
of
rust
that,
essentially,
everything
else
is
built
on
his
ownership
and
ownership
is
the
concept
that
every
single
piece
of
data
is
owned
by
one
person
at
all
times.
That's
it
it's
a
very
simple
concept
which,
from
which
I'm
actually
going
to
talk
about
how
this
leads
to
safety
in
the
rest
of
the
language.
A
Some
stack
and
pushes
anything
on
it
then
Jarvis
image,
so
drop
is
kind
of
the
rust
way
of
saying
go
deallocate
this
event,
don't
worry
about
it
anymore,
and
so
then
afterwards
I
attempt
to
push
on
that.
So
that's
actually
I
use
that
to
free
if
this
compiles
critically,
because
this
factor
was
dropped
at
this
point
and
then
trying
to
push
out
of
effort,
so
I
can
see
your
C++.
This
would
actually
compile
just
fine,
but
then
you
would
have
a
cycle
afterwards.
You
hopefully
have
Scifo
and
everything
go
die,
so
it
rust.
A
We
have
this
concept
of
the
stack.
The
local
variable
V
owns
the
vector,
and
then
you
can
kind
of
do
some
stuff
to
it,
and
then
you
release
ownership
with
a
vector
by
passing
it
to
this
drop
function,
and
if
you
don't
want
use
it
so
I'll
come
back
to
ownership
a
lot
throughout
the
rest
of
this.
But
you
kind
of
think
just
one
person
knows
this
and
in
some
way
people
can
borrow
access
to
it,
but
they
don't
have
been
interactive
partnership
unless
you
kind
of
initiative
along.
A
So
the
other
really
big
part
about
rust
is
it's
a
totally
safe,
as
the
pitch
was
saying.
Rust
is
a
what
language
built
for
safety
in
these
low-level
concurrent
aspects,
a
little
goodie
box,
so
Russ
dealt
with
this
by
not
actually
putting
all
this
in
the
language.
All
of
this,
the
the
ownership,
the
bar
wink,
has
core
fundamental
language
features.
A
Allow
us
to
write
safe
libraries
and
safe
abstractions,
which
give
you
the
tools
you
need
to
write
totally
safe
in
the
current
code,
and
so
the
big
takeaway
from
this
is
the
rust
language
itself
is
actually
really
not
all
that
complicated.
But
the
rust
libraries
are
where
a
really
big
amount
of
logic
happens.
That's
that's
something
which
we
found
to
be
really
powerful
for
time
to
kind
of
not.
B
A
Us
so
much
about
the
language
giving
you
these
fundamental
like
concurrent,
responding
or
channels
or
anything
like
that,
but
the
libraries
actually
doing
that
so
I'm
going
to
talk
a
little
bit
about
these
actual
all
these
concurrency
primitives
that
you
have
to
play
around
with
the
rest,
because
we
have
a
good
array
of
a
good
rated
primitives,
which
you
can't
help
you
have
in
various
situations
which
you'll
see
a
lot
of
parallels
to
this
in
C++
and
a
little
cello
go
and
lots
of
other
languages
with
concurrency
and
things
in
them.
So.
A
A
What
your
computer
is
giving
that
day,
it's
nice
thing
that
we
give
you
a
something
called
channels
and
channels
on
trusts,
manifestation
of
message
passing
if
you're
familiar
with
that
and
the
idea
the
channel
is
that
you
call
this
function
called
share,
which
gives
you
two
endpoints
so
channel.
One
of
the
TX
is
the
sending
end
and
the
RX
is
the
receiving
end
and
then
what
we
do
is
you
can
also
clone
the
send
against.
They
can
have
multiple,
multiple
people
sending
to
a
channel.
A
So
in
this
case,
we
spawned
two
subtasks
that
are
setting
on
the
same
channel.
Clone
was
kind
of
clone
a
reference,
the
channel
not
actually
creating
your
channel
and
the
first
one
since
fire.
The
second
one
sense
for
the
very
end
we
print
out
what
messages
we've
just
received.
So
this
is
another
case
where
we
might
see.
B
A
A
So
channels
are
totally
generic,
so
you
can
send
any
kind
of
message
over
a
channel.
You
can
send
anything
you
want,
and
the
idea
here
is
that
you
take
an
object
and
you
give
ownership
to
the
channel
and
then
later
on.
Someone
can
receive
ownership
of
that
object
back
by
call
and
receive
on
it.
So
this
concept
of
taking
things
moving
them
into
the
channel,
so
I
relinquish
ownership
of
them
and
then
later
on,
someone
else
and
a
concurrent
aspect
models.
You
might
get
the
the
channel
that
we
read.
A
So
right
now
we
have
two
kinds
of
channels
where
one
is
asynchronously
Sunday.
When
earth
one
is
essentially
infinitely
buffered
in
one
is
synchronously
water,
and
what
that
means
is
this
one?
The
default
channel
function
every
time
you
send
you're
just
going
to
keep
sending
in,
send
me
instead
of
attending.
It's
just
got
a
big
queue
of
things,
so
it's
essentially
asynchronous
and
there
another
one
called
sink
channel
where
you
can
create.
If
you
care
about
an
offer
and
then
when
you
tend
to
send
on
about
a
channel
avons,
so.
A
Two
distinct:
they
only
have
those
two
you
later
James
philosophers,
Bowl
or
clock,
botton
split
it
you
can
create
with
a
zero
buffer
as
well
between
Ziva
topically
hand,
things
off
into
the
hole
with
you,
so
what's
gets
in
so
another
thing
that
we
allow
you
to
do
a
channel
is
a
selection
of
them,
and
selection
is
just
a
way
of
saying:
I
want
to
wait
for
all
these
channels,
but
just
telling
them
one
of
them
links
up.
So
in
this
case
we're
listening
on
two
channels
and
depending
on
which
one
we
received.
A
First,
we're
actually
going
to
run
that
blog
first,
and
this
is
kind
of
a
select-
is
the
way
you
kind
of
compose
channels
together
and
kind
of
build
your
application
from
above
many
channels
for
many
places.
So
the
other
thing
I,
don't
think
which
Ross
has
which
is
not
unique
to
Russ.
This
is
the
approval
of
SharePoint
response.
If
you're
familiar
with
that
as
Mark,
we
call
it
art
and
it
stands
for
atomically
reference
counted
pointer
and
what
all
that
means
is
that
sister,
it's
gotten
fired,
but
the
operations
on
it.
A
Our
talk
so
it's
safe
to
share
across
threads.
So
in
this
case,
what
I'm
doing
is
I'm
Cleve,
a
vector
of
three
numbers
and
put
into
an
arc
a
pointer,
and
then
this
shared
numbers
thing
is
actually
just
a
point.
That's
all
it
is
it's
a
planner
to
this
park
and
I
close
what
that
does.
It
creates
a
new
reference,
so
child
numbers
and
shared
numbers
actually
point
to
the
same
day.
A
Oh
there's
no
copy
going
on
this
is
very
clones,
are
very
cheap,
some
cheap
operations
and
then
I
move
one
of
them
into
the
and
I
leave
one
of
them
on
the
outside.
Everyone
can
access
it
at
the
same
time,
so
this
is
Argus
or
how
you
share
memory,
which
is
distinct
for
a
message
passing
and
message
passing:
there's
not
a
whole
lot
of
sharing
you're
just
sending
things
to
place
to
place,
but
a
lot
of
times
you
might
have
like
a
very
large
data
set.
You
want
to
share
with
your
task.
A
A
And
then
one
of
the
last
things
about
your
days,
mutexes
and
mutexes-
are
things
that
I
find
essentially
every
language
that
has
threads
or
anything
like
that.
But
one
of
the
rusts
are
one
of
the
things
that's
kind
of
a
little
bit
unique
about
recipe.
Texas
is
the
one
you
would
acquire.
A
locket
X
represents
a
resource
inside
that
lock.
A
So
in
this
case,
while
I
have
the
lock
I
have
access
to
the
vector,
but
when
I
don't
have
the
lock
have
access
to
the
vector
I
just
cannot
access
it.
So
this
is
a
way
that
bus
protects
you
from
accessing
something
outside
of
a
lot
where
it's
kind
of
easy
to
do.
With
you're,
just
using
like
pthread
mutex
or
things
like
that,
because
there's
no
concept
of
what
they're
protecting.
A
Wide
array
of
libraries
and
fun
things
all
stood
sink
is
the
the
module
that
we
have
everything
we
can
find
stuff
like
barriers
for
having
tons
of
threads
synchronize
at
one
location
and
then
go
on
our
W
locks
for
graphic
reader
fire
locks.
Semaphore
is
fun
for
all
tons
of
things
and
once
is
fun
primitive
where
you
give
it
a
function
and
it
basically
it
wasn't
once,
but
every
future
person
will
never
move
again.
It's
a
pretty
efficient
way
to
control
initialization.
A
A
That's
actually
kind
of
hard
to
happen.
That's
kind
of
hard
to
happen,
so
you
have
to
explicitly
authentic,
which
I'll
show
you
and
then
I'll
talk
about.
More
often
is
one
one
synchronize
or
one
is
a
right
and
how
we
can
we
can
prevent
these,
and
the
goal
is
to
totally
prevent
databases
which
prevents
up
to
five
behavior
which
prevent
scratches
interest.
A
So
if
you,
if
you
go
back
to
thinking
about
ownership,
this
is
kind
of
a
classic
okay,
so
we're
in
C++.
If
I
did
this,
it
would
compile
just
fine.
Most
of
the
time
would
work,
but
most
the
time
also
would
be
in
the
sense
that
this
vector
is
being
shared
along
as
a
child
thread
and
the
main
thread.
So
this
factor
is
being
concurrently
modified
and
it's
being
concurrently
written
to
a
pushing
acts
by
pushing
things
on
this
vector
now,
things
in
rust
are
protected
by
default.
So
this
is
like.
A
Stuff,
this
won't
actually
compile
them,
and
what
happens
here
is
this
thing
called
a
proc
is
called
procedure
in
rust
and
procedures
are
kind
of
a
closed
you'll.
If
you
are
the
promoter
languages
worth,
but
this,
this
closure
consumes
ownership
of
anything
that
closes
over.
So
in
this
case,
this
vector
V
is
moved
into
the
procedure,
so
the
procedure
now
owns
it,
and
then
this
outer
friend
or
has
access
to
it.
So
this
fails
to
compile,
because
the
outer
outer
thread
is
using
a
move
value
so.
A
A
You
can
actually
have
shared
memory
with
arts,
so
this
is
kind
of
a
same
example
from
before,
where
the
arc
is
a
way
to
you,
you
give
them
ownership
to
this
arc,
and
then
you
closure
along.
If
you
move
it
into
test,
you
can
access
a
concurrent
I
can
look
at
the
leg.
Look
at
whether
it
contains
things,
and
this
is
lots
of
reading
access
so
question
you
might
have
it
as
well.
It's
not
very
useful
like
what,
if
I
just
put
an
arc
around
the
spectrum
has
pushed
on
that's
the
exact
same
problem
is.
A
So
it
turns
out,
if
you
try
to
do
the
rust,
also
just
allows
that.
So,
if
you
do
that,
where
you
take
this
vector,
you
put
it
into
the
garden
and
then
you
attempt
to
modify
the
vector
it
rescues.
This
error,
you
cannot
borrow
a
immeuble
dereference
of
an
X
n
pointer
as
beautiful,
and
all
that
really
means
is
rust.
Has
these
two
player
types
of
ampersand,
ampersand
Mew,
which
is
a
shared
borrow
at
a
you
tomorrow,
so
this
push
function?
A
Natural
requires
a
mutable
borrow
because
you're
modifying
the
container
and
arcs
only
allow
you
to
get
a
shared
reference
out
of
them.
So
this
means
that
all
the
methods
on
the
back,
which
require
a
mutable
reference
to
itself,
don't
work
so
this
bit,
what
arc
is
essentially
doing
is
giving
you
real
access
to
the
data
inside
of
them
now
that
we
only
I'll
kind
of
give
them
a
copy
on
a
second.
But
this
is
how
this
is.
The
non
synchronous
write
that
I
was
talking
about.
A
There's
a
that's
an
uncivilized
write
operation
and
if
they
go
back
to
the
top
you
can
see.
The
ingredient
for
data
rates
is
two
concurrent
accesses
which
we
got.
We
got
to
be
joining
pair
level
over
shared
memory
at
the
same
location
between
commas.
We
have
parts
and
then
the
next
requirement
is
at
least
one
s
and
synchronized.
So
we've
banned
that
right
now
there
is
no
sorry
we're
doing
the
right
where
there's
no
one,
there's
no
right!
There's
no
relocation
right
now,
just
yet,
because
arks
only
allow
you
read-only
access
the
into
the
insides.
A
B
A
Again,
in
a
protective
manner
for
things
like
mutexes
neat,
X's
are
explicitly
designed
such
that
when
you
you
can
share
them
across
many
threats
and
then
you
can
lock
them
across
many
threads
and
then
you
can
do
all
the
things
you
can
clip
it
as
you
normally
would.
So
what
this
is
doing
is
the
first
thing
is
I'm
freedom,
vector
I'm,
putting
inside
our
mutex
and
I'm,
putting
all
that
inside
of
the
mark.
A
So
what
I
have
now
is
that
all
the
reference
kind
of
piece
of
memory
with
a
mutex
inside
of
it
with
an
event
with
the
vector
inside
of
that,
so
you
can
kind
of
see.
This
is
a
lot
of
composition
going
on
here
at
these
primitives
kind
of
all
building
on
top
of
one
another
get
to
get
to
our
final
problems.
But
the
key
idea
here
is
everything
is
kind
of
owning
the
inside.
Once
you
own
it,
you
get
to
choose
how
you
allow
access
to
it.
So
in.
A
In
this
sub
procedure,
we
actually
grab
the
lock
and
put
something
on
to
it,
and
that
will
because
locks
are
thread
safe
and
synchronized.
We
were
allowed
to
that
that
bad
notation
is
saved,
because
this
thread
count
even
access
the
vector,
unless
of
has
the
lock.
So
we
can.
If
we
go
back
to
the
original
slide,
you
can
see
that
these
unsynchronized.
C
A
A
To
make
access
to
a
vector,
say,
physical
interview,
Texas
people
only
way,
and
then,
if
you
want
a
more
efficient
access,
you
can
have
N
or
W
law
which
solves
many
readers,
but
one
writer
things
like
that.
So
this
is
where
we
are
taking
kind
of
conventional
wisdom
around
these
primitives
and
make
them
yes
in.
C
A
A
B
A
A
park
which
is
essentially
just
a
plumber
I
can
go
to
the
exact
that
I
can
call
if
it's
on
that
without
any
other
syntactic
sugar
or
without
any
other
things
going
on,
like
you
can
just
do
it,
it
should
be
weighted.
So
this
way
this
is
actually
calling
the
block
method
on
a
mutex
and
then
what
that's
returning.
This
is
actually
kind
of
a
fancy
thing
called
a
mutex
bar.
A
So
I
won't
go
too
much
into
this
lifetime
standards
and
things,
but
it
turns
out.
This
is
actually
an
object
itself,
and
so
what
this
goes
out
of
scope
is
going
to
unlock
the
log,
and
then
this
is
the
internist
and
then,
when
you
call
that
push
it's
not
actually
going
to
push
on,
this
is
coming
very
often.
Yes,
so
there's
some
syntactic
sugar
going
on
here
to.
A
A
I
was
alluded
to
borrowing
we're
from
another
thing:
I
can
borrow
a
resource
and
if
you
think
about
it,
kind
of
conceptually,
if
I
borrow
something
it's
only
valid,
while
that
thing
is
still
there.
So
it's
like
this
borrow
is
valid
for
a
very
specific
lifetime
and
that's
kind
of
the
conception
way
to
think
about
it,
and
then
it's
actually
manifested
in
terms
of
these
tickety's
all
over
the
place.
But
you
were
I,
wouldn't
I'll
talk
more
about
them.
A
A
A
The
critical
part
is
that
these
never
happen
at
the
same
time.
You
have
to
have
both
of
these
to
happen,
sir,
yes,
well,
each
one
of
these
happens
to
each
one
of
these
can
happen
independently
of
one
another,
but
these
two
memory
accesses
I'm
talking
about
is
you
can
never
have
two
unsynchronized
memory
accesses
for
one
of
those
right
and
you
can
have
never
have
to.
A
Both
of
which
are
rights
almost
there
tonic,
which
case
everything
is
all
fine,
so
I'll
go
on.
I
can
go
into
some
more
details
later,
but
in
general,
the
primitives
in
trust,
actually
prevent
all
all
the
data
races
from
that.
So
another
thing
that
I
was
talking
about,
which
is
played
a
lot
of
concurrent
programming,
is
dull.
Freeze
where
a
lot
of
times
you
know
you're,
not
actually
sugar
lens
resource
goes
out
of
scope.
Someone
else
might
free
it
or
you
might
create
or
you're
not
totally.
A
Out
of
scope,
that's
when
your
freedom
resource
can
only
blow
up
one
time,
so
that's
kind
of
the
the
key
aspect
to
ownership.
Is
you
have
that
guarantee?
You
actually
don't
even
worry
a
hold.
What
I've
helped
double
freeze?
You
don't
need
a
worry
about
a
whole
lot
about
marry
manager
and
things
like
that.
You
kind
of
create
the
memory,
but
then
someone
else
goes
and
takes
care
of
it
from
you
after
that
point.
So
because
we
have
this
concept
of
moving
around,
everyone
is
always
blown
by
someone
else
or
they're
free.
A
B
A
At
some
point,
what
it
needs
to
so
when
you
combine
no
data
races
and
no
double
freeze,
you
get
no
cyclones,
and
this
is
this
is
the
Holy
Grail.
The
rest
is
kind
of
approaching
and
running
after
is
no
cycle.
So
with
all
those
combined
together,
the
rust
can
give
you
a
memory
concurrent
model
of
concurrent
premise,
but
you
can't
cycle
it's
a
lot
of
times
if
you're
kind
of
daunted
by
writing
these
writings
big
applications,
which
bobbin
with
lots
of
concurrent
aspects
to
them,
it's
it's
it
can
be.
A
You
can
stop
very
very
quickly,
saying
oh
I'm,
actually
sure
if
this
can
cyclone
I'm
not
actually
sure
if
this
is
safe,
but
in
rust
you
know,
but
if
it
compiles
it's
safely,
not
to
worry
about
it.
So
this
is
where
the
kind
of
the
safety
and
Russ
is
absolutely
paramount.
Is
the
primary
goal
of
Russell's
to
give
you
all
of
the
safety
and
prevent
crashes,
but
while
still
allowing
you
raw
access
to
these
concurrent
situations
of
all
these
contexts,
which
is
really
really
critical
for
a
lot
of
applications?
A
So
I
didn't
want
to
talk
a
whole
lot
about
deadlocks
and
starvation
in
terms
of
Russ,
and
it
turns
out,
we
do
still
allow
us,
but
the
good
part
is
that
this
is
not.
This
is
a
less
severe
conditioning.
This
is
office.
This
is
still
exploitable
in
some
sense,
but
it's
much
less
exploitable
in
terms
of
Archer.
Who
is
huge,
and
things
like
that,
so
we
have,
in
the
past
attempted
to
prevent
download.
B
C
A
Could
only
do
a
lot
of
useful
things
with
it,
some
ended
up
just
ripping
it
out.
So
today's
our
position
today
is
that
the
Russ
Tech
system
is
not
powerful
enough
to
actually
prevent
these
two
situations
and
it
may
be
able
to
in
the
future.
But
for
now
it's
the
way
that
it's
currently
designed
is
it's
too
limiting.
A
If
we
actually
leverage
it
to
try
and
do
this,
so
you
can
still
get
into
a
deadlock
with
rust,
you
can
still
start
it
if
you
just
star
readers,
writers
and
rust
things
like
that,
but
these
are
not
considered
unsafe
operations.
Leaders
are
just
kind
of
considered
application
errors,
and
do
you
think
back
to
the
beginning
kind
of
all
under
race
conditions
as
well?
We
don't
prevent
race
conditions.
I
can
still
make
a
database
connection
mega
TCP
socket
than
actually
mismatch.
What's
being
settled,
or
something
like
that,
so
rust.
A
Else
cannot
prevent
that,
but
that
it
is
arguable
application
error
than
the
actual
engine
is
well
less
exploitable
differences.
Things
like
that,
so
that's
all
I
have
we
have
tons
at
least
I
have
or
you
can
find
all
of
his
all
the
servers
all
in
the
line
just
give
up
with
a
website
an
IRC
channel
and
remind
me
that
I
had
stickers,
because
I
always
forget
to
take
a
secret
several
times
to
emphasize
students
all
right,
any
questions.
So
this
is
a
if
you.