►
From YouTube: Cloud Native Rust Workshop: Let's go parallel with Rust - Florian Gilcher & Sabree Blackmon, Ferrous
Description
Don’t miss out! Join us at our upcoming event: KubeCon + CloudNativeCon North America 2021 in Los Angeles, CA from October 12-15. Learn more at https://kubecon.io The conference features presentations from developers and end users of Kubernetes, Prometheus, Envoy, and all of the other CNCF-hosted projects.
Cloud Native Rust Workshop: Let's go parallel with Rust - Florian Gilcher & Sabree Blackmon, Ferrous Systems GmbH
In this session, we are going to build a small Rust server together. We’ll start with a simple server that accepts and delivers data through a simple TCP protocol.
Then, we will start using threads to parallelise the process. After that, we will rewrite the same project in an async fashion.
This way, you will get a basic feel for Rust and its concurrency features.
To follow the session, I recommend that have Rust installed through https://rustup.rs (rustup may also be available in your distributions package manager) and have rust-analyzer set up.
A
A
A
Before
I'm
even
getting
started
introducing
myself,
if
you
don't
have
rust
installed,
I
would
highly
recommend
you
to
install
rust
through
rust.
Stop
this
means
you
can
either
go
to
rustling.org,
learn,
get
started,
and
the
reason
why
I
put
this
slide
up
front
is,
if
you
are
using
oh
for
some
people,
audio
seems
to
be
muted,
okay.
A
If
you
can't
get
rust
installed,
you
can
always
use
the
playground
and
the
play.rustlang.org
to
follow
along
and
at
least
get
things
to
compile
and
I'll
explain
what
rust
stop
is
in
detail
in
a
bit,
but
just
for
the
sake
of
making
sure
that
you
can
get
the
get
your
download
started
and
your
installation
started.
I
wanted
to
put
this
as
a
first
slide,
so
who
am
I
I'm
from
geisha
I'm
one
of
the
founders
of
ferris
systems
in
critical
section?
A
I
don't
think
that
copyright
on
teaching
material
is
a
good
forcing
function
and
the
other
thing
that
we
do
as
far
systems
which
I
would
like
to
highlight,
is
we
try
to
work
as
much
as
possible
in
open
source,
also
using
new
funding
models.
So,
for
example,
we
propose
tools
to
the
ecosystem
that
we
think
is
useful,
that
we
think
are
useful
and
then
for
them.
A
A
That
is
the
job
of
a
subsidiary
called
critical
section,
and
that
is
a
project
that
we
want
to
succeed
in
in
the
next
few
years.
2020
to
2023
is
the
date
when
we
want
to
see
rust,
on
course,
about
this
workshop
and
how
it's
going
to
work,
because
I
only
have
two
hours
the
way
I'm
going
to
do.
This
is
in
a
code
along
style.
A
If
you
want
to,
you,
can
just
watch
me
doing
things
and
talking
about
it,
but
also
I
highly
encourage
you
to
have
a
text
buffer,
open
and
just
code
along
also
like.
If
you've
got
a
minute
and
some
bandwidth,
you
can
try
to
like,
take
chances
and
start
developing
in
a
certain
direction
or
not
and
just
try
things
out,
and
please
ask
questions
in
chat,
doing
that.
I've
made
sure
that
the
example
is
small
enough
that
I
have
ample
time
to
actually
go
and
talk
about
these
kind
of
things.
A
I'll
also
be
relying
on
a
little
of
the
experience
of
the
previous
speakers
that
they
have
shared
particularly
nell's
talk
about
borrowing
and
working
with
the
borrower,
checker,
which
I
will
show
practical
applications
of,
and
the
example
is
betraying
really
simple.
What
we
want
to
build
in
the
next
two
hours
is
just
a
small
server
that
accepts
tcp
connections.
Not
even
http
connections
then
read
one
line
from
the
incoming
stream,
either
until
the
first
new
line
or
until
the
input
stream
closes.
A
A
That's
that's
about
it
and
along
the
way,
we
will
actually
learn
how
rust's
ownership
model
does
not
only
manage
memory
but
also,
for
example,
other
resources
like
network
connections,
we're
going
to
learn,
mutable
and
immutable
references
and
how
they
work
and
how
I
can,
for
example,
work
with
them
in
a
dynamic
setting
where
need
to
assume
multiple
connections
to
be
currently
being
handled,
and
also
some
basic
concurrency
safety.
Few
mutexes
and
smart
pointers
so.
A
A
A
A
A
A
A
A
A
I
won't
go
too
much
into
details,
but
rust
stop
is
rus
toolchain
manager
and
what
it
does
it
installs
rust,
compiler
versions
for
you
allows
you
to
switch
between
them,
similar
to
something
like
rvm
or
the
node
version
manager.
But
it
also
does
more-
and
I
think,
that's
the
important
part
around
this
and
where
it
becomes
the
tool
chain
manager.
A
But
another
thing
that
it,
for
example,
allows
is
that
rust
by
default,
all
the
tooling
as
cross
compilation,
aware
and
rust,
the
rust
project,
ships,
a
number
of
pre-built
targets
and,
for
example,
rostop
also
manages
these.
So
I
do
quite
a
bit
of
embedded
development
on
these
kinds
of
ports,
but
that's
not
the
point
of
this
course.
So
I
have
a
number
of
the
targets
installed
to
insta,
to
compile
software
for
this
board,
and
here
is
my
native
target,
I'm
on
a
windows
pc
and
I
use
the
microsoft
visual
code.
A
Back-End
there's
also
one
for
mean
gw.
If
you
want
to
use
that.
So
if
you
want
to
use
a
neutral
chain
on
windows-
and
you
prefer
that
you
see-
there's
other
ones
like,
for
example,
android,
even
like
google's
new
operating
system,
fuchsia
the
experimental
one
and,
for
example,
ios
so
rostop
manages
your
whole
development
environment
and
that's
why
I
recommend
using
it
there's
a
some
people,
don't
like
rust
up,
because
you
need
to
install
it
through
a
shell
script.
A
A
A
This
is,
in
general,
the
one
that
is
used
to
compile
other
packages
just
for
the
difference
on
what
rustop
does
and
why
there's
still
one
in
package
managing
and
this
one,
I
would
recommend
to
use
if
you
are
actually
interested
in
testing
your
software
on
a
specific
linux
distribution
and
one
thing
that
is
just
to
quickly
address
the
question
by
olga.
What
would
you
recommend
as
a
container
base
for
windows
based
build?
I
usually
don't
build
in
containers
when
I'm
working
on
when
I'm
working
on
windows.
A
A
A
A
A
So
what
this
creates
is
a
new
cargo
project.
Cargo
is
rust's,
build
tool,
build
management
and
dependency
management
tool,
and
it
has
a
manifest
file
called
cargo
tunnel,
tommel
tom's
obvious
minimal
language,
a
kind
of
an
any
file
language.
I
think
most
people
know
tamil
now
nowadays
and
what
it
takes
is
a
top
level.
Key
called
package
gives
the
package
some
metadata,
the
name
version.
A
A
You
can
completely
ignore
the
2015
profile
nowadays,
no
one
uses
it
anymore,
except
in
very
niche
cases
where
code
hasn't
been
ported
over
yet.
So
this
is
something
what
I
would
say,
learn
or
need,
if
you're
learning,
rust,
learning
rust,
2018
and
don't
bother,
unless
you
probably
never
run
into
the
case
where
2015
becomes
relevant
for
you
and
below.
We
have
a
dependency
section,
and
in
this
dependency
section
we
can
express
dependencies
similar
to
rubygems
npm,
any
other
package
manager,
but
we're
not
going
to
express
one
now.
A
A
For
that
I
will,
I
can
highly
recommend
after
this
course,
or
actually
follow
down
a
little
the
types
that
I'm
going
to
use
here
and
have
a
look
at
their
documentation
in
the
standard
lab.
I'm
not
going
to
do
that
for
the
sake
of
time,
but
our
standard
clip
is
completely
documented
and
again,
if
you
read
something
in
the
documentation
and
it
doesn't
immediately
click
or
you
have
a
hard
time
understanding,
it
would
also
be
very
interested
in
a
bug
report.
A
A
A
A
A
If
you
have
a
look
here,
listener
is
now
results,
tcp,
listener
error
and
that's
the
first
time
in
russ
that
we
get
actually
in
touch
with
the
result
type
on
the
very
first
line.
Rust
has
a
special
or
this
is
actually
not
special,
is
just
a
type
that
is
provided
by
the
core
library
says
that
extract
over
things
that
work
or
may
not
so
here
it
says
this
gives
back
a
result
of
tcp
listener
and
error.
A
What
unwrapping
says
is
either
this
works
or
immediately
crash
for
beginners.
That
sometimes
feels
like
this
is
a
this
is
a
way
out
like
I,
I
ignored
the
structured
error
handling
that
russ
does.
I
do
not
fully
subscribe
to
that.
Calling
unwrap
is
basically
a
statement
that
if
this
doesn't
work,
then
the
program
should
immediately
quit
and
shut
down
in
a
structured
way.
A
So
it
is
perfectly
fine
to
do
that.
Also
for
the
sake
of
this
session,
I
will
actually
handle
all
result,
types
using
unwrap
why
this
is
actually
for
even
for
experienced
rust
developers
an
easy
first
pass.
I
just
assume
everything
works
all
right
and
then
I
can
later
go
look
at
all
of
those
and
wrap
calls
and
turn
them
into
structured
error
handling.
A
Because
then
I
know
all
the
errors
that
could
happen
in
the
program
that
I
have,
and
that
is
a
good
moment
to
collect
them
all
and
put
a
more
structured
error
handling
on
top
of
that.
So
that
is
something
if
we
have
enough
time
that
I'm
actually
going
to
do
so.
I
don't
want
to
omit
that
part,
but
let's
see
how
far
we
get.
A
So
I
get
a
small
warning
that
I'm
not
using
using
this.
This
variable,
don't
let
warnings
confuse
you
too
much.
The
rust
compiler
takes
care
that
all
varnic
warnings
are
relevant
once
you're
done
so
currently,
hey
you're,
not
using
this.
I
can
ignore
this
warning.
I
will
use
that
variable
in
a
second,
but
once
your
program
is
done,
it
is
actually
good
practice
to
see
that
it's
warning
free,
because,
again,
all
all
warnings
should
ultimately
be
relevant.
A
A
That
is
a
choice
you
can
make
if
you
want
to
I'm,
usually
because
I
am
not
using
this
like-
I
want
to
remove
this
at
some
point-
I'm
just
using
unwrap
right
away
and
then
I'm
filling
that
later
on
jack's
question:
why
unwrap
with
this
question
mark
this
is
possible.
This
is
actually
something
that
I
will
would
do
once
we
go
to
more
structured
error
handling.
But
currently
I
want
everything
to
just
explode
at
the
place
where
it
happens.
A
So
during
doing
development
I
actually
like,
if
errors
have
like,
if
errors
stop
the
program
at
the
place
where
they
happen
for
coding,
initial
coding
and
debugging,
I
find
that
more
helpful,
so
they
have
different
different
behavior
question.
Mark
is,
is
a
different
way
of
error,
handling
and
the
question
of
victor.
Will
russia
throw
warnings
for
easier
search
of
on-wrap
usage?
A
A
So
I
can
use
a
for
loop
here
and
the
reason
why
I'm
saying
connection
attempt
is
the
this
only
represents
the
attempt
to
connect
so
later
if
we
were
to
write
a
fully
fledged
service.
This
allows
us,
for
example,
to
react
to
to
the
condition
that
the
kernel
started.
Rejecting
connections,
for
whatever
reason
I
will
see,
still
see
their
rejected
connections
here,
and
this
is
the
one
place
where
I
would
actually
like
to
look
at.
How
that
what
that
looks
like
if
we
look
here,
connection
attempt
is
again
a
result
of
a
tcp
stream.
A
A
So
what
it
tells
me
is
there's
multiple
options
that
there's
multiple
alternatives
that
you
need
to
cover
which
that
type
could
represent,
and
I
can
easily
get
them
inserted
by
my
ide
by
clicking
here
left
and
say,
fill
my
charms
and
now
I
have
those
two
conditions
and
results
is
a
type
that
says:
either
everything
went
okay
then
you
get
the
loft
value
or
there
was
an
error.
Then
you
get
the
right
value.
A
A
Arrow
connecting
oh
and
e-printer
line
prints
to
standard
error
instead
of
standard
out
and
using
the
interpolation
syntax.
Here
I
can
print
e
there's
a
question
in
the
chat.
Was
that
does
the
bang
mean
an
e-printer
lm
iprinterland
and
printerland
are
macros
in
rust
and
macros
always
need
to
be
called
with
a
bang
on
them?
A
A
A
A
There
we
go
now,
we
have
this,
handle
client
function
and
can
do
whatever
we
want
here.
First
of
all,
one
thing
that
I
would
like
to
do
is
remove
the
standard
net
here
and
import
the
tcp
stream
directly,
so
that
I
don't
need
to
fully
qualify
it,
because
I'm
going
to
use
it
again
for
other
functions.
A
So
it's
a
piece
of
convenience
here
and
there's
an
important
thing
here.
Rust
has
famously
this
ownership
system
and
if
you
just
pass
in
a
bear
type
into
a
function,
we
say
it
takes
ownership,
so
this
function
now
takes
ownership
of
the
connection
and
what
we
can
now
do
is
example.
We
can
print
here
client
connected.
A
A
A
A
And
the
reason
for
this
being
is
precisely
rust's
ownership
model.
I
have
not
explicitly
said
goodbye
to
the
client,
but
this
handle
client
function
has
taken
ownership
of
this
currently
currently
active
tcp
stream.
For
that
client
and
one
thing
that
rust
does
implicitly,
but
I
can
also
annotate
that
explicitly
is
once
an
own
value
falls
out
of
scope.
A
A
A
A
That
means
we
express
a
low
coupling
between
those
two
components.
The
net
component
is
now
not
responsible
for
handling
the
stream
anymore
at
all.
The
handler
is
now
responsible
for
doing
that,
and
that
ownership
transfer
is
complete
in
the
sense
of
the
one
component
is
not
allowed
to
use
it
anymore.
I
can
actually
try
that
out
if
I
were
to
try
doing
something
with
stream
over
here,
for
example,.
A
A
A
A
A
A
A
A
I
maybe
want
to
write
to
the
client
again
and
do
other
things
with
the
stream,
so
I
do
not
want
to
throw
it
away,
so
I
do
not
want
to
pass
on
the
handling
of
this
resource,
so
I
give
readline
the
ability
to
use
that
resource
through
reference,
but
I
do
not
want
to
give
it
away
so,
every
time
you
see
a
type
that
has
a
kind
of
sigil
ampersand
or
something
like
that
and
rust.
That
means
this
is
where
the
referencing
system
takes
place.
A
A
That
correctly
reads
a
line
with
all
kinds
of
new
line:
careers
return,
new
line,
whatever
doesn't
matter
now
you
see
this
takes
a
this
takes
a
buff
argument,
and
this
is
the
actual
buffer
that
we
need
to
that.
We
want
to
write
to
and
as
its
read
line
it
reads
into
a
string
buffer.
You
can
see
here,
ampersand
mut
string.
A
And
this
is
a
second
kind
of
reference
that
rust
has
rust,
has
a
difference
between
mutable
references
and
immutable
ones,
and
both
are
not
allowed
to
be
active.
At
the
same
time,
you
need
to
either
mutable
reference
or
immunity
reference
you
can
also,
if
you
have
experience
with
concurrency
safety,
you
can
already
see
where
this
is
going.
Rust
does
not
allow
you
to
have
to
look
at
data
and
to
mute
it
at
the
same
time,
and
now
that
we
have
read
this
line.
A
A
The
question
whether,
like
the
answer
that
kevin
gave,
I
mean
to
to
ask
whether
why
we
need
to
call
this
a
second
time.
This
is
different.
This
is
the
variable
is
mutable
and
we're
allowed
to
mutate
it
and,
as
kevin
says,
this
is
correct.
This
is
now
we
take
immutable
reference
to
it.
So
for
this
to
be
allowed,
it
needs
to
be
immutable,
but
we
need
to
reset.
We
need
to
state
that
we're
taking
this
reference.
A
A
A
A
A
A
A
That
is
a
strategy
that
rust
applies
a
lot
to
make
sure
that
the
code
you
write
is
actually
compiling,
even
in
the
face
of
interface
changes
in
years
out,
unless
someone
deliberately
breaks
existing
interface
that
obviously
it
doesn't
work.
So
if
you
read
line
would
change
its
its
type
signature,
its
function,
signature,
then
that
would
break.
A
A
A
A
A
A
And
these
two
are
equality
is
actually
defined,
so
request.
Equals
request
can
be
automatically
be
applied.
You
can
build
custom
implementations
of
these,
so
if
you
wanted
to,
you
can
omit
the
compiler
doing
that
and
just
write
your
own,
but
for
convenience
here
and
because
they're
so
common
there's
this
derived
interface.
That
allows
you
to
have
the
compiler
auto-generate
that
and
the
rule
is
very
simple.
A
If
any
of
these
here
internally
have
data
here,
for
example,
string,
then
it
expects
that
that
string
also
implements
debug,
eq
and
partial
eq,
and
then
again
the
compiler
can
reason
about
the
structure
of
the
request,
type
and
say:
okay,
there's
a
trivial
equality
and
debug
implementation.
Here,
the
partial
eq
here
is
a
little
bit
odd.
You
need
that
for
floats,
but
eq
cannot
be
derived
without
a
partial
eq
being
present.
A
A
A
A
A
A
A
A
One
thing
to
note
here,
rust
is
an
expression
based
language
similar
to,
for
example,
ruby.
So
we
can,
we
do
don't
need
to
say
return
request
retrieve.
We
can
in
the
one
arm
here
return
request
retrieve
in
the
other
arm
of
the.
If
statement,
request,
publish-
and
that
means
the
if
statement
always
returns
a
request
type
and
we
can
just
let
that
flow
out
into
out
of
the
function
and
we
return
a
request.
A
There's
a
question
by
boban
which,
whether
to
use
string
from
trim
to
own
or
trimmed
to
string,
there's
a
fourth
form
that
also
exists
which
one
to
use,
in
which
case
I
generally
recommend.
Thank
you.
I
generally
recommend
to
use
a
string
from
I
like
that,
the
most
but
they're,
actually,
all
the
same,
they
used
to
be
a
difference
with
tostring
was
actually
faster
due
to
in
inadequate
compiler
optimizations.
A
A
A
A
There
we
go
so
we
can
use
this
data
type
that
we've
used
that
expressed
these
two
alternatives
here
to
to
guide
ourselves
through
our
reaction
to
those
requests.
It's
essentially,
if
you
look,
this
is
a
little
bit
of
a
router
here.
I
would
not
use
this
like.
I
would
not
use
match
as
a
router
for
any
kinds
of
systems.
There's
more.
A
A
Things
now
the
only
and
you
might
have
noticed
I've
not
been
doing
I've
been
using
the
type
system
to.
Let
me
flow
through
the
things
that
I
wanted
to
do,
and
I've
only
added
this
one
data
type
where
I
introduced
my
own
alternative,
my
own
semantics
here,
there's
a
probable
request
and
there's
a
retrieve
request.
The
rest
I've
been
flowing
through
the
type
system
here
and
now
now
that
I'm
faced
with
this
decision
now
I
have
a
problem.
A
I
actually
want
to
store
store
data
and
I
have
no
storage
and
I
on
a
new
question
it
it
does
actually
take
my.
It
does
actually
take
my
input.
It
just
doesn't
echo
it.
So
that's
the
annoying
part
here,
so
I
would
actually
just
go
and
pop
this
shell
here
off,
so
that
you
see
the
actual
reaction.
Okay,
so
again,
coming
back
to
this
now
I
need
storage.
A
A
Vector
q,
it's
a
double,
ended
queue
based
on
backed
by
a
vector
the
nice
thing
around.
That
is,
it
allows
me
to
push
something
in
the
back
and
pop
it
out
from
the
front
in
difference
to
a
normal
vector
type.
That
rust
has.
That
only
allows
me
to
push
in
the
back
and
pop
the
last
element-
and
I
wanted
to
have
this
kind
of
first
in
first
out
behavior,
so
pushing
back
taking
from
the
front
is
the
semantics
that
I
want.
A
A
A
A
There's
a
question
olga:
is
there
not
a
lot
of
go
channels
and
rust,
not
as
a
language
feature?
It's
actually
rust
did
have
in
language
channels
at
some
point
as
a
research
prototype,
there
are
channels
in
that
can
be
found
in
standard
lib,
yeah
and,
as
supreme
mentions,
there's,
for
example,
the
cross
beam
crate
allows
that
the
nice
thing
about
channels
is
that
they
also
work
by
this
ownership
principle.
You
push
something
into
you,
send
something
through
a
channel.
A
A
A
Needs
to
be
mutable,
so
I
can
actually
give
it
away
and
now
on
every
loop
doing
every
connection
I
give
you
the
story.
The
storage
over
to
handle
client
can
write
something
or
read
from
it
and
then
on
the
next
loop.
It
will
be
passed
to
the
next
client
handler
on
the
next
loop
iteration
and
over
here.
That's
simple:
what
do
I
do
in
publish.
A
The
corresponding
method
is
pop
front
gives
me
the
it
gives
me
this
data,
and
now,
let's
have
a
look
at
what
this
variable
is,
and
it
is
option
string,
and
that
says:
well,
it
might
be
there
or
not
and
again
this
is
an
enum
like
the
results
or
the
one
that
I
introduced
tells
me.
These
are
the
two
child,
the
two
things
that
may
happen:
either
there
was
nothing
in
the
storage
or
you
well
or
you
can
write
it
to
the
client.
If
you
want
to.
A
A
First
of
all,
rust
takes
a
very
structured
way
on
its
linger.
So
if
I
can
interpret
something
as
something
else,
the
functions
that
do
that
are
always
called
as
underscore.
So
this
is
no
copy
or
whatever
involved.
This
is
strings,
can
be
seen
as
bytes.
Not
the
other
way
around
bytes
are
not
always
youtube.
Eight
strings
messages.
Bytes
and
you
can
you
basically
just
turn
it
into
the
different
type
and
then
there's
the
write-all
function
here,
which
you
actually
need
to
import
a
trade
for
the
right
trade.
A
To
the
client
slight
warning
here,
rust
does
not
protect
you
from
functional
mistakes,
there's
also
a
write
method.
The
write
method
will
write
as
many
bytes
as
it
currently
can,
until
it
would
block
the
write.
All
will
write
all
the
bytes
on
the
right
side
and
wait
this
to
be
done.
This
is
a
frequent
mistake
here,
people
using
write
and
then
later,
if
they
write
more
data,
actually
losing
data
to
the
right,
because
they
forget
writing
the
data.
A
A
There
might
be
arrows
happening
here
which
the
compiler
will
call
me
out
on.
It
says:
there's
a
result
being
returned
here,
but
you're
not
using
it
you're,
not
checking
whether
it
actually
works
and
that
actually
being
a
warning
and
the
compiler
being
annoying
about
hey.
You
haven't
checked
whether
that
actually
succeeded
is
a
good
thing,
even
though
I'm
choosing
again
here
to
just
say
unwrap,
then
then
let
it
crash.
A
A
A
A
A
A
And
again,
I've
been
using
the
type
system
here
to
guide
me
by
saying:
oh
okay,
so
the
two
things
that
could
happen.
If
I
pop
from
a
collection
is
data
could
be
there
for
data,
could
not
be
there
and
then
react
on
that
and
let
myself
be
guided
by
this
by
this
type
level
flow,
where
the
type
system
can
express
this
kind
of
branching
behavior.
These
are
the
two
things
that
you
need
to
cover.
A
Data
has
been
there
or
not
in
other
languages
that
would
often
be
abstracted
to
an
outpoint
or
a
null
value.
Rust
doesn't
have
nil,
or
now
it
uses
these
kind
of
option
types
here
and
through
compiler
optimizations.
That
doesn't
actually
cost
me
anything.
So
this
is
as
costly
as
a
null
pointer
check
here
in
the
back.
A
A
A
A
On
the
question
on
adrian's
question:
why
don't
we
need
to
specify
the
stream
as
immutable
when
we
pass
it
in
precisely
because
we
have
not
used
it
in
immutable
fashion
at
all
before
so
this
happens,
because
this
is
the
first
time
we're
writing,
we're
writing
to
it.
And
yes,
this
is
because
of
ownership
in
rus.
A
There's
a
the
ownership
principle
basically
says:
there's
only
one
owner
in
the
in
the
whole
world,
essentially
of
any
piece
of
data
so
and
this
owner
can
actually
decide,
for
example,
to
make
immutable
data,
immutable
or
immutable
data
immutable.
So
at
this
place
this
is
really
just
a
choice
and
an
and
an
annotation
which
is
well
the
well.
The
compiler
diagnostic
tells
you
well,
it's
not
mutable,
but
you
can
add
mood
here
and
then
it
is.
But
this
is
own.
This
is
a
privilege
that
only
owners
have.
A
A
A
A
A
A
Oh
there's
one
thing
that
may
help:
if
you
have
vs
code
running
for
days
like
I
sometimes
do.
If
there's
a
vs
code
update
in
between
the
language
server
for
for
a
rust,
analyzer
will
not
install
cleanly
because
that
case
cannot
be
properly
handled.
So
sometimes
like
just
quitting
this
code
and
starting
it
up
again
may
help.
A
And
this
is
completely
synchronous,
so
we're
handling
one
client
at
a
time.
The
kernel
buffers
that
for
us,
so
we're
not
losing
any
clients,
but
we're
going
one
by
one,
and
for
that
reason
well,
we
basically
have
no
parallels
more
concurrency
problems,
because
there
is
none.
So
one
thing
that
I
would
like
to
do
for
the
last
half
an
hour
is
actually
take
this
and
put
it
on
a
thread
and
the
principles
that
I'm
going
to
show
here
will
be
just
as
applicable
to
async
systems
in
in
rust
as
well.
A
So,
for
example,
things
like
tokyo
or
async
stood
or
all
those,
so
the
the
safety
mechanisms
that
rust
supplies
are
exactly
the
same,
especially
because
all
of
those
run
times
are
always
multi-threaded
runtime.
So
the
problem
of
multi-threading
is
always
the
dominant
one.
Here
I
just
find
it
easier
to
explain
that
using
threads
because
they're
a
little
bit
of
a
simpler
primitive
that
does
not
mean
need
understanding
of
the
whole
user
space
runtime.
A
A
A
A
What
it
will
use
yes,
tokyo's
outside
of
scope
for
this
workshop,
but
yes,
you
as
as
written
tokyo,
spawn
and
and
all
of
these
things
will
just
work
and
they
have
similar
semantics,
particularly
around
the
moving.
So
for
the
sake
of
this
workshop,
it's
completely
fine.
If
you
replace
thread
by
task-
and
it
will
work,
it
will
behave
just
the
same
and
the
principles
especially
around
moving
ownership
are,
are
the
same.
A
A
A
A
A
A
Immutably
more
than
once
at
a
time,
because
I
am
not
sure
how
long
this
threat
is
going
to
live
the
threat
that
takes
ownership,
I'm
I
will
not
allow
you
to
pass
immutable
reference
into
a
thread
which
has
like,
because
these
things
might
start
working
in
parallel
or
concurrently,
independent
of
your
runtime
system,
the
whole
concurrency
and
and
parallels
and
checking
and
rust,
is
completely
independent.
It
doesn't
know
if
you're
running
on
a
on
a
threading
on
on
a
thread
runtime,
which
is
essentially
your
kernel,
is
or
if
you're
running
on
something
like
tokyo.
A
Russ
doesn't
know
about
this
at
all.
Just
knows,
oh
so
thread
spawn
and
we'll
run
thread
spawn.
I
need
to
be
aware
that
this
is
a
component
that
has
dynamic
runtime
behavior
over
each
other,
so
you
have
two
threads
running
in
parallel,
and
so
you
don't
know
how
long
this
reference
will
be
used
and
when
and
rust
gives
us
two
tools
around
this,
and
so
we
have
two
problems.
Essentially,
we
have
multiple
threads
or
tasks
or
whatever
I'll
just
call.
This
g1.
A
A
And
what
arc
allows
me
to
do
it
allows
me
to
have.
Let
me
make
this
just
bigger
some
drink,
that
in
front
anyways,
the
arc
is
the
atomic
ref
counter
and
the
atomic
stands
for.
The
counting
is
done
in
an
atomic
manner,
so
that
I
have
no
compare
and
concurrency
problems
on
count
on
the
down
count,
and
it's
a
reference
counter
in
the
sense
that
if
I
have.
A
A
A
A
A
A
A
That
means
that
means
we
don't
know
if
they
would
not,
for
example,
take
out
try
to
mutate
the
shared
data
at
similar
times.
So,
if
I
draw
a
line
here,
there
could
be
moments
where
these
actions
overlap,
and
this
is
how
rust
guarantees
concurrency
safety
actually
through
the
definition
that
mutable
references
are
required
to
write
to
memory
and
that
mutable
references
need
to
be
unique.
A
Oh
sorry,
thank
you.
Thank
you
for
the
pointer
and
chat
that
you
couldn't
see
the
drawing.
So
if
we
have
these
threads
taking
out
immutable
references
at
the
same
time,
there
could
be
a
moment
where
multiple
meteor
mutable
references
are
yet
available.
At
the
same
time,
arcs
have
no
similarity
to
go
context.
Weight
groups
steep
as
my
understanding
for
for
go
context
and
weight
goes.
A
A
My
basically
my
lease
on
a
ref
counted
value,
while
the
clone
interface
is
the
general
cloning
interface
that
rust
has,
which
also
allows
you
to
feed
this
in,
for
example,
in
things
that
that
want
to
express
multiple
ownership
that
you
feed
this
into
things
that
that
might
want
to
clone
and-
and
that
would
cost
you
that
would
cost
you,
for
example,
a
lot
of
memory
if
you
were
actually
doing
this,
so
this
allows
you
to
do
cheap
cloning,
okay.
So
let's
get
to
this
mutable
thing
here.
A
A
A
A
A
A
A
And
this
is
the
one
location.
Maybe
I
can
go
into
details
later
on
why
that
is.
But
this
is
what
I've
been
hinting
at
with
generally
seen
as
an
api
mistake
in
the
standard,
lib
locking
returns
a
result-
and
that's
result
is
almost
not
handleable
in
the
case
where
it
actually
fails.
So
this
is
the
point
where
we
I'll
call
just
unwrap,
and
just
be
okay
with
that,
so
this
is
really
like.
A
A
This
is
a
value
that
represents
I'm
currently
holding
lock,
and
I
can
use
the
card
to
actually
write
to
the
data,
because
this
represents
I'm
holding
a
lock
and
it
knows
I'm
holding
a
lock
to
a
vector
queue
and
will
expose
the
function
pushback.
I
cannot
go
into
the
exact
mechanics
on
how
this
works
here,
but
because
I
would
like
to
talk
a
little
bit
about
how
that
guard
works
in
a
second,
but
just
before
we're
doing
that.
I
would
also
like
to
again
do
that
here,
so
if
we
retrieve.
A
A
And
because
the
mutex
internally
guarantees
that
this
card
can
only
exist
once
that's
the
definition
of
a
mutex,
this
one
will
finally
produce
you
a
mutable
reference
to
which
you
can
write.
That
only
exists
once
this
is
the
thing
that
a
mutex
provides.
So
this
is
like
the
the
cleverness
that
rust
has
there.
A
A
That
means
it's
a
slight
warning
here:
I've
been
using
I've
been
binding.
The
guard
explicitly
here
here.
That
means
the
guard
will
be
released
up
after
actually
writing
to
the
client,
so
I'm
actually
holding
it
for
a
little
too
long,
which
is
why
general
practice
is
actually
to
do
that.
All
in
line.
A
A
So
what
we
see
here
is
we
have
the
mutex
and
then
we
have
this
way
to
come
back
to
mutability
by
working
through
the
lock
interface.
There's
often
the
question
whether
that's
an
escape
patch
in
the
language.
It
actually
isn't
because
I
said
I
wanted
to
come
back
to
this
type
signature
and
make
sure
that
you
understand
it.
A
A
A
A
A
A
This
vector
qb
available
and
this
one
is
enforced,
and
this
is
what
you
generally
know,
as
borrow
checking,
if
you
like
hear
about
it
at
the
hear,
hear
about
that
at
some
point
is
enforced
to
never
live
longer
than
the
guard.
That
would
be
a
violation,
so
rust
does
three
levels
of
safety
checking
here.
A
A
A
A
A
A
A
There
clear,
yes,
you
can
deadlock
in,
live,
locking,
rust
you
can.
There
are
ways
on
how
you
can
force
a
resource
acquisition
order
if
you
structure
your
types
right,
but
that
is
something
you
need
to
work
for
that
doesn't
come.
Naturally
out
of
the
language
you
can
use
the
type
system.
A
little
bit
was
that.
A
The
questions
on
cc,
plus
plus
new
and
delete
in
any
way,
no
there's
nothing
similar
to
new
and
delete
in
in
the
way
that
that
you
would
be
used
to
in
c
plus
we
like
rust,
doesn't
even
have
things
like
special
constructors
there's
some
there's
ways
to
create
to
create
data,
but
the
the
destruction
of
data
always
goes
through
this
drop
interface.
You
can
write
destructors,
that's
the
thing
that
I
haven't
shown
like
all
of
these
things.
Work
through
destructors.
A
A
On
thomas
question,
the
art
no
longer
leads
mood
is
that,
because
of
interior
theory
mutability-
and
yes,
we
are
you've
seen
this
warning
here-
mood
storage.
It
does
not
need
to
be
mutable
anymore.
Rust.
Has
this
idea
of
interior
immutability
just
quickly,
which
is
precisely
this
year,
where
I
have
immutable
access
to
this,
and
but
in
some
way
I
can
produce
mutable
access
here
and
I
said
like
I
cannot
like.
If
I
have
an
immutable
reference,
I
cannot
get
immutable
reference
and
this
is
in
general
true
in
practice.
A
That
would
make
mutexes
not
very
useful
types,
because
that
would
mean
I
would
have
to
need
mutable
access
to
the
mutex
already
to
then
produce
immutable
and
mutable
access
to
its
inner
parts.
So
there's
this
concept
of
immutability
in
that
types
in
and
by
themselves
can
say
I
will
manage
immutability
by
myself,
but
and
and
particularly
at
runtime,
because
that's
what
a
mutex
does.
It
is
a
mutex,
it's
a
moderator
of
mutation
essentially,
but
what
that
means
is
that
it
still
needs
to
uphold
this
guarantee
that
mutable
references
in
rust.
A
If
there
is
one
out
there's
exactly
one
out,
there's
also
no
immutable
references,
there's
exactly
one
mutable
reference
to
the
vector
q
available
at
that
moment
in
the
program
and
nothing
else,
and
that's
that's
important
to
to
make
sure
that
this
is
that
this
is
true
at
all
times
and
mutex's,
especially
many
concurrency
primitives.
Do
you
use
this
kind
of
feature
yeah
and
the
compiler
knows
about
this?
It
knows.
A
A
It
still
needs
to
make
sure
that
in
all
cases,
while
bufferedreader
readline
works
on
this
specific
buffer,
it
knows
this
is
the
only
execution
of
this
function.
On
this
specific
piece
of
data
and
again
coming
back
to
what
I
said
before
this
is
this
is
the
crucial
part
of
the
concurrency
and
safety
checking
of
rust.
And
if
you
take
this
piece
of
code,
I
can
highly
recommend
doing
that
as
an
exercise.
If
you
take
this
piece
of
code
and
then
have
a
look
at
the
tokyo
api,
you
will
see.
Tokyo
also
has
tcp
stream.
A
A
A
Our
collections
themselves,
let's
say
no
so
standard
lip
collections
and
rust-
are
not
by
themselves
thread
safe,
and
you
would
need
to
use
these
kind
of
things.
But
rust
knows
that
they're
not
thread
safe,
so
they
are
safe
to
use,
and
this
is
exactly
what
it
what
it
has
figured
out
when
I
was
trying
to
pass.
If,
if
it
were
thread
safe,
it
would
not
have
complained
the
moment
where
I'm
passing
it
over
through
an
arc
and
would
try
and
would
try
to
mutate
it
in
a
way.
A
A
A
That
is,
takes
a
little
bit
of
a
more
complex
protocol.
That
looks
a
lot
like
the
redis
protocol,
so
it
also
has
a
library,
as
a
protocol
browser
it's
written
using
async
stud,
but
given
that
the
interface
of
async,
state
and
tokyo
have
moves
very
closely
to
each
other,
you
can
basically
just
go
and
remove
async
stud,
replace
it
by
tokund
and
use
it
as
tokyo
and
greetings
to
germany
yeah.
A
A
First,
okay,
oh
and
because
it's
so
quick
to
answer
frank
yeah.
That
was
that
was
the
thing
that
I
had
hinted
at
there's
a
type
in
rust
that
is
instead
of
mudex,
it's
called
rw
lock,
which
works
the
same
as
mutex.
It
wraps
the
data,
but
it
has
two
functions.
One
read
and
one
right
where
you
request
the
kind
of
locking
that
you
that
you
need.
A
Okay,
thank
you
all
for
attending
the
session,
seen
more
than
100
listeners
and
number
has
dropped.
So
thank
you
and
see
you
soon.
If
you
have
any
further
questions
I'll
be
in
slack,
please
feel
free
to
ping
me.
I
may
need
some
time
to
answer
and
but
I'll
I'll
be
going
through.
All
the
questions
you
sent
me.