►
From YouTube: Rust: Removing the Sharp Edges from Systems Programming - Jonathan Creekmore, Star Lab
Description
Rust: Removing the Sharp Edges from Systems Programming - Jonathan Creekmore, Star Lab
Systems programs are at the base of everything an embedded engineer works with, but manually managing memory safely can be difficult to get correct in traditional systems languages like C and C++. Rust gives a programmer a high-performance systems language that enforces data safety through its strong type system, eliminating memory corruption and data race issues at compile time. In this presentation, Jonathan Creekmore will give an overview of the Rust programming language and explain how systems programmers can use it to protect their programs from memory corruption and data races, leading to safer, more secure programs. Additionally, Jonathan will show how to use meta-rust to bring Rust programs into Yocto systems.
About Jonathan Creekmore
Twitter Tweet LinkedIn Connect Websitethecreekmores.org
Jonathan Creekmore has been an embedded systems and security software engineer for the last 16 years. Over the years, he has worked on routers, switches, and IoT sensor nodes, as well as a software protection product built on Linux. Since joining Star Lab, Jonathan has been contributing to the Xen hypervisor and writing security software utilities using Rust. Currently, Jonathan is one of the principal software engineers developing Crucible, a secure, authenticated boot solution for embedded virtualization.
A
A
hi
everybody,
my
name
is
Jonathan
Creek
Moore
here
to
talk
to
you
about
rust
today,
so
kind
of
just
a
general
overview.
First
I'm
going
to
explain
kind
of
why?
What
I
believe
system
programming
to
be
and
how
rust
helps
solve?
What
I
see
as
some
of
the
problems
with
systems
programming
languages,
then
I'm
going
to
give
just
a
really
quick
overview
of
rust.
A
Software
I,
like
anything
programming
theory
related
math
history,
hiking,
just
all
sorts
of
different
things,
but
I
spend
most
of
my
time
writing
software
and
whenever
I
can
I,
write
it
and
rust
these
days
all
right.
So
what
is
systems
programming?
What
do
I
consider
systems
programming
to
be
well,
comparing
that
to
applications,
programming
systems,
programs
provide
services
to
other
programs,
they're,
not
something
that
the
user
is
really
going
to
be
executing
themselves,
but
are
rather
in
support
of
those
user
programs.
A
So
for
the
Linux
kernel
would
be
a
systems
program,
any
OS
kernel
would
be
a
driver.
Gmc
would
be
a
systems
program
so
with
the
JVM.
So
any
type
of
language
runtime
would
be
a
systems
program.
So,
like
I,
said
anything
that
any
type
of
program.
That's
not
the
right
main
reason.
A
user
is
sitting
down
at
the
computer
and
trying
to
get
useful
work
done
would
be
a
system
program
of
some
sort.
A
You
typically
would
see
them
in
some
place
where
your
resources
are
very
constrained
either
because
they're
not
doing
what
the
user
is
really
looking
to
have
done.
They're
just
that
base
level
software
or
you're
dealing
with
an
embedded
system
where
you
have
a
very
small
set
of
memory
or
very
constrained
CPU,
like
I,
said:
they're
used
to
build
abstractions
for
applications
programs,
so
libraries,
language,
runtimes,
OS
kernels,
that
type
of
thing.
A
What
I
see
the
sharp
edges
of
systems
programming
mainly
to
be?
Is
the
manual
memory
management
that
you
wind
up
having
to
do
so?
Applications
programming
languages
generally
provide
garbage
collectors
so
that
the
user
does
not
have
to
deal
with
allocating
memory
or
releasing
it
at
the
right
time
or
remembering.
A
What
memory
is
in
use
of
what
memory
can
be
reused,
but
the
garbage
collector
does
incur
some
amount
of
overhead
in
your
program.
You
have
a
memory
overhead
of
it's
going
to
allocate
more
memory
than
you
necessarily
need
it's
going
to
hold
on
to
it
longer
than
the
system
necessarily
going
to
want
to
hold
on
to
it
periodically
you're
going
to
have
pauses
when
the
garbage
collector
has
to
run
and
go
through
and
sweep
and
find
a
memory
that
it
can
free
up.
A
So
if
you
have
very
resource
constrained
applications,
you
may
not
want
to
incur
that
overhead
of
a
garbage
collector.
Another
issue
is,
if
you
have
library
code,
it's
hard
to
write
that
in
a
high-level
language,
because
how
do
you-
especially
if
you
have
a
runtime
associated
with
that
language,
because
how
do
you
share
that
among
other
languages?
So
how
can
I,
as
a
CE
application
writer,
use
something
that
is
a
Java
library
I?
Pretty
much
just
can't.
A
So
why
is
manual
memory
management
challenging?
So
a
lot
of
the
reasons
why
it's
challenging
is
because
the
programmer
just
has
to
keep
up
with
a
lot
of
extra
stuff
and
always
make
sure
that
they
get
it
right.
So
the
programmer
has
to
keep
track
of
the
scope
of
all
the
memory
allocated
in
the
system.
Where
were
data
objects
allocated?
A
A
None
of
these
problems
are
real
showstoppers
in
a
typical
systems.
Programming
language,
a
careful
programmer,
can
manage
all
of
those
issues,
I
mean.
Obviously
we
can
we've
been
using
C
for
40
some-odd
years
and
we're
very
successful
using
C,
but
a
lot
of
care
must
be
taken
and
as
a
programmer
I
don't
know
about
you,
I'm
a
little
lazy.
I
don't
want
to
have
to
keep
track
of
all
these
details.
A
It
has
a
strong
static
typing
system
that
allows
the
type
system
to
give
you
several
safety
guarantees
at
compile
time,
rust,
encodes
ownership
and
lifetimes
of
data
objects
directly
into
the
type
system.
So
the
compass
is
up,
so
they
can
Pilar
assist
in
keeping
track
of
how
long
your
data
lives.
So
now
you
just
like
you
wouldn't
see
when
you
do
stack
allocated
memory,
the
compiler
is
more
or
less
keeping
track
of
that.
A
A
Plus
ownership
is
transferred
by
default
so
and
C
or
C++
you're
actually
doing
copies
a
lot
of
times
or
always
I
mean
you.
Every
value
is
passed
by
copy
into
functions
and
out
of
functions
and
all
that,
if
you
want
things
to
be
passed
by
reference,
you
have
to
give
a
a
pointer
in
rust,
you're,
always
moving
the
data
from
scope
to
scope.
If
you
don't
want
to
move
data
around,
then
you
borrow
data
rather
than
transferring
it,
and
I'll
show
a
little
bit
of
an
example
that
in
just
a
few
minutes,
okay.
A
So
this
is
just
a
real
simple
memory.
Leak,
take
a
look
at
it
and
see
if
you
can
see
where
the
memory
leak
is
I,
think
there's
actually
probably
a
couple
of
small
little
issues
with
this
program,
but
I
wrote
it
quickly
so
so,
like
that,
there's
a
little
memory
leak
in
it
in
our
test
function.
We're
using
stirred
up
to
you
know
allocate
that
string
assigning
it
to
tests.
We
pass
it
into
a
function
that
function
does
something
with
the
memory
allocates
its
own
memory
return.
A
Without
very
well-documented
functions
in
C,
we
have
no
way
of
knowing
short
of
reading
all
the
code.
What's
going
to
happen
to
the
parameters
that
are
passed
in,
that's
something
that
we
have
to
as
programmers
document
in
rust.
We
wind
up
not
having
to
do
that.
The
compiler
tracks
it
for
you,
but
the
real
issue
here
is
who
owns
the
memory
that
was
passed
in
nothing
in
the
code
specifies
it
nothing
in
the
code
says:
oh
well,
the
test
function
owns
it.
A
A
Two
different
types
of
up
case
methods
and
the
first
one
does
explicit
ownership
transfer.
So
in
this
case,
input
takes
a
string
and,
like
I,
said
in
rust
by
default,
you're
passing
things
in
you're
doing
a
move
operation
on
it.
So
this
says
that
that
up
case
function,
when
it's
called
will
own
the
string
that
gets
passed
into
it.
What
that
means
is
the
calling
function
will
no
longer
be
able
to
use
the
variable
that
passed
that
in
so
there's
no
ambiguity
about
who
owns
that
memory?
A
At
that
point,
the
compiler
can
then
free
it
up
when
the
function
is
done
in
this
case.
But
what,
if
you
don't
want
that
to
happen?
Well,
in
that
case,
rust
has
borrowing
where
you
pass
in
by
reference
as
to
pool
ampersand
beings.
That
means
that
the
caller
still
owns
that
memory
and
the
called
function
is
only
borrowing
access
to
that
memory.
So
it's
very
explicit
exactly
how
that
is
used.
A
Okay,
very
similar
thing
in
C++,
I,
don't
know
if
there
are
any
C++
programmers
here,
but
it's
a
little
subtly
different.
So
in
this
case,
I'm
allocating
this
big
object
and
big
object
has
something
else
inside
of
it.
Some
object
bar
and
then
I
call
a
function
on
it
that
consumes
the
foo
object,
so
I
am
taking
that
in
and
it's
going
to
delete
foo
after
it's
done
with
it.
A
Like
you
see,
foo
is
now
no
I
can't
use
it,
but
I
grabbed
a
reference
to
bar
so
I'm
still
holding
on
to
a
reference,
and
that
memory
is
now
no
longer
valid.
It
could
have
been
allocated
by
something
else
that
could
have
been
cleaned
up
by
the
delete.
I
have
no
way
of
knowing
when
I
call
do
it
on
that
object,
it's
undefined
what's
going
to
happen.
A
So
how
would
rust
deal
with
this?
Well,
in
this
case,
we
have
very
similar
code,
so
consume
is
going
to
take
in
big
object
and
it's
not
going
to
do
anything
with
it,
but
since
it
passed
in
by
ownership,
it's
going
to
free
it
when
it's
done
so
I,
don't
really
care
what
consume
does
in
this
case,
doing
the
same
type
of
thing
I
can
allocate
one
of
those
objects.
I
can
get
a
reference
to
it,
I
call
consume
I
call,
do
it
and
that's
a
compiler
error.
A
A
So
a
little
subtle
issue
has
bitten
me
in
C++
in
the
past
is
using
the
STL.
So
the
SDL
gives
you
a
lot
of
data
structures
that
can
be
used
and
in
this
case
I'm
using
a
deck
and
I'm
wanting
to
walk
through
that
deck,
and
you
know
race,
anything,
that's
in
it,
that's
even
so.
All
of
my
even
variables
I
want
to
erase
those
out
well.
A
So
if
I
do
this
race,
the
iterator
I.t
that
I'm
using
I
then
cannot
be
guaranteed
to
increment
past
that
and
go
to
the
next
version.
If
I
try
to
do
the
same
type
of
thing
in
rust,
I
get
another
compiler
error,
so
this
is
another
one
of
those
data
races
that
I
was
saying
in
this
case.
I
am
doing
an
immutable
borrow
of
the
input
data
structure,
so
I
have
a
reference
to
it.
I'm
wanting
to
Muta
bleah
do
something.
To
that:
remove
is
mutating
the
input
structure.
A
That's
not
allowed
because
I
have
an
immutable
reference
to
it.
So,
once
again,
rust
is
just
helping
protect
me
from
writing
code
that
can
be
racing
not
necessarily
saying
that
it
would
be
a
problem
in
production,
but
it
could
be
generally
you
wind
up
having
to
restructure
your
code
a
little
bit
to
work
around
issues
like
that.
A
This
is
a
compiler
error.
You
would
have
to
rewrite
this
so
that
it
operates
differently.
It
could
be
a
little
bit
of
a
pain,
but
it
makes
your
code
more
robust,
okay.
So
that's
just
little
bits
of
things
of
how
rust
is
protecting
you
in
problematic
areas.
What
are
some
of
the
exciting
features
that
I
really
like
about
rust?
A
Sorry,
okay,
so
algebraic
data
types,
I
love,
good,
algebraic
data
types,
so
this
is
something
that
you
get
enhancements
to
things
that
you
would
normally
see
in
C
or
C++,
so
a
sum
type
would
be
some
sort
of
an
enumeration,
but
it's
really
more
like
a
variant,
so
you
think
of
a
c
e
new,
and
it's
just
saying
it's
one
of
these
set
of
values.
Well,
in
rust
there
anoon
type,
you
can
also
associate
data
with
that
value,
so
in
this
case
the
enum
sum
has
a
type
value
of
foo.
A
It
has
bar,
which
also
takes
two
arguments,
and
Baz
takes
two
named
arguments.
So,
if
I'm
trying
to
access
think
of
it
in
C
as
a
struct
with
an
e
new
minute
and
then
a
union
that
has
different
values
in
it,
depending
on
which
value
the
enum
has
with
rust,
it
enforces
that
say
that
you
size
and
string
value
is
only
there
when
bar
is
the
value
of
the
e
new.
A
A
The
way
you
work
with
a
lot
of
that
is
matching
pattern.
Matching
is
very
powerful
and
rust,
so
it
works
similar
to
a
switch
statement
in
C
or
C++.
In
this
case,
I
have
that
Inu,
just
like
I
had
defined
before
I
can
do
a
match.
Just
like
I
said
it's
similar
to
a
switch
on
the
variable
that
I
have
in
there
and
I
have
a
set
of
cases
and,
in
this
case
I
have
well.
If
it's
su,
why
I
don't
know
what
to
do
so?
A
I'm
just
going
to
return
0,
because
that's
the
only
possible
value
I
mean
there's,
there's
no
value
associated
with
foo.
If
I
have
bar
well
I
have
a
you
size
that
I
can
use.
So
let
me
just
return
that
use
size,
eye
candy
structure,
the
Enuma
and
peel
out
the
different
pieces
that
are
associated
with
that
value
and
with
bads
I
can
do
the
same
type
of
thing
so
that
match
statement,
D
structures,
your
data
type
and
gives
you
access
to
all
those
interior
fields,
and
it
does
it
by
borrowing.
A
Rust
does
type
inference
so
that
you
don't
have
to
necessarily
specify
what
types
all
your
variables
are.
The
compiler
will
figure
it
out
for
you
and
keep
track
of
all
those
static
types.
In
some
cases
it
does
get
a
little
confused
and
you
have
to
specify
this
is
what
my
type
is,
but
in
general
the
compiler
is
really
good
about
figuring
it
out.
So
in
this
case,
foo
it
figures
out.
Is
that
type
pub
sum
and
it
figures
out
that
value
is
a
type
you
size,
because
that's
how
it's
always
being
used?
A
If
you
tried
to
do
one
of
those
returning
a
string
and
one
of
those
turning
the
you
size,
it
would
error
at
compile
time
because
you're
not
being
correct
with
your
types
another
one
of
my
favorite
features
are
generics
and
traits.
So
if
you're
familiar
with
C++,
think
templates
are
the
equivalent
of
generics.
So
what
they
allow
you
to
do
is
right,
the
code
from
for
an
algorithm
once
and
then
apply
it
to
many
different
data
types
in
a
thread
safe
manner.
A
So
here
I
wrote
a
simple
one:
coast
called
print
Trucy
and
it
takes
the
value
that
was
passed
in
and
called
is
truthy
on
it
and
prints
that
out.
For
you,
one
of
the
things
that
it's
also
saying
is
hey:
that
value
is
of
type
key
and
type
key
has
to
either
be
debuggable
or
has
to
be
debuggable
and
truthiness.
A
They
let
you
define
an
interface
that
can
be
called
on
a
data
type.
You
can
define
your
trait
at
any
point
in
this
case.
I
define
this
truthiness
trait
and
it
has
a
function
called
is
true.
C
then
I
was
able
to
implement
that
trait
for
built-in
data
types
or
any
other
data
type
in
the
system.
So
long
as
I'm
defining
the
trade
I
can
implement
it
on
any
data
type.
If
I
am
using
somebody
else's
trait
I
can
implement
it.
A
A
Ok,
another
place
where
rust
helped
out
is
in
kind
of
traditional
error
handling.
So
in
C
and
C++
you
can
return
null
pointers,
and
you
know,
Tony
Hoare
is
called
null
pointers.
The
billion
dollar
mistake
there
are
so
many
issues
with
returning
null
and
accidentally
dereferencing.
These
null
pointers.
A
Additionally,
a
lot
of
functions
in
C
or
C++
overload
the
return
type
of
the
function
with
error
handling.
So
you
might
have
say
positive
numbers
are
valid,
but
then
negative
numbers
or
error
cases,
and
then
you
have
to
make
sure
that
you're
checking
all
is
is
positive
or
negative
before
I'm
using
it
and
there's
a
lot
of
things
you
just
have
to
know
by
convention.
A
A
A
So,
if
you're
getting
back
an
object
and
it's
an
option
type
in
general,
you
have
to
match
on
that
option
type
to
get
the
value
out
and
if
you're
matching
on
that
option
type
to
get
the
value
out,
you
also
have
to
handle
the
other
case,
which
is
the
none
case.
So
you
have
to
deal
with
the
error
case
now.
A
I
want
to
put
a
little
asterisk
on
that
because
you
don't
have
to
rust,
has
something
called
unwrap
unwrap,
says:
yeah,
that's
good,
just
give
me
what's
supposed
to
be
in
there
and
blow
up
and
panic.
If
it's
nine,
usually
you
would
only
do
that
in
development
cases.
I,
don't
recommend
doing
it.
If
you
can
avoid
it,
but
in
general
you
have
the
ability
to
easily
track
those
error
cases.
A
The
option
type
also
gives
you
the
ability
to
change
together.
So
in
this
case,
I
have
you
know
some
value,
42
and
then
I
can
map
a
function
across
that
value
and
get
back
another
option
type
with
the
result.
So,
in
this
case,
the
X
X
dot
plus
eight
that's
an
anonymous
function,
its
closure,
it's
applied
to
the
value
that
is
inside
that
sum
and
turns
that
into
50,
and
it
wraps
it
back
up
in
the
sum
and
pops
it
out
the
very
bottom
line,
the
none
I'm
applying
the
same
function
to
well.
A
In
that
case,
none
doesn't
have
a
value,
so
it
just
passes
the
none
along.
So
you
can
chain
several
operations
together
and
if
any
of
them
fail,
then
you'll
get
the
failure
case
out.
You
don't
have
to
do
a
bunch
of
explicit
error
checks
and
you
also
have
the
option
to
do
an
and
then
which
is
in
the
case
where
the
function
you're
wanting
to
pass
back
returns
an
option
itself
instead
of,
is
just
a
plain
function.
A
If
you
need
more
data
than
just
this,
failed,
you
have
a
result.
Type
result
gives
you,
okay,
an
error,
so
that
gives
you
the
stay.
For
instance,
like
the
error.
No,
so
I
need
more
data.
That's
coming
back.
I
have
a
good
value
and
I
have
some
error
value
that
needs
to
come
back.
It
can
be
a
string.
It
can
be
an
enum
of
some
sort.
Whatever
you
choose
the
type
system
once
again
forces
handling
of
all
those
error
cases.
The
same
types
of
chaining
methods
are
available.
A
A
So
some
of
the
other
features.
In
brief,
we
wouldn't
be
a
systems
programming
language.
If
we
did
not
have
some
way
of
writing
unsafe
codes,
I
mean
there's
some
things
you
just.
You
can't
be
completely
safe
about
if
you're
trying
to
do
pointer,
manipulation
because
I'm
writing
an
operating
system
or
I'm
interfacing
with
an
existing
C
library.
I
have
a
way
of
saying
this
set
of
functions.
A
Other
useful
things
are
hygienic
macros.
So
these
are
not
your
macros
like
you
would
have
as
a
C
pound
define,
which
is
just
a
simple
text:
substitution,
the
rust
macros.
You
get
the
syntax
tree
passed
to
you
and
you
can
do
operations
on
the
syntax
tree
to
generate
code
and
new
and
I
believe
rust
115.
They
added
something
called
procedure
macros
to
help.
You
automatically
derive
certain
instances
of
code
for
data
structures,
that's
very
powerful.
A
Okay,
so
building
applications
in
rust,
rust
has
a
normal
compiler
called
rust
C,
and
you
can
call
out
to
rust,
C
and
build
your
code.
That
way,
and
almost
nobody
does
it
instead.
Rust
have
something
called
cargo.
Cargo
is
a
build
tool
and
dependency
manager
for
rust.
So
if
you're
familiar
with
JavaScript-
and
you
have
something
like
NPM-
that
fetches
down
your
packages
builds
a
for
you
and
gets
them
ready
to
use
cargo
does
something
very
similar
for
rust.
It
builds
packages
called
crates.
A
Cargo
also
has
test
integration
built-in,
so
there
is
expand
cargo
tests
that
will
automatically
walk
through
all
your
source
code,
pull
out
things
that
are
wrapped
with
the
test
feature
flag,
run
unit
tests
on
our
compiled
those
for
unit
tests
and
run
them
and
then
collect
the
test
results.
It
also
can
do
integration
testing
for.
A
A
The
cargo
documentation
is
pretty
good.
It
has
a
good
getting
started
guide
it's
worth
reading
through
and
seeing
everything
that
it
can
do
so
meta
rust
also
has
support.
Our
Yocto
also
had
support
for
rust,
so
the
company
I
work
at
we,
we
used
metal,
rust
and
two
of
our
engineers
are
maintained,
errs
of
meta
rust
and
we
use
it
to
build
several
of
our
user
space
utilities
in
Yocto.
A
Currently
it
has
depending
on
which
release
you're
on.
We
have
two:
we
try
to
keep
support
for
to
rust
versions,
the
legacy
version
and
then
the
default
version
for
that
for
that
release.
So
with
Kroger,
if
you
started
with
Kroger
off
your
rust
version
would
be
112
one.
If
you
then
upgraded
to
morty
you're
still
going
to
be
pinned
on
112
one,
but
then
you
have
the
opportunity
to
move
yourself
up
to
rust,
114
they're
trying
to
do
two
versions
because
rust
releases
every
six
weeks
or
so
a
new
release
of
the
compiler.
A
A
So
another
one
of
my
co-workers
wrote
a
command
called
cargo
bitbake.
So
since
rust
has
its
own
build
system
and
its
own
way
of
specifying
what
all
of
your
dependencies
are
and
how
your
application
gets
built
up,
he
wrote
cargo
bitbake,
which
is
full
tool
to
parse
that
cargo
file
and
auto
generate
the
bitbake
file
so
that
it
will
pull
down
all
the
dependencies
while
you
still
have
network
and
then
let
Yocto
go
off
and
build
without
network.
A
Okay,
rust
is
not
all
golden.
It
does
have
a
few
rough
edges,
one
of
the
ones
that
you'll
see.
If
you
do
any
research
on
rust
and
start
playing
with
it,
and
especially
if
you
start
writing
rust
is
what's
called
fighting
the
borrowed
checker.
So
I
mentioned
before,
where
you
you
pass
everything
by
you:
pass
ownership
by
default,
but
you're
borrowing
a
lot
of
the
time,
because
you
don't
necessarily
want
to
pass
variables
around
all
the
time
and
they
can
take
your
head.
A
A
Luckily,
the
syntax
of
our
the
compiler
in
rust
is
getting
better
and
better,
and
when
you
start
seeing
these
problems,
it
now
will
give
you
any
error
message:
here's
your
code,
here's
where
I'm
you
saw
earlier
that
it's
at
this
function.
This
line
is
borrowing
this
line,
can't
let
it
happen,
here's
what
it
is.
So
it
gives
you
a
lot
of
good
explanation
as
to
how
to
fix
the
problems
in
your
code
back
when
I
started,
doing
rust
in
one
one
I
think
it
was
a
lot
harder.
A
The
error
messages
weren't
nearly
as
good,
but
with
starting
with
about
110,
or
so
it
got
really.
The
error
messages
upgraded
and
it
got
a
lot
easier
to
figure
out
like
that.
Eventually
it
does
click.
You
wind
up,
figuring
out
ways
to
rewrite
your
code
so
that
you
just
don't
have
borrowing
problems
at
all
and
generally
that
winds
up
being
a
slightly
more
functional
way
of
programming.
So
less
mutation
and
more
streaming
of
data
structures,
rust,
has
the
concept
of
stable
versus
unstable
features.
A
Well,
there's
some
useful
api's
and
pieces
of
syntax
that
are
still
unstable.
A
rust
is
a
young
language.
It
only
stabilized
about
two
years
ago
now
to
the
1.0
as
the
language
of
matures
less
and
less
should
be
unstable
and
more
useful
features
should
migrate
into
the
stable
path
since
it's
so
young
many
useful
libraries
are
still
immature.
Rust
has
very
good
built-in
support
for
threading,
but
async
I/o
is
still
kind
of
new.
A
The
last
thing
is
cargo
kind
of
locks
you
into
its
build
methodology.
It's
hard
to
do,
builds
and
rust
without
using
cargo.
The
rust
developers
upstream
love
cargo
and
don't
really
want
you
calling
the
compiler
yourself
not
to
say
you
can't
do
it,
but
it's
not
well
documented,
and
it's
not
nearly
as
easy.
A
A
More
api's
are
stabilizing
over
time,
but
compiler
changes
take
longer
they've
not
specified
when
they're
going
to
have
a
2.0
and
have
any
breaking
changes
in
the
compiler.
So
it's
it
just
takes
a
little
bit
of
time
for
them
to
get
some
of
these
APIs
standard
library
changes
in,
but
there's
a
very
active
community
writing
libraries
for
rust.
A
So
if
you
want
to
give
rust
a
try,
take
a
look
at
WWF
ORF.
It's
the
easiest
way
to
download
the
compiler
in
the
tool
chain
and
manage
all
of
that.
A
lot
of
distros
don't
have
support
for
rust
yet,
and
so
what
this
does?
Is
it
installs
into
your
user
directory?
Basically,
so
that
you
can
manage
the
updates
and
lets
you
easily
update
every
six
weeks
or
so
when
they
release
the
new
version
of
the
language?
If
you
so
choose,
are
there
any
questions.
A
A
A
It
has
some
support
for
Atmel,
like
the
atmega,
see
your
series
they've
gotten
a
little
bit
of
support
in
for
that,
but
most
of
that
is
unstable,
but
arm
x86.
That
should
all
be
good.
I
think
there's
some
support
for
PowerPC,
but
it's
an
unstable
distro,
so
I
think
you
have
to
build
it
yourself,
but
I've
not
run
into
a
place
where
it's,
where
I've
been
trying
to
use
it,
that
it
hadn't
been
supported.
A
A
B
A
A
B
A
A
Now,
once
you
built
something
so
say:
I
pulled
down,
50
crates
or
something
so
I'm,
building
everything
up
once
I
built
those
crates
once
those
don't
have
to
get
rebuilt
unless
they
update
or
unless
I
clean,
but
yeah
the
incremental
build
can
use
some
work
and
there's
active
work
in
the
rust
community
to
get
incremental
builds
a
lot
better.
I,
don't
know
what
their
schedule
is
on
that
right
now,
but
I
know
that
they're
actively
working
on
it.
A
A
Yes,
yeah
and
and
rust
cargo
tracks
the
dependencies
between
them
all
but
yeah.
If
it's
your
own
project-
and
you
have
just
hundreds
and
hundreds
of
modules-
then
yes,
it's
going
to
have
to
build
your
project
completely
every
time
because
it
has
no
way
of
knowing
until
it
builds
it
all
what
what
has
changed
until
they
get
the
incremental
build
support.
A
A
A
Yeah
yeah
built
built,
sighs
and
the
final
executable
size
can
be
a
concern.
One
of
the
advantages
of
Russ,
though,
since
you're
doing
this
statically
they
can
eliminate
unused
functions,
so
you
may
be
pulling
in
a
lot
of
code,
but
if
it's
not
ever
used,
if
it
could
determine
that
it's
not
ever
used,
then
that
will
get
thrown
out
at
link
time.
So
it
will
try
to
shrink
it.
It
does
link
time
optimization
as
much
as
it
can.
B
A
Well,
you
should
still
be
able
to
do
post
analysis
on
it
because
the
code-
that's
not
being
that's,
not
LinkedIn,
just
won't
be
there,
so
it
would
be
in
your
source
code,
but
it
won't
be
in
the
executable.
So
you
wouldn't
see
that
as
you're
debugging
it
at
all
I
mean
it
would
just
be,
like
any
type
of
you
know,
link
time
optimization
even
with
C.
You
know
if
you
pull
them
together,
a
lot
of
object
files
it'll,
throw
out
the
ones
that
you
can't
use
any
other
questions.
Yeah.
A
So
the
question
is
integration
with
I
des
and
I
had
kind
of
a
glib
answer.
The
only
IDE
that
matters
to
me
is
bi,
so
it
works
great,
but
there's
a
there
is
some
integration.
That's
I
des
I
believe
Emacs
is
getting
good
support
and
it's
not
an
IDE,
but
there
that's
another
one,
but
they're
actually
a
project
to
build
the
Emacs
C
component
in
rust.
Now
I,
don't
know
about
id
about
IntelliJ
or
eclipse,
or
anything
like
that.
I'm
just
not
familiar.
A
A
So
right
now
we
packaged
it
all
together,
so
the
dependencies
are
fetched
down
as
just
additional
source
packages
and
compiled
all
together
into
one.
So
it's
one
of
the
things
that
if
you
have
a
lot
of
rust
utilities
right
now
that
are
using
the
same
dependencies
they're
going
to
get
built
multiple
times,
they're
going
to
be
linked
in
multiple
times,
I.
A
The
download
should
only
happen
once
yeah.
The
download
should
only
happen
once,
but
it's
still
going
to
get
built.
Well,
it's
not
like
you're
building
a
shared
or
static
library.
Necessarily
you
could
structure
things
so
that
you
are
building
static,
rust
libraries
so
that
you're
only
building
it
once
that's
just
not
how
its
set
up
at
the
moment.
A
Does
it
support
dynamically
link,
so
there
is
support
for
diamond
okay.
So
rust
has
support
for
dynamically
linked
libraries
right
now,
yato
recipe.
We
are
supporting
it,
but
you
can
do
it.
The
ABI
is
not
stable
at
the
moment,
so
so
long
as
you're
using
the
same
compiler,
you
can
build
a
dynamically
linked
library,
but
the
next
version
of
the
compiler
they
won't
be
able
to
use
it.
So
you
back
to
the
old
C++
days,
yeah.
A
A
There
is
support
for
bare
metal
what
you
wind
up
having
to
do
is
run
rust
Knightley's
because
they
use,
which
are
some
of
those
unstable
features,
but
there
is
support
for
bare
metal
and
there's
a
couple
of
blog
posts
about
people
writing
os's
in
rust,
so
I
think
theirs
was
it
redox
and
so
op
has
a
set
of
blog
post
about
writing
an
OS
and
rust,
but
I've
not
personally
done
it.
So,
oh,
is
it
okay.