►
Description
Rust is not a hype, it is a much-needed solution. Rust is a new systems programming language, currently finding its way into the software industry. It's hard to not see it in tech news today. But why the high interest? This talk will guide you through why investing effort into Rust will help you and your organisation in many ways?
Presented by: Florian Gilcher (@argorak)
Ruby/Rust developer, Rust Core/Community team, RustFest Main Organizer, Rust Community Europe board member | Asquera, Berlin
A
A
A
B
A
C
Yeah
so
hello,
everyone.
The
reason
why
we
here
is
basically
nothing
were
technology-wise
and
basically,
we've
got
an
idea
how
it
could
be
made
better
to
have
other
ways
how
it
doesn't
work.
Clucky
already
introduced
me
I'm
Florian.
This
is
basically
all
my
profiles.
If
you
want
to
be
me
for
that,
I
just
take
this
put
into
your
batch
profile
source
it.
C
C
That's
just
for
managing
community,
it's
all
by
community
members.
So
it's
not
a
Mozilla
thing
or
something
and
yeah
happy
to
be
part
of
it
as
a
hobby.
I
shoot
arrows
at
stuff
so
mind
back
during
the
Q&A,
but
yeah
I'm
here
to
talk
to
you
about
Russ
rust
is
a
new
programming
language
and
a
at
systems
programming.
It
is
powered
and
was
little
below
along
with
servo,
which
is
a
new
browser
engines
in
development
by
Mozilla.
B
C
A
lot
of
technologies,
some
of
churches
that
are
found
in
circle,
are
now
coming
into
Firefox
I
was
trying
to
say
slowly.
It
isn't
bad
slow,
they're
going
to
hit
in
November.
So
this
is
an
interesting
thing.
Russ
is
the
programming
language
that
was
always
developed
in
lockstep
with
a
large
project
which
a
large
practical
project
side
by
side,
which
is
unusual,
usually
the
largest
project
in
a
programming
language.
At
the
beginning,.
B
C
Most
of
the
time
being
larger
than
the
language
implementation
itself,
it
is
there
to
provide
an
alternative
to
C
and
C++,
but
also
to
other
high
other
languages.
This
is
a
common
mistake
that
people
make
to
think.
Well,
this
is
a
CV
placement.
It
isn't.
It
is
also
meant
to
bring
new
stuff
to
other
programming
fields,
but
yes,.
B
C
It's
built
for
the
same
area,
but
since
it
was
possible
to
work
programs
with
fight
control
of
a
memory
layout
on
all
these
kind
of
things.
I
also
have
to
say
that
we're
seeing
this
as
an
evolution
and
not
as
kind
of
a
fight
who
see
in
C++
there's
a
lot
of
good
things
that
these
language
is
made
and
I
think
the
best
thing
I
ever
heard
about.
B
C
So
the
three
coins
that
Russ
is
trying
to
make
as
a
language
it's
it
wants
to
be
safe,
concurrent
and
fast,
without
any
kind
of
trade-offs
to
make
like
this
is
safe.
But
it
is
concurrent
this
is
concurrent,
but
it
isn't
fast
and
all
of
these
kind
of
things
it
actually
aims
to
bring
these
three
under
one
umbrella
and
we
seen
all
of
the
promises
before.
But
how
do
we
differ?
C
C
We
have
aesthetic
types
and
types
of
sim
with
local
type
inference
if
you
have
a
program,
Haskell
or
any
kind
of
other
programming
language
that
has
a
static
type
system
where
you
don't
have
to
type
all
the
types,
but
it
finds
out
what
the
type
of
an
expression
is,
and
you
don't
need
to
put
it
on
every
variable.
This
is
basically
how
it
works
in
a
little
bit
with
a
little
twist,
rust
doesn't
incur
types
and
any
kind
of
boundaries
like.
C
If
you
have
a
function,
you
need
to
save
the
whole
signature,
it
doesn't
infer
it,
and
this
is
a
conscious
choice
for
programming
language
or
for
program
stability.
That
beeps
are
the
boundaries.
What
we
say
this
is
where
you
actually
have
to
note
it
down
what
the
interface
is.
It
has
explicitly
ability
I
come
to
that
in
a
second.
It
has
something
that
we
call
zero
cost
abstraction,
which
is.
C
There
are
no
exceptions,
but
all
error
cases
must
be
handled.
It
has
no
null.
It
has
no
concept
of
a
null
pointer.
Values
have
to
be
there,
and
if
you
absent
this,
it
has
something
that
we
call
static
automatic
memory
management.
It
doesn't
automatically
manage
memory
for
you,
so
you
rarely
explicitly
key
allocate
and
it
doesn't
leave
memory.
But
that
happens
all
at
compile
time.
B
C
C
Would
fit
and
all
places
and
a
way
to
prove
that
this
was
actually
possible,
was
hoarding
the
whole
server
code
base
over
to
not
using
the
garbage
collector
at
all,
and
when
that
works,
you
can
actually
write
a
practical,
huge
program
in
the
programming
language
without
this
kind
of
backdoor,
where
you
could
actually
use
a
garbage
collector.
This
was
used
as
a
proof
that
this
was
actually
possible.
So
there's
a
lot
of
decisions
in
rusts
where
people
come
and
say.
Oh,
why
are
you
not
doing
this
but
actually
say?
Oh,
we
did
do
this.
C
A
lot
of
teachers
in
the
language
are
there
for
the
long
run,
I'm
going
to
explain
that
a
little
food
talk,
but
that
sometimes
means
that
if
you
start
learning
the
language
and
you've
writing
small
programs,
some
of
the
features
might
not
have
that
much
bang,
as
it
would
have
to
people
that
are
very
loud
problems.
So
there's
always
some
kind
of
mental.
B
C
Would
that
picture
look
like?
Is
it
on
a
large
code
base,
so
we
are
kind
of
resistant
to
introduce
features
just
for
being
there
to
make
it
easier
to
the
first
two
days,
which
doesn't
mean
that
we
don't
want
to
be
in
ergonomic
language.
So
if
you
can
introduce
economics
that
make
the
language
better
on
day
to
day
use
for
sure
we're
doing
it,
it's
just
that
the
core
idea
of
language
is
around.
We.
C
People
to
just
write
tooling
for
the
language
and
to
just
write
documentation
for
language,
which
means
that
our
standard
libraries
almost
completely
documented
in
more
than
just
two
sentences
fermentative,
and
we
have
a
whole
book
written
on
the
language.
It's
pretty
to
be
rewritten,
it's
close
to
completion,
it's
yeah,
it's
usually
better
than
without
the
new
program
edge.
So
what
does
the.
C
C
Error
handling:
what
happens
if
you
come
up
when
you
attempt
tear?
Is
you
get
a
click
back
that
says
it
worked
or
it
didn't,
and
you
actually
need
to
check
on
this.
So
you
can
brush
your
cone
off
okay,
this
world
and
this
is
the
directory,
and
then
you
can
do
whatever
with
it
so
even
create
a
file
in
it
using
the
path
and
joining
the
name
on
it.
So
we
can
standard
or
you
can
do
something
based
in
error
and
then
can
say
well,
couldn't
open
the
temporary.
C
Russ
will
actually
notice
that
at
this
point,
this
file
handle
falls
out
of
scope,
needs
to
be
the
allocator,
and
the
file
needs
to
be
closed,
so
it
automatically
handles
this
case
for
us
and
all
kind
all
kinds
of
similar
cases.
So
in
that
sense,
that's
what
I
mean
by
it's
kind
of
like
you're
working
in
a
garbage
collected
language
that
has
these
kind
of
semantics,
but
this
has
no
runtime
component.
The
compiler
will
note
is
that
the
temp
file
runs
out
of
scope
and
will
delegate
it
and
will
close
the
file
handle
correctly
I.
C
Start
first
with
zero
subtractions,
because
they're
basically
just
this
rough,
can
look
much
more
high-level
than
the
thing
before
like
this
was
pretty
much
by
the
numbers.
You
go,
you
go
top
to
bottom
and
if
you
know
all
the
operations
Europe
in
imperative
programming
land,
but
rust
has
a
certain
functional
component,
especially
in
his
api's.
So
what
I
can
do
here?
As
I
said,
the
first
operation
can
fail
or
not
fail.
I
can
start
combining
these
operations
and
say:
okay,
I
want
to
open
a
new
temp
dear
and
then
which
will
be
executed.
C
If
that
was
successful,
and
then
you
would
that
have
to
create
a
file
in
it
and
so
on
so
forth,
so
I
can
start
combining
things.
But
the
way
when
this
plays
into
zero
cross
abstractions
is
our
compiler
is
smart.
Then,
basically,
this
compiles.
These
two
things
will
compile
to
the
same
program,
and
this
is
actually
not
the
rascal
compiler
beam.
Excuse
me
smart.
This
is
something
that
LLVM
the
core
technology
that
we
use
can
do
since
ages.
So
we
basically
just
pick
me
back
any
on
that
and
actually
using
it
in
a
programming
language.
C
Nowadays
many
programming
languages
cover
by
the
mutability
by
ifs,
say
everything
is
mutable
and
all
bets
are
off
or
immutability
is
evil,
so
nothing's
mutable
and
everything
works
like
it
wouldn't
be
mutable
and
the
compiler
may
be
optimizing
in
the
back.
Where
knows
that,
something
works
better
than
mutating
the
memory
region
instead
of
instead
of
you
explicitly
doing
that
rust
has
a
different
idea
there.
It
actually
makes
the
mutability
an
explicit
part
of
the
language,
so,
let's
just
say
two
structures.
This
is
basically
like
C
or
many
other
programming
languages
that
have
bad
memory
structures.
C
C
I
can
create
that
in
my
program,
basically
by
just
using
the
visualization
syntax
here
and
now,
I
would
try
to
go
to
the
inner
field
and
set
the
value
to
something
different,
and
this
won't
work
because
they
default
in
Russ
everything's
immutable,
but
I
can
make
it
mutable
I
can
use
the
same
program
and
say:
D
is
mutable,
then
I
can
mutate
it.
So
mutability
is
part
of
all
variable
bindings
of
all
interfaces
of
all
signatures.
This
is
just
a
simple
example.
The
compiler
will
actually
reason
about
the
mutability
properties
for.
C
C
Is
no
one
feels
responsible,
no
one
who
lose
that
memory
same
thing
and
what
Russ
says
is
that
any
piece
of
data
that
you
introduce
into
a
program
is
uniquely
own.
It's
only
one
owner
and
this
ownership
can
be
passed
on
or
it
can
be
borrowed.
And
here
you
have
mutable
and
immutable
that
come
to
what
borrow
is
quickly
and
the
thing
with
passing
ownership
is,
if
you
pass
ownership
to
a
function
that
takes
ownership.
C
You
cannot
use
it
afterwards,
classic
cases
here.
Is
you
pass
on
a
file
handle
to
another
part
of
the
program
you
shouldn't
use
it
afterwards,
because
you
don't
know
what
happened.
File
might
be
closed
or
something.
This
is
standard,
programming,
semantics
with
thinking
about
giving
something
away
to
another
part
of
a
program
or
basically
lending
it
away
and
trying
to
do
something
with
it
afterwards
and
the
other
thing
that
we
allows
this
kind
of
borrowing.
C
What
borrowing
says
is
you
give
away
access
to
something,
but
you
keep
it
the
way
it
works
memory
was
is
once
you
pass
away
ownership.
You
passed
away
everything
for
that
piece
of
data
access,
mutating
you're
not
allowed
to
do
anything
anymore,
so
the
flow
in
this
program
is
I.
Instantiate
data
I,
give
it
to
taking
ownership,
and
the
compiler
will
introduce
a
statement
here
that
removes
it
from
memory
once
it
falls
out
of
scope
where
it
is
owned.
C
C
C
Might
who
take
the
data?
Is
it's
perfectly
fine,
but
there's
no
other
party
currently
waiting,
I'm,
borrowing
it
away
multiple
times
immediately,
which
is
also
fine,
because
they
there's
no
collisions.
That
could
happen
because
the
language
semantics
force
that
none
of
the
receivers
of
this
data
actually
mutated,
and
this
is
exclusive,
so
either
the
first
rule
by
all
the
second.
So
it's
not
possible
to
once
share
the
way
mutiply
and
a
hundred
times
you,
because
that
would
break
the
expectations
of
the
ones
were
borrowed
it
amusingly,
because
this
this
means
it's
no
exclusive.
C
This
no
other
part
of
the
program
that
could
mutate
it.
As
long
as
you
know
that
you
have
an
immutable
borrow,
and
this
can
also
be
used
for
optimization
by
the
compiler
later
and
the
ability
runs
deep
and
that's
one
of
the
things
where
I
say
like
Reston
look
for
large
programs-
and
this
applies
deeply
all
your
code
as
big
as
it
is
like
you
can
grow
an
immutable
pointer
in
a
100,000
line
library.
C
And
it's
part
of
our
submissions
I
mentioned,
and
the
idea
of
this
is
rust,
makes
reasoning
about
large
systems
localized
by
reducing
action
of
distance,
that
mug
doesn't
make
it
the
fastest
language
in
the
assembly
of
those
large
systems,
but
once
you're
in
a
method,
scope-
and
you
know
this
I-
can
mutate.
This
I
can't
use
this.
No
one
else:
computing
working
here,
I
work
fully
localized
in
a
block
of
code
and
having
much
more
information
that
you
would
have
in
another
programming
language
about
the
context
in
which
this
code
runs.
C
C
B
C
C
Isn't
in
a
concurrent
setting
isn't
secure
operation?
What
could
happen
is
that
two
of
those
operations
are
running
at
the
same
time
either,
and
one
of
those
gets
lost.
So
after
running
this,
the
integer
might
be
too
just
not
or
44.
It
should
be.
46
Russ
actually
detects
that
rust
carries
along
with
all
types
information,
whether
they
can
be
shared
through
a
pointer
between
threats,
muted.
B
C
B
C
C
B
C
Which
is
basically
the
engineer
that
is
behind
the
line,
or
also
the
proper
handling
of
go-go
routines
and
the
second
less
sharing
in
between
those.
So,
for
example,
if
you
would
drag
something
in
a
mutex
and
make
sure
that
this
moderation
actually
works,
make
sure
that
all
of
these
three
operations
about
one
after
another.
C
C
B
C
C
That
is
that
the
compiler
in
these
cases
would
actually
tell
you
if
you
do
something,
that's
safe
and
you
don't
need
to
run
it
using
any
kind
of
other
static.
Analysis
like
Firefox
have
a
huge
static
analysis
tool.
Just
living
poet
have
written
for
their
old
sign
system
that
just
work
on
the
specific
kind
of
super-spicy
right,
and
if
you
don't
it
even
stops
working
to
detect
these
kinds
of
cases,
and
here
the
language
brings
it
on
its
own,
and
we
have
libraries
on
top
of
that.
Providing
threading
general
its
event
pays
for
currency.
C
C
B
C
C
The
language
gives
you
the
possibility
to
opt
out
of
the
safety
if
absolutely
necessary.
There's
a
special
kind
of
sub
language
is
called
unsafe,
rust
or
better
off,
but
you
can
do
everything
you
could
do
in
C.
So
if
any
of
these
semantics
are
problematic,
you
could
switch
them
off.
You
should
do
that
for
good
reasons
and
beginning
it's
pretty
often.
C
B
C
C
C
C
I
did
that
before
and
that
this
is
data
that
perhaps
an
inner
data
and
the
compiler
will
actually
figure
out
like
what
the
proper
layout
Phyllis's.
If
you
have
a
program
in
the
language
that
has
this
angle
bracket
notation
for
genetics,
Java
or
C
C++,
this
comes
quite
naturally,
and
what
I
mean
by
local
type.
Inference
is
in
this
case
you
actually
don't
have
to
notate
the
variable,
because
in
sensation
you
already
see
this
is
data
in
a
data
and
the
language
will
find
that
out
by
itself.
C
C
So
the
problem
is
I
have
a
number
that
I
instantiate
here
and
I'm
returning
a
borrower
on
that
number,
but
because
of
the
ownership
rules,
I
explain
you.
If
I
have
a
number
three
and
this
code
ends,
numbers
falls
out
of
scope,
it
will
be
de-allocated
due
to
the
ownership
rules
but
I'm
returning
a
borrower.
C
C
C
You
can
allocate
the
number
on
the
heap
or
you
can
return
it
like
in
the
case
of
an
interest
rate,
you
could
just
return
them
very
something
but
never
hand
out
a
burner
on
something
that
you
might
later
and
move
from
memory
before
the
Burrow
is
not
active
anymore,
and
that
leads
to
this
way
with
statement.
They
have
a
learning
curve,
but
they
have
very
simple
concept,
because
the
only
thing
the
biggest
problem
is
that
people
assume
they
do
more
than
they
actually
do
and
they
are
purely
descriptive.
C
C
Isn't
possible?
That's
all
that
lifetimes.
Do
you
can
actually
compile
Ross
code
without
taking
any
care
of
these
at
all,
like
there's
a
compiler
that
does
none
of
this
checking,
the
code
is
completely
valid.
The
information
is
only
used
for
validity
checking
of
the
code
and
that's
a
problem
that
people
run
into
when
they
are
like
I'd
like
to
program
a
lifetime.
C
Now
you
can't
program
a
lifetime,
you
can't
you
can't
find
any
kind
of
description
of
this
problem
or
or
of
this
kind
of
code,
where
this
is
possible
and
that's
that's
the
thing
that
people
banging
their
head
against
once
they
run
into
this
error.
So
if
you,
if
you
ever
run
into
these
kinds
of
problems,
the
first
thing
you
can
say
is
what
am
I
expressing,
because
this
actually
catches
the
weirdest
times
of
box
where
you're
sitting
there
for
an
hour?
And
then
you
like?
C
C
A
C
C
It
brings
it
brings
along
a
lot
of
really
interesting
new
concepts,
especially
like
the
whole
concurrency
checking
I,
don't
know
in
any
other
adopted
language,
these
languages
that
have
concepts
that
make
this
whole
thing
easier,
but
the
language
that
actually
checks
your
patterns
on
how
you
are
working
concurrently
in
that
time
system
I,
don't
know
any
except
research.
Language
is
obviously
one
thing.
I
have
to
say:
Russ
is
not
a
simple
language,
whoever
tells
you
otherwise
is
wrong,
especially
because
the
features
are
booked
for
the
long
run.
C
C
Learning
must
make
me
a
lot
better
in
my
C++,
for
example,
because,
like
all
of
these
sense
of
sharing
semantics,
also
like
in,
if
you
read
Java
concurrent
OVA
thinking
in
these
sense,
sharing
ideas
and
kind
of
passing
on
ownership
is
definitely
useful
in
object-oriented
languages
as
well
rust
in
itself,
like
the
echo
system,
loads,
rather
approachable,
it's
easy
to
get
an
environment
set
up.
We
get.
We
have
a
lot
of
documentation
for
all
operating
systems
for
all
larger
operating
systems,
on
how
to
do
that.
C
There's
great
dogs
through
a
book
and
they're
almost
fully
documented
standard
library,
but
probably
the
parts
that
are
documented.
You
bought
it
and
it
has
built-in
dependency
management
just
like
you
would
know
from
JavaScript
Ruby
or
something
we
have
like
way
of
doing
this,
and
it
plays
really
well
with
others.
It
interfaces
would
see
or
any
kind
of
C
foreign
function
interface
almost
that
no
or
zero
cost,
depending
on
how
expensive
the
C
interface
of
your
language
is.
C
That's
why
I
wrote
and
and
almost
no
cost
like
if,
for
example,
the
Ruby
C
FFI
isn't
zero
costs,
so
the
cost
of
using
that
Russ
cousin
case.
But
you
can,
for
example,
if
your
language
has
a
CF
I,
you
can't
use
less
of
it,
and
this
is
a
part
where
a
lot
of
people
going
to
Russ,
there's
more
people,
that
I
know
that
have
rewritten
critical
parts
of
their
Ruby
applications
in
Russ
and
I
know
that
have
written
critical
parts
of
it
and
see.
But
everyone.
C
You
suck
ports
with
this
small
library
that
you
wrote.
You
bring
me
down
your
whole
web
server,
but
no
one
wants
to
do
this
if
you
work
in
a
second
language
which
were
saved
bus
is
this
is
a
total
looking
for
impossible
thing
to
do
so,
even
with
people
that
don't
have
an
ample
amount
of
experience
with
system
programming,
they
can
do
this.
We
see
you
need
someone
who's
properly
trained
in
having
all
of
the
ways
to
handle
this.
C
This
value
generators
for
C
in
C++,
this
probably
good
because
well
Firefox,
needs
them
and
Firefox
is
using
rest
in
a
lot
of
places
now,
and
this
definitely
improves
the
quality
of
those
LED
bodies.
There's
high
level
bindings
for
some
languages,
Ruby
half
of
the
finding
that's
called
helix
JavaScript,
has
funny
that's
called
neon.
C
And
very
good,
so
you
don't
need
to
be
super
into.
How
does
the
SFI
of
my
language
work
and
it's
a
great
partner?
It
preserves
the
conveniences
of
high-level
languages
like
second
fingers.
Memory
management,
all
these
kinds
of
things
any
low
level,
and-
and
we
also
don't
want
to
be
a
primary
language
at
all,
because
don't
rewrite
your
whole
application
in
rust.
C
C
Out
with
a
huge
application
and
I
wrote
in
all
of
us,
that's
just
a
very
tough
call
for
language.
That's
fun!
That's
just
two
years
old!
If
you're
doing
this,
we
definitely
support
your
full
way,
but
most
of
the
users
that
adopters
are
secondary
language
doctors,
and
this
is
definitely
something
that
we
fully
support
and
what
want
to
know
all
the
issues
that
you
have
so
it's
built
for
gradual
adoption,
and
it
also
shows
in
the
projects
that
are
using
this,
the
gstreamer
framework.
B
C
This
is
not
a
fun
operating
system
like
this
is
proper
operating
system
that
feeds
into
a
graphical
shell,
that
is
usable.
This
is
educational
operating
system.
We
afford
them
and
there's
even
one
for
embedded
use
cases
and
there's
also
an
implementation
of
RTFM,
which
is
we
have
time
for
the
masses,
which
is
concurrency
framework
both
for
embedded.
C
Thrust
is
moving
there,
sometimes
if
you're
working
on
a
very
specialized
processor-
probably
you
haven't-
that
is
feasible
to
do,
but
someone's
going
to
do
the
work
at
some
point
and
yeah
GC
was
currently
introducing
rest
for
C
for
plugins
and
their
findings,
where
rust
has
better
ergonomics
at
the
same
speed
like
performance
points
and
their
20.
Last
security
issues
were
memory
bugs
because
especially
video
software
is
heavily
pausing
file
formats
and
streams,
and
all
these
kind
of
things,
they're
very
prone
to
memory
issues
and
rust
makes
sure
they
didn't
happen
and
they
come.
C
They
had
a
huge
source
of
bugs,
especially
in
the
multivariate
code.
So
any
kind
of
support
for
meta
multi-threading
is
right
up,
there
least,
and
they
needed
a
language
that
gives
latency
guarantees
that
JC
g
seed
language
is
just
calm.
Give
GC
GC
run
just
means
that
your
streams
come
in
and
be
hitching.
You
really
don't
want
to
have
that
and
it
runs
well
the
memory
constrained
environments,
so
we
don't
have
large
concepts
on
top
of
every
value
like
every
table
or
something.
C
Rust
in
itself
has
a
commission
possibility.
The
rest
is
released
every
six
weeks,
which
is
a
bit
odd
for
programming
language
but
M.
It
is
very
nice
because,
in
the
sense
that
any
of
those
releases
won't
introduce
many
changes
and
we've
got
a
strong
commitment
to
backwards
compatibility,
a
lot
of
huge
machinery
to
ensure
that
including
pulling
down
all
public
rustling
and
trying
to
build
it
and
see
the
basement
reference.
If
you
feel
that
this
could
introduce
aggression
now,
that
also
means
we're
currently
at
version.
This
is
ugly
we're
currently
able
Persian
121
zero.
B
B
C
C
Program
languages
have
this
unstable
flag
or
fragments
that
you
can
activate
that
are
not
in
the
language
standard.
We
have
that,
but
only
if
you're,
using
the
nightly
version
of
the
compiler
to
ensure
that
people
don't
actually
build
stable
software
on
top
of
it,
which
takes
us
the
ability
to
change
these
things.
But
it's
a
surprisingly
mature
was
such
a
long
language,
because
cogeneration
is
provided
through
LLVM,
which
in
itself
is
much
more
mature.
It's
the
base
technology
behind
the
amplifying
compiler
and
all
these
kind
of
things
it
has
no
runtime
having
the
runtime
means.
C
C
C
It
is
also
if
you
do
any
kind
of
embedded
so
rust
is
they
default
across
compiler
and
the
whole
tool
chain.
That's
the
advantage
of
shipping.
The
whole
tool
chain
is
aware
of
that,
so
you
can
install
in
two
or
three
commands:
I
want
to
have
a
rustic
honor
with
the
standard
library
for
Apple
iOS
and
all
these
kind
of
things.
It's
almost
no
setup
in
the
cross
compilation.
If
your
target
has
a
specific
SDK
that
you
need
to
that
nikan
ship,
you
need
to
install
it
by
hand
and
it
supports
embedded
use
cases.
C
So
we
are
there
for
several
kinds
of
of
embedded
processors,
cortex
and
being
the
most
prominently.
The
compiler
divides
useful
errors
and
warnings.
We
change
that
a
lot.
We
want
any
of
those
warnings
to
not
be
arcane.
Some
still
are,
but
that
changes
in
future
versions-
and
we
have
a
currently
in
development
language
server
for
supporting
idea-
is
this
also
idea
is
that
already
have
great
support,
especially
the
idea
has
great
support
to
rust,
but
they
ship
their
own
tool.
So
it
needs
to
be
said:
it's
a
young
language,
so
their
library.
C
C
So
most
important
libraries
are
available
for
many
protocols,
h,
CP
c
parses,
positive
libraries
are
there
in
maxes
and
a
couple
of
concurrency
abstraction
libraries
for
the
most
important
parts.
So
you
don't
have
to
build
your
event
reactor
on
top
of
the
sentence.
You
don't
really
want
to
do
that
quite
be
kind
of
forward.
C
We
have
that
it's
just
not
in
the
language
core
and
there's,
currently
a
huge
ongoing
effort
to
bring
libraries
close
to
1
0
to
1
0,
which
is
just
a
community
occurred
where
we
encourage
people
of
libraries
that
have
wide
use
to
actually
find
contributors
that
would
bring
them
to
a
stable
1-0
release
that
they
will
actually
be
willing
to
maintain
what
we
already
have.
We
have
people
binary
libraries
for
48
different
kind
of
targets.
So
what
exam
is
what
you
wanna
know?
We
have
full
instill
to
link
through
our
our
dependency.
C
C
C
Or
30
days
or
something-
but
this
is
this-
is
the
time
range
we're
talking
about
for,
where
small,
to
large
changes
to
the
language
landing,
and
we
make
sure
that
people
that
have
small
changes
don't
go
through
the
huge
process?
That's
build
for
like
making
sure
that
the
stability
of
the
language
gets
many
they're
maintained
if
you're
just
fixing
a
small
mistake
somewhere
or
a
typo.
C
This
is
something
we
just
want
to,
and
this
works
really
well,
so
there's
lots
and
lots
of
infrastructure,
ncie,
quality
control
and
development,
and
the
language
itself
usually
builds
since
version
zero
for
zero,
and
that's
something
that's
really
interesting.
Mozilla
has
a
research
department
them
and
Russ
is
out
of
the
research
search,
if
happened,
but
that
research
department
expects
all
of
their
projects
to
be
in
a
releasable
state
over
time
and
to
actually
make
proper
releases
of
two
months.
C
So
when
we
were
in
the
alpha
ages,
that
was
still
a
release
every
two
months
to
make
sure
that
the
software
is
releasable
and
that
told
me
shows
and
how
it
was
allowed
this.
The
software
that
this
is
not
just
some
researchers
bashing
out
like
very
bad
code
that
no
one
ever
can
retrace
because
they
cannot
build
it.
It
and
by
both
I
mean
check
it
out.
Make
done
and
this
works
since
five
or
six
years,
so
wasn't
a
support.
Their
house
really.
C
But
there's
one
thing,
I
would
say
when
it
comes
to
governance
in
community.
Russ
is
not
a
Mozilla
project,
and
this
is
a
conscious
decision.
Actually
most
of
the
changes
to
the
language,
impulsive
contributions
to
the
language
come
from
community
members
and
75%
even
contributions.
Even
though
there's
many
people
employed.
It
was
a
lot
of
time
to
do
with
us
and
to
work
with
us.
They
do
a
lot
of
community
effort
behind
it,
and
Mozilla
is
really.
C
They're
doing
that
for
ages
also
handle
this
in
a
fashion
that
doesn't
feel
like
this
language
is
just
going
this
way
because
Mozilla
wants
it.
They
actually
tell
you
why
they're
doing
it
and
also
support
ways
to
use
the
language
which
are
not
Muslims
in
space,
for
example,
they
are
funding
someone
to
make
us
better
in
a
minute.
C
As
far
as
I
know,
and
to
have
that
we
also
have
public
or
see
process,
so
any
larger
changes
to
the
language
we'll
go
through
process
with
where
the
debate,
and
if
you
want
to
have
your
voice
heard.
This
is
the
place
where
you
can
do
it,
and
it
is
not
unusual
that
these
are
sees
fail
like
there
has
been
one
RFC
for
a
larger
rebuild
of
the
module
system
of
the
language
that
failed
three
times
over
the
summer.
People
were
getting
really
frustrated.
C
C
This
is
not
because
we
think
companies
should
have
inclusive
accident,
but
companies
often
have
an
interest
and
not
being
too
public
about
many
things
about
the
software
that
they
built.
So
we
give
them
a
trustful
way
to
approach
us,
and
they
have
problem
is
the
problem
we
do.
This
was
completely
burnt
because
so
this
kind
of
gives
us
a
insight
into
what
larger
usage
of
the
program
is.
My
problem
with,
and
we
have
companies
that
do
consults
Development,
Train,
yeah.
Finally,
commercial
uses
here.
C
C
Britannians,
so
fine
words,
in
my
opinion,
lust
is
not
high
at
all.
A
lot
of
the
community
growth
is
very
natural.
It's
actually
not
as
fast
as
you
as
maybe
media
would
make
you
believe.
It's
very
constant
and
it's
breathing
safe
programming
to
target
weight
was
previously
unfeasible
and
I.
Think
this
is
the
interesting
part
about
the
language
and
it's
totally
a
language
that
once
we
use
it,
that
wants
to
be
practical
use,
and
but
we
also
bring
like
this
whole
concurrence.
Checking
thing
is
something
where
it
gets
really
interesting.
C
Had
our
we
had
our
annual
survey,
we
do
any
all
surveys
every
universe,
and
we
had
we
had
at
this
summer
and,
interestingly,
the
strongest
sub
community
of
rust
is
Europe.
Rust
is
totally
like
uniformly
in
to
rust
it's
by
a
good
margin
and
I'm
very
happy
about
this.
So
it
isn't
like
a
language
that
sweeps
over
from
the
US,
but
there's
a
huge
communities
outside
of
the
US,
also
in
India,
and
that
makes.