►
Description
This presentation was recorded at GOTO Amsterdam 2019. #GOTOcon #GOTOams
http://gotoams.nl
Florian Gilcher - Founder of Ferrous Systems, Music Addict, Rubyist, Rust Trainer & Backend Programmer
ABSTRACT
2018 has seen a massive push towards improving Rust's usability. This comes both with ergonomics improvements, but also with stabilisation of a lot of use-case specific features.
Rust is now usable and is used on everything from bare metal microcontrollers over small IoT gateway systems up to server programming. It can be deployed on phones just as it can be deployed in your web browser through Webassembly (WASM). That makes the newest edition of Rust the only currently available memory-safe language that can be used in almost any contexts without the need of a runtime.
This talk gives you a tour of what is possible with just one language and just one compiler right now.
Finally, Rust 2018 includes a lot of ergonomics improvements like a better async/await-story and cleverer safety [...]
Download slides and read the full abstract here:
https://gotoams.nl/2019/sessions/751
RECOMMENDED BOOKS
Tim McNamara • Rust in Action • https://amzn.to/3ux2R9u
Blandy, Orendorff & Tindall • Programming Rust • https://amzn.to/3x7r6w6
Ken Youens-Clark • Command-Line Rust • https://amzn.to/3PQZ539
Kevin Hoffman • Programming WebAssembly with Rust • https://amzn.to/3x3brhe
https://twitter.com/GOTOamst
https://www.facebook.com/GOTOConference
https://www.linkedin.com/company/goto-
http://gotocon.com
#Rustlang #IoT #WebAssembly #WASM #Rust #Programming #ProgrammingLanguage #SoftwareEngineering #Mozilla #Coding #FP #FunctionalProgramming
Looking for a unique learning experience?
Attend the next GOTO Conference near you! Get your ticket at http://gotocon.com
SUBSCRIBE TO OUR CHANNEL - new videos posted almost daily.
https://www.youtube.com/user/GotoConferences/?sub_confirmation=1
A
Thank
you
everyone,
so
my
talk
is
called
roast
access
all
areas,
because
one
of
the
big
movements
for
the
language
last
last
year
was
we
actually
finalized
the
ability
to
deploy
rust
on
basically
any
target.
Theoretically
talk
about
the
practice
in
a
second
but
first
of
all,
I
have
a
word
about
doing
off,
strong
who
was
mentioned
this
morning,
because
he
has
been
very
important
for
me.
A
Sometimes
you
have
to
invent
a
language
for
that,
and
Russ
comes
pretty
much
out
of
the
same
way
that
if
we
want
to
solve
a
couple
of
fundamental
problems,
we
need
to
invent
a
new
language
for
that.
Instead
of
trying
to
paper
over
in
the
languages
that
we
have
so
who
you're
mine,
I'm
florian,
you
can
find
me
on
twitter
and
on
get
up,
I
have
two
companies,
one
that
runs
infrastructure
and
another
one.
That's
called
ferry
systems,
which
is
rust,
consultancy,
I
am
a
rust
programmer
and
trainer.
A
You
can
find
me
on
rust
experts,
I'm
also
a
mozillian.
Sometimes
people
think
because
of
my
activity
in
the
rust
project.
I
am
employed
at
Mozilla,
that's
not
the
case,
but
people
who
are
closely
aligned
with
Mozilla's
mission,
I,
usually
called
millions
previously
I
did
ten
years
of
ruby
community
work.
So
there
was
a
point
where
people
stopped
referring
to
me
as
the
Ruby
person
in
Berlin
and
then
moved
to
hey,
that's
rust,
florian
I
personally
started
learning
rust
in
2013,
mostly
out
of
curiosity,
it
was
a
new
language.
A
It
was
still
in
research,
work
and
I
co-founded.
The
Berlin
user
group
I
then
started
organizing
two
of
the
larger
stress
conferences,
rust,
fest
and
oxidized
conf
witches
and
focused
on
embedded
hardware
and
I'm
a
project
member
since
2015.
Most
of
the
time,
the
community
team
recently
I
started
leading
the
website
team
I'm
now
in
the
core
team
as
well
and
I've
got
a
quick
question
to
the
room
who
here
has
been
exposed
to
rust?
Who
has?
Okay?
A
Not
so
many
people,
because
I'm
going
to
give
you
a
detail
of
an
explanation
of
what
it
is.
Also
I
have
a
couple
of
endorsements.
I
gave
a
talk
about
rust,
I'd
go
to
2017
and
the
best
YouTube
comment
is
I.
Don't
trust
any
programmer
that
deliberately
uses
Ruby
and
Java
I?
Guess
I
still
use
Ruby
and
Java
for
great
effect.
So
please,
if
you
don't
immediately
start
using
rust.
A
So
what
is
rust?
Our
current
claim
is
it's
a
language
empowering
everyone
to
build
reliable
and
efficient
software
before
the
2018
release.
We
said
well,
these
three
things
that
are
important
about
rust.
First
of
all,
the
language
is
safe.
Second,
it's
concurrent,
but
it's
fast.
The
problem
with
that
is
those
are
the
language
level
concerns
also.
What
is
safe
is
something
that
people
can
have
long
twitter
fights
about,
and
we
changed
that
nowadays
we
say
the
three
important
parts
of
rust
are
performance,
reliability
and
productivity.
A
A
Big
data
applications,
databases,
so
it
must
provide
high
abstractions
and
low
abstractions,
also
very
cheap
abstractions.
They
must
be
useful,
but
they
must
all
to
be
picked
through,
because
if
we
want
to
work
close
to
the
hardware,
we
sometimes
need
to
rip
them
open
and
work
with
what
we
have
on
the
inside
and
they
should
cost
nothing.
The
problem
with
the
thing
that's
called
zero
cost
abstraction
is,
if
you're
talking
about
a
zero
cost
abstraction.
What
we
mean
is
you
couldn't
hand
code
it
better
yourself.
A
We
built
you
an
abstraction
that
does
the
thing
that
is
the
most
efficient.
If
the
abstraction
does
not
do
exactly
what
you
need.
In
that
case,
it
might
still
cost
you
something.
So
maybe
another
approach
is
better
but
also
economics
in
care.
We
have
a
unified
tooling
for
all
of
those
targets.
We
have
extense
extensible
tooling.
So
if
you
need
something
for
a
specific
use
case,
you
can
plug
into
the
current
tooling
and
make
it
do
what
you
want
and
we
have
a
very
strict
backwards
compatibility
strategy.
A
So
the
program
problems
to
solve
that
I
want
to
talk
about,
is
memory,
safety
and
the
stock
resource,
consumption,
resource
handling,
concurrency
and
parallelism
dealing
with
external
data
resilience
and
integration
into
existing
code.
Let's
get
started,
the
talk
has
in
the
title:
rust,
2018
access
all
areas
so
just
quickly
clear
up
what
rosters
an
ad
is
it's
a
new
language
profile
to
enable
all
of
the
above.
We
shipped
it
in
December
2018.
It
was
not
a
breaking
change.
The
rust
compiler
still
understands
old
rust
and
you
can
mix
and
match
libraries.
A
Rust
in
itself
is
a
c
and
c++
competitor
as
a
language
itself,
at
lands
somewhere
in
the
middle
that
aesthetically
memories
safe,
and
it
has
features
that
also
make
it
compatible
competitive
with
higher-level
languages
like
Scala,
Java
or,
for
example,
also
go
from
its
model
itself.
Rust
is
a
native
programming
language.
It's
a
values
and
function,
language
much
like
C
is,
and
it
comes
with
no
notable
runtime,
so
it
has
no
active
runtime.
A
It
has
no
garbage
collector
everything
that
I
present
in
this
talk
is
actually
being
resolved
by
the
compiler
at
compile
time
and
not
during
runtime.
Still,
it
is
memory
safe.
So
it
looks
a
little
bit
like
a
garbage
collector
language.
It
is
a
generic
language.
I
wouldn't
introduce
that
I
assume
everyone
here
was
exposed
to
Java
and
I
won't
go
into
higher
detail
and
that
we
use
the
same
syntax,
so
it
should
be
kind
of
natural.
It
has
detailed
error
handling
at
no
catchable
exceptions.
It's
a
very,
very
detailed
language,
it's
kind
of
like
what.
A
If
we
had
a
language,
that's
a
nitpicker,
but
in
a
good
way
we
usually
call
the
compiler
complainer.
We
might
also
call
it
an
Iron
Maiden.
So
let's
look
at
the
code
example
quickly.
So
he
said
rust
is
a
structures
and
functions
language.
So
we
have
a
data
structure
here
with
two
integers
inside
exactly
32
bits,
so
I
know
the
size
of
it
in
memory.
So
I
can
talk
in
rust
about
a
directly
about
memory.
Layout
I
can
just
construct
it.
I
can
allocate
it
on
the
heap
that
works
in
rust
by
a
special
type.
A
A
All
of
that
memory
and
then
quits
the
program
and
that
works
through
a
system
called
ownership
and
a
value
introduced
and
harrassed
program
is
exclusively
owned
and
this
ownership
can
be
moved
so,
for
example,
I
can't
capacit
into
a
function,
but
if,
for
any
reason,
this
value
runs
out
of
scope,
it
is
dropped
and
this
moment
is
clearly
defined.
The
moment
is
exactly
here,
because
that's
the
end
of
the
scope.
A
That's
the
moment
that
the
allocation
happens,
so
there's
no
garbage
collection
happening
that
might
defer
that
it
will
actually
happen
at
that
point
and
that
can
be
used
for
great
effect.
One
of
the
misunderstandings
about
ownership
is
that
it's
just
for
memory
handling.
It
is
actually
very,
very
useful
for
any
kind
of
resource
handling.
So
all
rust
values
have
a
trackable
region
memory
where
they
active,
and
that
means
they
can
be
used
for
resource
management,
because
I
know
when
they
become
inactive
and
ownership
manages
resources.
A
Memory
is
always
one
of
them,
but
it
doesn't
have
to
be
one
example
for
that
is
file.
So
if
I
have
a
function
that
reads
a
file
I
just
pass
it
as
a
path
and
I
get
a
string
back,
which
is
the
contents
of
the
file
I'm
talking
about
that
resulting
in
a
second
I
open
the
file
and
because
I
don't
return
the
file
I,
actually
don't
do
anything
after
reading
it.
The
file
will
automatically
be
closed
and
that's
kind
of
this
resource
handling
semantics,
because
I
can
attach
to
a
file
pointer.
A
Oh
if
it
runs
out
of
scope,
also
called
closed
on
it.
The
question
mark
here
is
our
error
handling
operator
just
quickly
about
that
result.
Rust
has
no
exceptions.
What
we
use
is
we
use
a
result,
type
that
has
in
something
that
we
call
an
enum.
It
has
two
so-called
variants:
okay,
an
error
which
signal
the
thing
that
you
want
to
do
worked
or
it
didn't,
and
if
it
returned
one
of
them
from
a
function,
I
actually
asked
the
caller
to
before
actually
handling
the
data.
A
Checking
hey,
was
it
okay
or
do
you
actually
have
to
handle
an
error?
So
results
are
plain
data
like,
for
example,
also
in
go
or
other
languages.
What
it
dis
allows
me
to
do
if
I
have
another
function.
The
implementation
is
pretty
unimportant.
That's
print
file
and
close,
but
the
important
thing
is:
it
takes
a
file
reads
it
fully
and
because
it
lets
a
drop
out
of
scope,
it
closes
it.
So
what
happens
if
I
try
to
furcal
this
function
twice
on
a
file?
A
What
happens
is
I
get
an
error.
What
it
tells
me
is,
oh,
you
moved
ownership.
You
call
the
function
on
this
piece
of
data,
gave
away
ownership
and
then
you're
trying
to
call
it
again
that
doesn't
work
because
you
don't
own
it
anymore,
practically
speaking.
What
it
just
made
sure
is
that
the
second
time
I
call
the
I
call
this
function.
It
actually
gets
a
valid
file
pointer
if
I
wouldn't
do
that.
The
first
call
to
it
would
succeed
because
it
can
actually
read
from
that
file.
A
So
they
don't
forget,
closing
files
and
having
dangling
fine
boil
five
points
around
that
can
be
circumvented,
because
what
I
can
do
is
that
can
somehow
because
Ruby
is
a
garbage
collected
language,
so
I
can
take
any
amount
of
references
on
any
kind
of
data.
So
what
I
can
do
is
I
can
do
file
open
and
intend
say:
I
want
an
iterator
over
each
line
of
the
file,
return
that
and
oops
that
doesn't
work,
because
the
definition
of
that
closure
was
once
the
closure
ends.
A
You
close
the
file
and
then
I'm
trying
to
read
from
it
bang.
This
is
obviously
a
simple
example.
No
one
would
write
that,
but
slice
only
have
so
much
space.
That's
also
the
annoying
part
of
it.
If
you
run
into
such
a
bug,
it's
usually
a
1,000
line
code
base
and
then
it's
hard
to
figure
out
where
you
had
accidentally
closed
it.
So
what
happened?
We're
referencing
through
the
file
through
to
the
file
through
an
iterator,
we
moved
the
iterator
out
of
scope.
The
file
was
closed.
We
try
to
iterate
back.
A
Let's
try
that
in
rust
we
can
have
a
look
at
the
book
and
it
says
hello.
Rust
has
references
and
we
can
try
to
also
get
a
similar
situation
where
we
set
up
a
reader
that
references
the
file.
This
is
the
referencing
operator.
Ampersand
moot
is
a
special
kind
of
reference
to
which
it
can
actually
mutate.
The
end
I
come
to
that,
and
so
you
open
that
bufferedreader
and
then
I'm
returning
the
reader.
A
A
A
References
cannot
outlive
what
they
borrowed
from
so
I
always
have
to
reference
valid
memory
and
mutable
and
immutable
references
cannot
alia,
so
I
showed
the
m
%
loot
there's
also
the
ampersand
reference
which
doesn't
allow
me
to
mutate
through
it,
and
the
important
thing
is:
if
you
have
a
mutable
reference
in
rust,
you
can
also
be
guaranteed
that
it's,
the
only
one
everywhere
in
the
program.
So
if
you
have
a
mutable
reference,
there's
no
other
part
of
the
program
that
can
actually
currently
even
read
that
memory
references
are
always
valid.
A
Much
like
in
C++,
and
the
interesting
notion
here
is
mutable
state
and
rust
is
allowed.
Shared
state
in
rust
is
also
allowed,
but
shape.
Mutable
state
is
not
allowed
and
that's
the
problem
that
we're
usually
running
into
in
parallelism
and
concurrency,
and
we're
also
seeing
a
thing
here.
Talking
about
illegal
States
files
and
rust
are
defined
in
such
a
way
that
they
are
always
open.
If
you
have
a
file
type,
it's
always
open,
so
rust
gives
you
methods
to
make
illegal
states
it
representable.
Even
if
you
want
the
file
API,
that
represents
both
open
closed.
A
So
how
do
we
get
out
of
that?
It's
actually
pretty
simple.
We
changed
this.
It
used
to
be
a
moot
file
here.
We
change
this
to
file
and
don't
reference
the
file.
What
happens
then?
The
bufferedreader
takes
ownership
of
the
file
reps.
It
builds
a
buffer
around
it
and
then
I
can
both
pass
both
back
from
it
and
then
I
can,
for
example,
iterate
over
the
lines
print
them
out
with
line
numbers
or
whatever.
So
pretty
often
in
rust.
A
A
That's
important
here:
bufferedreader
now
owns
the
file,
so
it's
also
the
unique
owner
of
the
file.
So
it
can
also
be
sure
that
no
one
else
is
currently
referencing
the
file
mutating
it
writing
to
it
or
whatever,
and
that's
a
thing
that
happens
pretty
often
in
rust.
There's
a
lot
of
API
is
that
come
in
three
things:
owned
borrowed
mutiply
borrowed.
These
are
the
three
things
that
you
hear
most
about.
A
For
example,
if
you
talk
about
iterators,
pretty
simple
concept:
I
have
a
collection,
in
this
case
a
vector,
1,
2,
3
and
I
want
to
iterate
over
it
and
there's
three
ways
of
actually
doing
it,
which
is
first
of
all
the
owned
iterator,
we're
still
which
again
closes
over
the
collection.
You
completely
forget
what
collection
it
was.
The
only
thing
you
get
out
is
I
can
iterate
over
it
and
then
you
iterate
over
it,
and
once
the
iterator
drops
everything
they
all
the
data
that
it
closed
over
actually
drops
as
well.
A
This
is
what
it
means
to
take
ownership.
If
it
just
call,
eater
I
will
get
the
immutable
borrowing
iterators,
so
I
can
borrow
I
can
I
can
iterate
over
that
lecture
as
much
as
I
want?
I
can
actually
get
an
infinite
number
of
these
iterators
at
the
same
time,
because
they
can
all
be
sure
that
the
data
is
not
being
manipulated
and
keeps
at
the
same
length
and
everything
and
I
also
have
a
mutable
iterator
or
it
can
iterate
over
and
a
plus
1
to
each
of
those
numbers
or
whatever
and
they're.
A
The
guarantee
applies
that
if
I
have
this
iterator
I
know
that
I
can
mutate
the
collection,
but
no
one
else
can
see
it.
So
there
is
no
sharing
of
this
mutable
state
at
that
moment.
So
before
that,
if
I
had
immutable
references
or
immutable
iterators,
active
I
would
have
to
remove
them
all
before
actually
starting
with
us,
and
this
relates
nicely
to
parallel
processing.
So
we
have
quite
a
number
of
great
frameworks
for
parallel
programming
that
also
work
on
very,
very
small
devices.
A
They
are
mixable
with
concurrent
approaches,
so
we
do
allow
parallel
and
concurrent
programming
in
the
same
language,
but
all
that
is
safe
from
data
races,
because
data
races
happen
in
the
moment
where
I
can
observe
someone
manipulating
the
memory.
Basically,
the
problem
is
I
have
an
immutable
reference,
I
read
it,
someone
manipulates
it
and
then
I
read
it
again
and
it's
something
different,
but
I
have
an
immutable
reference.
What's
that,
like
the
guarantee
of
an
immutable
reference
in
rust,
is
the
value
that
you're
that
you're
referencing
will
never
change?
A
Why
you
have
that
reference
and
just
to
show
how
this
works?
This
is
again
the
iterator
API
I
have
another
collection
of
I-32
32-bit
integers
I
just
want
to
sum
them
all
up,
I
want
to
square
them,
and
then
sum
them
all
up.
If
I
want
to
do
this
in
parallel,
there's
actually
a
library
that
allows
me
to
just
say
this:
iterator
is
now
parallel
put
it
on
a
thread
pool
start
running
it.
It's
kind
of
boring,
isn't
it.
It
also
gives
a
couple
of
additional
options
like
this.
A
Is
the
convenience
option,
with
a
background
thread
pool
where
it
will
just
be
applied
to
you
can
also
say,
I
want
a
specific
thread
pool
to
be
used
or
whatever,
so
you
always
got
the
option
to
move
out
of
those
defaults,
but
other
than
that.
That's
currently
yet
I
get
to
another
detail
of
that
in
a
second.
But
currently,
if
you
want
to
parallelize
Rusco,
that's
very
easy.
Api
is
to
do
that.
A
There's
two
large
libraries
for
doing
that.
If
you
ever
want
to
do,
but
if
that's
the
way
you
want
to
get
started
with
rust-eze
cross
beam
and
raion
cross
beam
are
all
the
base
types
that
you
want
for
for
any
kind
of
parallel
processing.
Several
several
methods
for
mutex,
a
offense
and
whatever
wet
pools.
Rayon
is
the
library
that
provides
these
parallel
iterators
quickly
and
easily.
A
If
you
talk
about
concurrent
programming,
that
is
things
like
Erlang
does
it
or,
for
example,
no
GS,
so
you
have
an
event
reactor
potentially
on
a
single
thread
or
on
multiple
threads,
where
you
don't
have
web-based
scheduling,
but
actually
a
cooperative
scheduling
between
all
the
units.
We
have
that
as
well
also
a
mixable
with
parallel
approaches,
the
other
way
around
works
as
well,
also
safe
from
data
races.
A
What
rust
allows
you
to
model
is,
if
you
have
any
kind
of
concurrent
unit,
say
thread
a
task
on
the
event
reactor
or
whatever
it
allows
you
to
model
which
part
currently
owns
what
data
and
that
works.
Independent
of
the
concurrency
of
probably
parallelism
implementation
that
you're
currently
using
I'll
show
how
that
works
in
a
second.
A
Currently
concurrent
programming
in
rust
looks
like
this,
because
it's
completely
based
on
standard
rust,
API
and
anyone
here
doing
JavaScript
was
promises,
yeah,
basically
the
same
problem,
so
we
have,
we
have
a
futures
type
or
a
promises
type,
but
the
only
thing
we
currently
have
is
methods
on
it
to
combine
them.
So,
actually,
each
of
these
things
in
for
each
be
to
end-
and
also
here,
are
small
concurrent
subunits
and
you
need
to
know
the
actual
names
of
what
of
these
things
are
concurrent
actions
to
understand
what
they
do.
A
Also,
you
need
to
use
these
kind
of
combinators
to
combine
them
in
the
right
way
that
works,
it's
verbose
and
very
error-prone,
which
is
actually
what
we
are
removing
that
or
we're
moving
towards
an
async
of
eight
syntax,
much
like
script
hazard.
So
you
have
a
look
at
this.
You
have
this
for
each
Combinator
that
takes
a
function
that
has
a
specific
behavior
how
for
each
works?
A
This
is
actually
going
to
be
replaced
by
a
while
loop
that
just
waits
on
like
this
is
a
small
TCP
server.
What
it
does
is
for
every
incoming
connection
or
for
the
incoming
connections
always
take
the
next
one
and
wait
for
the
next
one.
That's
the
operation
that
it's
doing
here
and
explicitly
spawn
of
every
connection
handling
as
a
second
task
or
as
a
as
another
task
on
our
current
event
reactor.
A
You
don't
need
to
understand
the
full
density
of
it.
It's
just
having
a
special
syntax
for
this
use
case,
makes
code
much
much
easier
to
read
the
interesting
thing
about
the
async/await
syntax
again
is
you
can
pick
the
concurrency
pattern
that
you're
using
and
the
nice
thing
about
being
able
to
pick
the
concurrency
pattern,
and
especially
implementation
is
that
you
can
choose
the
one:
that's
right
for
the
device
that
you're
currently
working
on
an
event
reactor.
That's
working
on
a
server
can
just
waste
a
couple
of
megabytes
of
memory.
A
You
don't
care
and
just
for
performance
reasons,
something
that
needs
to
work
on
a
small
device.
Most
obviously
use
an
implementation.
That's
much
much
simpler.
The
async/await
syntax
in
itself
comes
with
no
actual
cost.
The
only
thing
that
comes
with
the
cost
is
the
actual
reactor
that
you
need,
that
you
need
to
use
to
drive
it
and
that's
pretty
unique
that
we
have
a
syntax,
that's
independent
of
the
library
implementation
that
you're
using.
So
you
wouldn't
need
to
replace
the
runtime
system
or
you
wouldn't
need
to
replace.
A
It
have
been
the
rust
implementation
that
you're,
using
what
you
replace
is
I,
choose
different
library
from
our
our
library
host
and
then
just
use
that
one
instead
there's
a
couple
of
libraries
ran
this
the
most
prolific
one
currently
being
active
and
actives
web
act
is
an
actor
framework.
Much
like
our
lang
is
an
activist
web
is
a
web
framework
implemented
in
it.
A
Every
value
in
rust
has
two
additional
properties
and
those
are
send,
and
sync
sin
means
the
data
can
be
passed
between
concurrent
units.
That's
much
like
I
could
take
a
piece
of
data
and
can
send
it
to
another
thread.
The
first
thread
will
not
have
it
anymore,
the
other
one
have
it
and
suit
means
I
can
pass
it
between
concurrent
units
and
both
properties
are
independent
of
power
or
the
parallelism
and
the
concurrency
library
news.
A
A
The
problem
is
because
counting
on
a
processor
is
I,
read
the
data,
I
manipulate
it
and
I've.
Read
it
again
to
memory
there
might
be
a
race
condition,
so
programming
is
or
multiplayer.
Programming
is
one
of
the
only
ways
to
actually
make
1
+
1
+
1
B
2-
and
this
is
what
happens
here.
Luckily,
Roz
compiler
actually
tells
me
that
that
doesn't
work
in
this
case
in
the
initial
case
tells
me
what
the
thread
expects.
It
actually
wants
to
take
ownership
of
all
the
data.
A
Now
the
problem
is
I
can
only
pass
on
ownership
once,
but
I
want
to
throw
this
boundary
that
doesn't
work.
It
actually
tells
me
here
value
moved
into
closure
here
in
previous
iteration
of
the
loop,
so
it
understands
that
we
iterate
multiple
times,
and
it
knows
that
the
first
time
calling
that's
born
the
values
already
gone.
A
So
what
I
need
is
actually
multiple
ownership
and
Russ
provides
ways
of
doing
that
through
smart
pointers,
much
like
in
C++
or
other
languages
and
and
a
standard,
smart
pointer
and
Russ
is
the
rev
counter.
If
I
want
ref,
counting
I
can
have
ref,
counting
I
can
construct
a
ref
counted
pointer
around
a
piece
of
data.
This
is
the
API
how
I
get
a
new
handle
on
that
ref
counter.
So
I
get
a
second
reference
and
then
that's
right
also
doesn't
work.
Why?
A
Because
the
standard
ref
Condor
in
rust
is
actually
not
synchronized,
so
I
might
have
the
same
problem
just
on
the
reference
count.
Instead
of
the
actual
data
that
I'm
pointing
to
but
Russ
detects,
that
tells
me
it
cannot
be
sent
between
threads
safely
because
it's
not
sent
that's
where
that
property
comes
from
okay,
let's
stick
a
little
bit
more
through
the
API
and
figure
out.
If
there's
a
sunt
ref
counter.
Yes,
there's
a
sink
ref
counter,
which
is
the
AR,
see
the
atomic
ref
counter.
A
Let's
try
that
same
API
doesn't
work.
Can
it
assign
data
to
an
m
%
reference?
What's
the
problem,
the
problem
is
I
have
multiple
access
points
to
that
data
through
the
AR
C
and
then
the
borrowing
rule
applies
again.
You
cannot
get
a
mutable
reference
out
of
that
because
there
might
be
other
people
watching.
A
So
the
last
thing
I
need
is
mutex,
because
the
mutex
does
exactly
that
that
moderation.
It
makes
sure
that
there's
always
ever
one
part
of
the
program
currently
holding
a
mutable
reference
that
works.
And,
interestingly,
if
you
lock
a
mutex
to
get
back,
is
something
called
a
mutex
card
which
we
presents
hey.
You
have
currently
locked
the
mutex
and
that
one
again
as
no
empathy
R
is
handled
through
ownership.
That
means
I
don't
actually
have
to
think
because
it's
a
resource,
yeah,
your
luck
is
a
resource,
so
I
take
a
lock
and
I.
A
A
Let's
move
on
to
a
little
more
practical
examples,
so
Russ
is
used
for
actually
a
lot
of
CLI
programs.
Anyone
here
using
BS
code,
you
ever
use
the
search
function
you
using
a
Russ
program.
It's
there's
a
certain
sub
community
of
the
Russ
community
that
wants
to
make
string
processing
as
fast
as
possible,
and
this
a
lot
a
lot
of
outcome
coming
in
these
kind
of
areas.
A
So
the
nice
thing
about
writing.
Cli
programs
in
rust
is
similar
to,
for
example,
if
you
write
them
and
go
there
shippable
without
having
people
to
install
a
runtime
pison
to
seven
or
whatever
its
memory,
conserving
with
a
very
a
fast
startup
time,
because
it
doesn't
come
with
a
runtime.
These
libraries
for
a
fast
and
convenient
part
is
pretty
often
CLI
programs
I
used
too
much
to
CSV
files,
JSON
files
whatever,
and
you
have
a
free
choice
of
concurrency
patterns.
A
If
you
want
to
interact
with
a
with
an
API
in
the
backend,
probably
you
want
a
single
if
you
just
want
to
churn
through
a
lot
of
data
quickly,
you
probably
want
a
third
Pole
and
ownership
makes
this.
It
still.
Resource
management
hang
around
those
files,
making
sure
that,
for
example,
all
your
all
your
back-end
requests
appropriately
closed
and
whatever
pretty
easy.
A
But
this
also
convenience
is
the
Russ
program.
Language
provide
you,
which
is,
it
has
ways
to
allow
for
structured
cogeneration.
So,
for
example,
this
here
is
a
struct,
but
through
a
library
called
struck
top.
We
turn
it
into
the
definition
of
our
CLI
interface.
What
the
derive
does
it
looks
at
the
struct
and
says
uh-huh.
There's
a
command-line
argument
called
pattern.
It
has
to
be
a
string.
It
has
to
be
present
because
there's
no
null
in
rust,
so
that
one
has
to
be
there.
This
year
is
a
past
buff.
How
do
you
get
a
past?
A
A
The
same
thing
is
used
for
serialization
and
deserialization.
There's
a
serialization
and
deserialization
from
serialization
framework
called
30,
which
we
can
use
in
much
the
same
way.
We
can
say
we
have
a
point
XY.
We
want
to
be
abitt,
serializable
and
e
serializable,
and
then
we
can
actually
choose
the
format
we
want
to
see,
relies
and
deserialize
at
that's
independent
of
this
machinery.
Here-
and
here
we
say
we
want
to
see
you
lies
it
into
jason
and
back.
A
The
nice
thing
here
is
this:
can
error
like
reading
a
json
file
that
might
be
incomplete,
might
have
additional
fields
might
have
less
fields,
and
so
they
it's
there's,
always
a
result
coming
back,
so
you
need
to
check
if
that
was
actually
with
other
data,
so
it
uses
the
type
system
to
understand.
Well,
did
I
even
get
a
valid
JSON
file
here
all
that
can
be
configured
just
to
be
clear.
So
what
do
you
do
if
ax
isn't
present
in
this
case?
A
A
The
first
place
to
go
to
if
I
want
to
go
smaller
is
usually
embedded
Linux,
my
router,
my
IOT
gateway
and
Industry
control
system.
We
have
seen
what's
there,
it's
people
talking
about
putting
it
on
cars,
and
people
researching
on
that
so
embedded
Linux
is
at
all
the
places.
There's
always
the
conversation.
If
embedded
Linux
a
lot
of
people,
don't
consider
embedded
Linux
kind
of
embedded
because
it's
a
full-blown
operating
system.
Still
it
has
a
lot
of
the
it
brings
you
into
a
lot
of
the
problems
that
start
with
smaller
devices.
A
The
first
one
is
cross,
compiling,
what's
compiling,
isn't
actually
a
language
concern,
it
is
the
language
concern
in
the
sense
that
our
standard
lip
is
written
in
a
way
that
we
want
to
make
sure
that
we
can
support
as
many
targets
as
possible
and
if
the
standard
lip
can't
support
it,
you
can
at
least
slice
it
in
pieces
where
you
can,
for
example,
support
parts
of
it.
So,
for
example,
our
memory
allocation
library
is
also
available
as
a
single
library,
but
the
process
itself
is
easy.
A
We
give
you
appropriate,
tooling
and
all
tooling
and
rust
is
aware
that
something
like
cross
compiling
happens.
Russ
stop
is
a
tool
that
we
use
to
manage,
what's
compilers
and
choose
the
version
that
you
want
to
have,
and
but
it's
not
just
a
version
switcher.
It
also,
for
example,
manages
targets
for
you,
so
if
I
want
to
compile
for
a
Arch
Linux
with
a
muzzle
Lipsy,
I
can
just
download
that
from
actually
our
projects
hosts
and
use
cargo,
which
is
a
build
tool
to
build
whatever
we
have
over
to
one
of
those
targets.
A
I
need
the
platform
linker
and
Lipsy
available,
which
is
usually,
if
I,
for
example,
compile
to
was
wrt.
I
need
to
have
the
open,
wrt
SDK
in
my
path
and
I
need
to
make
sure
that
that
is
there
still
from
our
side.
The
tooling
is
as
complete
as
possible
and
further
down
the
stack
last
year,
we
finally
unlocked
running
rust
with
all
of
those
features
that
I
just
shown
on
bare
metal
embedded
so
tiny
devices
in
RF
controllers
and
all
of
these.
So
that
meant
a
lot
of
the
stabilization
of
all
lower
level
details.
A
Replaceable,
error
handlers.
How
is
the
main
function
called
I
used
that
main
function
all
the
time,
but
what's
around
the
main
function?
What
happens
when
the
program
quits
most
people,
don't
care
people
on
bare
metal
devices
actually
care.
So
it
gives
you
great
support
for
all
of
these
safe
patterns
on
embedded
devices.
It
relies
on
the
existing
tooling.
It
should
be
considered
young
but
solid,
like
it
is
done.
We
have
backwards
compatibility
now,
so
we
can
start
writing
libraries.
This
is
what
it
looks
like
if
you
just
want
a
simple
program.
A
The
important
thing
here
is:
it
is
a
no
main
program,
so
it
actually
doesn't
have
a
main
function.
We're
gonna
write
that
all
ourselves,
it
doesn't
use
the
standard
lead.
It
uses
an
external
crate
for,
in
this
case
supporting
cortex-m
processors.
The
RT
is
this:
is
the
runtime
for
a
cortex-m
processor,
so
we
won't
actually
boot
and
finish
the
processor
if
you
want
to-
and
it
writes
at
the
main
function
and
marks
this
as
entry
here
we're
using
cogeneration
again
through
this
attribute
to
actually
set
up
do
the
set
up
off.
A
A
Let's
keep
that,
but
we're
still
using
Rustom
antics
there,
and
especially
the
embedded
working
group,
has
come
up
with
a
lot
of
interesting
usages
off,
for
example,
mapping
a
device
access
to
ownership,
because
I
have
the
same
problem
again.
I
don't
want
to
the
two
parts
of
the
program
to
use
the
same
port
at
the
same
time.
That's
an
ownership
problem.
I
want
unique
ownership.
A
It
uses
these
metaprogramming
facilities
that
we
provide
for
convenience
like
being
able
to
mark
and
function
as
an
entry
point
and
then
having
all
the
code
around
it
be
generated,
but
have
that
pluggable,
if
I
ever
want
to
replace
that
the
resulting
code,
just
to
be
clear,
is
board
specific
in
this
case.
So
this
needs
to
run
on
an
cortex-m
your
options.
There.
A
The
final
thing
that's
missing,
for
that
is
rust,
can
use
can
be
used
to
interact
with
C
and
C++,
just
if
it
were
C.
So,
for
example,
you
can
generate
static
and
dynamic
libraries
which
provide
you,
punctual
speed-up
of
larger
programs,
or,
if
you
have
a
device
driver,
that's
in
C
that
you
don't
want
to
rewrite
in
rust.
You
can
just
call
into
that
device
driver
and
use
that
one.
A
A
Basically,
what
it
ends
up
with
is
we
can
generate
libraries
that
externally
look
like
they
are
C
library,
and
then
you
reuse
all
the
facilities
that
we
have.
So,
for
example,
this
is
a
piece
of
Ruby
code
that
would
use
the
previews
library
as
the
dynamic
library
just
loaded
and
allocate
data
allocate
data
through
that
library.
Instead,
so
we
can
use
rust
as
a
memory
safe,
C
replacement.
A
So,
in
the
cases
where
you
would
usually
simple
use
the
dynamic
language
then
say
well,
we
would
write
rewrite
it
and
see
if
it
becomes
slow,
but
then
you
suddenly,
through
all
the
memories
safety
that
I
made
emmaandemma
clang,
which
gives
you
out
of
the
window
if
you
use
rust.
Instead,
that
works
as
well
this
generators
for
that.
So,
if
you
don't
want
to
handwrite
all
of
these,
you
can
use
generators
for
going
from
rust
program
to
C
header
from
a
C
header
to
rust
bindings.
A
They
specialized
tools
just
for
Python,
Ruby
and
node,
to
make
this
conversation
less
rote
and
actually
just
auto-generated
can
also
use
a
rust
program
to,
for
example,
composite
of
Awesome
because
of
time
are
actually
not
going
to
talk
about,
was
omits
pretty
much
the
same.
It's
a
shared
library
by
a
different
name
can
talk
to
me
about
that
later.
A
What's
missing,
especially
when
we're
talking
about
bare
metal
is
safety
critical
use
cases,
we
have
currently
no
certified
compiler,
but
we
have
recently
started
a
project
called
sealed
rust
that
attempts
to
bring
certification
of
rust
on
track,
the
problem
being
the
language
moves
forward.
So
we
need
to
at
some
point
decide:
okay,
we're
going
to
take
a
little
piece
of
that
or
going
to
take
the
current
version
and
try
to
get
it
certified
and
actually
keep
it
stable
and
supported
for
users
that
actually
need
that
what
we
got
that
on
track,
that's
a
multi
yeah!
A
A
Let's
go
back
to
these
claims
of
performance,
and
so
we
have
a
language,
that's
as
fast
as
C
and
C++,
with
safety
while
doing
the
fasting
and
abstractions
with
almost
no
overhead
or
no
overhead,
but
also
a
language
that
cares
about
reliability
by
letting
you
express
abstract
concepts,
making
making
illegal
states
inexpressible
and
with
type
level
support
for
resource
management
and
for
productivity.
We
have
great
tooling.
We
check
that
every
year,
people
user,
you
give
us
four
to
five
out
of
five
stars.
A
We
have
a
good
documentation,
can
find
that
on
our
website,
rustling
dork
slash
learn.
Actually
we
have
extensive
docs.
We
have
nine
books
written
on
all
of
these
special
use
cases.
So
there's
an
there's
a
book
on
the
language.
There's
a
book
embedded
specifically
and
we
actually
have
a
language.
It's
hard
to
present.
That's
well
feasible
for
performance
refactoring,
so
you
can
just
do
things
a
little
wasteful
and
then,
after
it
works,
start
refactoring
to
making
to
using
more
performant
techniques.
A
So
does
that
work
we're
seeing
rust
used
in
many
many
ways?
And,
interestingly,
we
got
roughly
33%
in
flux.
So,
a
third
from
functional
language,
dynamic
languages
and
systems
programming,
so
people
are
coming
from
all
like
off
the
stack
down
the
stack
from
all
areas
into
the
rest
project
because
they
seeing
that
there's,
finally,
a
language
that
they
can
kind
of,
amend
to
the
use
cases
easily
and
it's
well
supported
and
they
can
get
stuff
committed
to
the
tooling
to
actually
support
that
without
working
off
the
little
language
community.
A
Also,
one
thing
you
should
consider
I'm,
actually
not
asking
you
to
switch
languages.
That's
I
think
there's
a
huge
problem
that
if
we
bring
new
languages
on
the
table,
many
people
are
like.
Oh,
my
god,
I
need
to
get
everyone
retrained
and
all
the
stuff
rewritten.
No,
that's
actually
not
the
case.
This
is
why
we
offer
these
things
like
you,
can
rewrite
a
small
piece
of
it
and
then
use
rust
as
a
shade
library
or
you
can
integrate
it,
bringing
another
tool
to
the
belts
on
an
organization
level.
A
It's
much
cheaper
than
actually
like
rooting
for
bringing
the
old
stuff
out.
That's
important
to
consider
and
rust
is
a
tool
that
you
can
actually
use
everywhere.
So
it's
a
very
useful
tool
to
have
might
not
be
the
thing
that
you
use
everywhere,
but,
for
example,
with
you,
if
you
are
working,
for
example,
in
the
IOT
sector,
it's
one
of
the
rare
languages
that
can
actually
cover
all
of
all
of
the
use
cases
that
you
have
form
small
devices
up
to
your
service
systems.
A
So
the
conclusion
is
rust
is
the
language
of
wealth
shows
and
compiled
some
guarantees
and
simple
runtime
semantics
that'll,
and
this
simplicity
is
important
because
that
allows
you
to
use
it
in
any
area
of
your
product,
because
you
can
build
on
these
simple
semantics
towards
the
thing
that
you're
actually,
instead
of
dragging
all
of
those
semantics
in
in
the
first
place.
So
thank
you.