►
From YouTube: Matthias Endler - Why Rust?
Description
Rust is the new kid on the block. It's a system programming language that is blazingly fast and offers powerful high-level abstractions better known from dynamic languages like Ruby or Python. Rust offers memory safety without a Garbage Collector and makes low-level programming easier and more secure. I will give an introductory talk about Rust and show some of its nicest features.
A
Yeah,
it
really
happened
so
he
gets
kicked
out
and
then
one
other
guy
said
you
must
be
very.
You
must
be
devastated
that
this
happened
to
you
and
he
said.
None
I,
just
imagined
that
my
my
skull
is
myself
and
the
flesh
around
me
is
my
house,
so
I'm
always
at
home,
and
this
is
a
very
sad
story.
So
if
you
don't
have
a
neighbor,
then
just
imagine
that's!
That's
totally
fine.
Just
talk
to
your
skeleton
or
so.
A
So
we're
good
to
go
talk
of
today
is
called
y
rust,
so
I
could
have
named
it
rust
introduction
to
rust.
But,
to
be
honest,
rust
is
yet
another
programming
language,
and
so
you
yourself
might
ask
yourself
who?
Why
should
I
learn
rust?
Why
not
learn
I,
don't
know
Swift
or
law
code?
Why
learn
rust?
Because
rust
brings
something
new
to
the
table
that
was
not
there
before,
and
this
has
changed
the
game
for
all
the
other
languages
that
will
come,
and
this
is
why
I
named
it?
A
Why
Rus
not
just
rust
so
raise
your
hands
if
you
ever
played
around
with
rust
already
somebody,
okay,
you,
you
are
contributing,
so
you
some
of
you
who
have
already
a
cargo,
a
package
on
on
the
cargo
repository
yeah,
you
you're
the
dangerous
one,
then
for
the
ugly
questions
in
the
end,
this
is
going
to
be
very
lightweight
talk.
I,
don't
want
to
make
this
a
big
thing.
I
just
want
to
show
you
some
small
features,
some
code
and
then
give
you
some
pointers
on
where
you
can
go
from
there.
A
Speaking
of
the
community.
It's
very
important
for
me,
because
I
come
from
a
very
different
angle
of
programming,
so
I
work
at
trivago
I
live
in
düsseldorf
I'm
in
the
website
performance
team.
So
what
I
do
on
a
day-to-day
basis
is
look
at
profiling,
code,
optimizing
code
and
so
on,
but
actually
I'm
from
a
PHP
and
Python
kind
of
thing
and
rust
to
me
is
eye
opening
in
a
way
that
many
other
languages
try
it
but
failed
for
me
and
I
do
like
hot
chocolate.
So
that's
about
that!
A
There's
one
slide
that
will
come
up
next.
A
friend
of
mine
said:
don't
put
up
this
slide,
it's
super
confusing
and
it's
intimidating,
but
in
reality
this
is
how
I
feel
about
the
other
systems
programming
languages
yeah,
just
sometimes
they
are
scary.
You
know,
you've
worked
with
them
and
a
lot
of
people
may
be
used
to
Matt
University.
You
say:
okay,
I
know
this.
Okay,
it
works
perfect.
You
write
a
simple
application.
You
run
it
sec
fault.
A
You
say
what
the
hell
and
there's
a
lot
of
things:
you
need
to
learn
to
really
really
use
those
languages.
If
you
want
to
be
proficient
in
C++,
it
takes
just
a
lot
of
effort
and
even
then
bad
things
can
happen,
there's
even
so
many
bad
things
that
this
thing,
for
example,
even
has
its
own
logo.
So
that's
the
official
logo
of
heartbleed.
A
Now
they
created
a
logo
for
that
particular
bug
and
there's
some
discussion
going
around
how
this
happened,
but
it
can
happen
to
the
best,
even
if
you're,
the
best
C++
program
in
the
world.
You
make
mistakes
because
just
human-
and
it's
always
better
to
have
some
external
balance
to
check
you
on
your
constraints,
saying:
okay,
okay!
This
is
fine
in
99.9%
of
the
cases,
but
you
didn't
look
at
the
remaining
percentage
and
that's
where
Ross
comes
in.
A
If
you
want
to
build
something
like
open,
SSL
or
any
graphics
tool
yourself,
you
need
to
put
in
a
lot
of
effort
and
if
you
start
from
scratch,
it's
very
very
hard
systems,
programming
itself,
it's
very
hard.
You
have
manual
memory
management,
at
least
in
C
and
C++.
You
have
custom
error,
handling
that
you
need
to
do.
A
A
You
need
to
care
about
compiling
your
code,
so
not
interpreting
not
running
it
on
your
local
machine
just
by
calling
a
program,
no,
it
needs
to
be
compiled
as
binary
and
it
needs
to
be
compiled
for
your
platform.
So
you
cannot
run
the
same
binary
on
Windows
and
Linux.
It's
not
possible
and
things
like
that
and
on
and
so
on
and
so
on.
So
why
even
do
systems
programming,
then,
if
it's
so
hard
well,
because
it
enables
you
to
go
at
a
level
where
you
cannot
go
with
say
scripting
languages
like
Python
or
so.
A
This
is
just
a
boundary
that
you
cannot
cross
and
you
might
say
maybe
now
I
need
to
use
C++,
but
then
again,
I
need
to
put
in
so
much
effort
to
make
this
really
work,
and
you
say,
I'm
stuck
I
want
to
do
systems
level
programming.
Not
only
web
development.
I
want
to
do
real
applications.
I
want
to
do
farm
I
want
to
write
a
scheduler,
maybe
some
operating
system,
even
some
emulator,
but
it
cannot
do
this
at
least
not
very
performant,
and
there
are
some
constraints.
A
It
feels
that
a
bit
like
a
cargo
cult,
sometimes
you
have
those
dynamic
languages.
You
say
wow
cool,
it's
easy
to
start,
but
then
you
kind
of
don't
have
the
control
over
all
abstractions
to
go
to
the
very
low
level,
but
Russ
tries
to
change
that.
It's
also
a
systems
language.
So
just
some
facts
about
the
language.
It
was
created
by
grain
war
who
worked
at
masuleh
at
the
time,
and
he
was
doing
this
just
for
fun.
A
Just
to
say
how
can
I
make
this
work
and
then,
after
a
couple
years
as
a
side
project
Mozilla
picked
it
up
inside
wow.
That's
a
that's
a
pretty
neat
idea
that
you
had
right
there,
because
we
have
so
many
bugs
in
our
gecko
engine,
for
example,
and
so
many
public
same
web
K
a
kid
and
so
many
bugs
in
the
rendering
engines.
In
other
browsers.
A
It
is
just
a
mess
to
maintain
all
that,
and
so
they
picked
it
up.
They
founded
it.
People
came
in
great
and
left
there's
a
couple.
Other
people
that
came
in
I
like
Steve,
clap,
Nick
pieces,
Walton,
those
guys
they
were
very,
very
profound,
and
so
the
first
version
I
was
in
2010.
But
then
everything
from
there
sorry
first
major
version
was
last
year.
A
But
since
then
we
can
went
from
eight
a
one
point:
zero
to
one
point:
eight
and
the
core
hasn't
changed
much,
so
that's
a
proof
that
they
are
onto
something
it's
just
ability
that
improved
compared
to
C++
and
C.
It
tries
to
remove
the
challenging
part
from
systems.
Programming
systems.
Programming
is
challenging
and
ok,
here's
a
workaround,
but
that
doesn't
work
for
systems
programming.
If,
if
you
run
it-
and
you
made
a
mistake,
then
it
will
crash,
but
it
can
be
fun
and
what
are
some
ways?
This
can
be
fun.
A
A
It
allows
you
to
make
mistakes.
It's
totally
fine.
If
you
come
from
a
dynamic
background,
no
problem.
What
I
heard
Snoop,
Dogg
and
I
said:
that's
not
programming
language,
yeah,
yeah,
I've,
heard
of
this
of
Q
language
called
small
talk
before,
but
it
to
bridge
the
gap
from
a
dynamic
perspective
and
a
systems
level
like
that.
The
community
comes
in
very
helpful
people
on
IRC
on
the
forums
that
just
pick
you
up
and
say:
okay,
it's
cool!
You
can
use
it
all
of
those
languages.
They
they
follow.
A
A
I,
like
the
term
high
level
on
bare
metal,
I
love
language,
but
if
you
really
need
it,
you
can
drill
down
to
the
very
bottom
like
in
C++,
but
with
more
safety,
and
if
you
ever
want
to
write
your
own
emulator
or
programming
language
Russ.
This
might
be
something
that
you
want
to
look
into
if
you,
for
example,
I'm
writing
a
CPU,
emulator
and-
and
it's
very
helpful
to
have
this
little
those
little
checks
and
guarantees.
I
never
touched
something
like
this
before,
because
it's
just
out
of
my
scope,
I
thought
it's
not
also
finance.
A
A
A
So
let's
look
at
some
ross
code
and
I
was
thinking
a
lot
a
long
time
about
what
I
want
to
show,
and
I
want
to
make
it
simple
for
you
so
that
you
kind
of
can
relate
to
the
language
the
syntax
might
be
similar
to
other
languages.
But
the
semantics
are
not,
and
it's
a
big
difference.
The
semantics
are
more
powerful
than
in
other
languages,
but
just
to
get
started.
A
If
you
want
to
write
a
simple
address
book,
for
example,
you
might
have
a
struct
called
person,
a
struct
is
just
like
a
see
struct
and
you
can
also
create
structs
in
C++,
with
a
name
and
some
values.
So
let's
say
you
have
first
name
and
last
name,
and
maybe
you
have
an
age
and
then
you
can
implement
methods
or
functions
on
this
struct,
and
this
we're
very
impo
statement
comes
in
so,
for
example,
by
convention
you
have
a
new
function
and
this
new
function.
A
It
will
return
a
new
instance
of
your
person,
so
whatever
is
last
in
your
function
will
be
returned.
So,
for
example,
here
the
last
thing
and
the
only
thing
in
the
function
is
person
itself-
and
this
is
what
we
were
returned
from
that
as
you
can
see
also
in
the
return
statement
here
and
then,
if
you
want
to
use
it,
you
can,
for
example,
create
a
couple
persons
from
that.
A
In
your
address
book,
say
you
can
create
a
vector
like
in
C++
and
then
you
can
create
some
instances
of
your
persons
now
there's
one
thing
that
is
a
different
form.
Let's
say
a
scripting
language,
and
that's
this
one:
you
have
string
from
Austin,
you
might
say:
Austin
is
already
a
string
and
powers
is
already
a
string.
So
why
convert
it
to
something
like
a
string?
Well
in
systems
languages,
you
need
to
know
the
difference
between
a
stack
in
the
heap.
A
So
a
stack
is
something
local
to
your
function,
and
if
you
run
out
of
the
scope
of
the
function,
then
this
memory
will
be
freed,
but
on
a
heap
this
is
something
more
dynamic.
That
objects
will
be
created
at
runtime
there
and
they
will
be
available
until
you
remove
them
again
from
the
heap.
So
you
have
static
memory
and
dynamic
memory
if
like
and
this
one.
This
is
on
the
stack.
A
So
this
is
just
a
string
slice
as
we
call
it
in
rust
and
you
create
an
object
on
the
heap
with
this
constructor
here
and
what
it
will
do
is
it
will
copy
this
one
at
runtime
to
your
heap
and
then
it's
available
and
it
can
be
used
in
the
person
struct
here.
So
the
person
now
has
a
copy
of
this
string
and
it
also
has
an
integer.
A
That
is
also
available
and
you
can
push
this
person
now
to
our
vector
and
you
can,
let's
say,
push
multiple
persons
to
the
vector
and
if
you're
done
you
can
iterate
over
that.
So
you
iterate
over
a
vector
which
just
contains
our
persons
and
for
each
person
you
could,
for
example,
match
on
a
certain
attribute
of
it
say
match
on
the
person
age,
and
you
say
if
it's
from
0
to
18
it's
a
teenager,
then
from
maybe
18
old
enough
to
go
to
war,
and
then
everything
else
is
too
old.
A
So
very
simple,
a
matching
of
your
struct
fields
here
and
saying:
ok!
If
this
then
do
this
a
very
powerful
metaphor
that
comes
from
functional
programming-
and
this
is
some
abstraction
that
is
available
in
C++,
but
not
with
that
safe.
So
you
can,
for
example,
not
forget
a
case
with
a
match
statement.
You
always
need
to
cover
every
case
to
make
sure
that
you
don't
ignore
an
error.
So,
for
example,
here
that's
all
the
cases
that
can
appear
so
it
can
only
be
from
0
to
18.
A
A
A
Okay,
so
this
is
known
at
compile
time.
This
is
a
fixed
static
string
that
you
can
say
will
never
change
in
the
whole
time
when
your
program
is
running
it.
You
can
compare
this.
You
have
this
in.
Let's
say
the
data
block
of
your
program
in
the
binary,
and
you
compare
this
to
your
dynamic
element
to
your
dynamic
string
that
you
have
on
the
heap.
A
Here,
yeah,
but
here
you're,
using
this
to
allocate
a
new
object:
dynamically
I,
okay,
this
one
is
known,
but
still
it
needs
to
allocate
this
person
object
to
put
it
into
the
vector
after
that,
for
example.
So
it's
yeah.
This
part
is
known
at
compile
time,
but
also
is
this
going
a
bit
into
too
much
detail
right
now?
A
Maybe
we
can't
have
discussed
it
a
little
bit
later
because
we
don't
have
too
much
time,
but
there
you
know
what
you
mentioned
is
very
important:
there's
a
difference
between
a
second
heap,
and
things
like
this
can
buy
to
you
in
the
beginning
a
little
bit,
but
it's
just
a
bit
advanced
right
now,
apart
from
that
I
like
other
languages
as
well.
What
I
like
about
p2p
is
the
package
management
system
and
also
the
community.
A
They
have
a
strong
community
and
composer
is
pretty
nice
in
Python
I,
like
the
syntax
and
libraries
ago,
I
like
tooling
documentation
concurrency
in
some
way,
at
least
in
C
I,
like
the
speed
and
the
low
overhead
and
in
rust,
I
like
everything
of
that.
So
there
is
an
awesome
package
manager.
There
is
yeah
well
I.
Wouldn't
say:
awesome,
syntax,
but
it's
okay,
but
there's
definitely
awesome
documentation
and
their
speed
and
there's
also
things
that
I
don't
like
about
those
other
languages.
A
So,
for
example,
in
PHP
I,
don't
like
the
syntax
that
much
and
legacy
functions
yeah
what
comes
first,
the
haystack
or
the
needle
and
in
Python
you
don't
have
that
awesome
of
a
package
manager,
at
least,
if
you
don't,
if
you
want
to
push
something
out
to
the
public
and
open
source
and
two
versus
three
years
a
hell.
So
the
community
is
right
now
bit
split
into
those
two
versions
and
go
I.
Don't
like
the
error
handling
and
the
package
manager
is
not
super
sophisticated.
You
don't
have.
A
You
didn't
have
vendors
for
a
long
time,
so
no
versions
on
your
packages,
for
example,
all
of
them
were
globally
installed.
This
is
fixed
now,
but
still
no
generics.
Syntax
also
is
a
bit
weird
and
INSEAD
I
really
miss
the
package
manager
sometimes
and
of
course,
safety,
but
there's
also
a
lot
of
things
that
rust
is
not
good
at.
A
So
the
syntax,
you
might
say,
is
weird
fighting
with
the
power
checker.
This
is
also
what
you
mentioned
right
before
you
need
to
get
used
to
this
a
little
bit.
You
have
some
missing
packages,
because
it's
just
a
very
young
language
and
probably
a
lot
more
there's
a
couple
things
about
system
programming,
languages
that
you
can
categorize.
So,
let's
say,
let's
start
with
type
safety.
A
A
Don't
know
this
is
my
name,
but
in
reality
it's
the
money
on
my
bank
account
and
it
will
just
say:
okay,
it's
a
string
in
C++.
You
have
the
same
problem
in
go
it's
a
bit
better,
there's
type
safety.
So
what
I
mean
with
that
is
at
compile
time.
You
know
what
happens
what's
going
on
in
in
go.
This
is
sometimes
not
100%
the
case.
Also,
a
lot
of
things
are
done
at
runtime,
but
in
in
rusts.
You
do
that
at
compile
time.
A
So
you
know
your
types:
while
you
build
the
program,
it
can
never
be
unsafe
in
in
at
runtime
same
with
type
expression.
So
you
need
to
be
explicit
about
your
types
in
C
and
C++
and
you
can
be
explicit
or
implicit
in,
go
and
rust,
which
means
you
can
say,
let
I
equals
three
then
the
compiler
knows:
okay,
I
is
always
an
integer,
for
example,
it
will
infer
this
type
for
you
in
rust,
and
that
saves
a
lot
of
typing.
A
C
is
sometimes
pretty
bad
at
this.
It
does
not
support
it
then
type
checking,
there's
static,
internet,
dynamic
type,
checking
for
let's
say
a
scripting
language.
Everything
is
dynamically
checked
when
you
execute
it.
When
you
run
it
when
you
want
to
convert
it,
it
will
say:
is
this
now
working
or
not
in
rust?
For
example,
this
is
not
the
case.
A
You
can,
let's
say,
make
it
static.
Everything
is,
is
type
checked,
statically,
and
you
will
always
be
sure
that
your
types
are
sound
so
that
a
conversion
actually
makes
sense
in
C
and
C++.
You
don't
have
a
garbage
collector,
which
is
very
important
for
embedded
programming.
For
example,
if
you
have
a
little
micro
computer
and
you
want
to
run
it
well,
you
cannot
use
the
allocator
to
put
something
on
the
heap,
for
example,
because
yeah
they
might
not
be
enough
time
for
a
real-time
cpu
to
do
that.
It's
just
a
big
overhead.
A
So,
for
example,
also
garbage
collector
is
not
nice,
because
the
garbage
collector
can
stop
the
world
and
clean
up
all
your
objects
that
you
might
have
lying
around,
and
this
might
break
your
real-time
capabilities
in
rust.
You
don't
have
a
garbage
collector
built-in.
If
you
want
one,
you
can
build
one
as
a
library.
A
The
vector
might
have
grown
already,
so
you
create
a
new
reference,
so
a
new
pointer
to
the
first
element
of
your
into
your
old
vector
in
its
some
place
memory,
and
then
what
we
did
was
we
pushed
a
new
element
to
that
vector,
but
it
might
have
not
a
capacity
to
hold
both
values,
so
it
might
grow
in
to
some
other
place
in
memory.
And
what
can
happen
is
the
new
place
is
here,
but
your
old
reference
is
still
here,
so
you
have
multiple
mutable
references
to
the
same
data
and
in
rust.
A
This
must
be
avoided
and
you
don't
need
to
avoid
it.
The
compiler
will
so
in
rust.
This
might
not
compile,
it
will
not
compile.
This
is
the
new
error
message
that
you
will
get
with
the
newest
nightly
build
and
what
you
can
see
is
you
have
basically
the
same
code.
You
have
a
reference,
you
define
it
as
mutable.
A
You
also
have
a
mutable
vector
here,
but
if
you
want
to
compile
it,
it
will
say:
okay,
here
you
have
a
mutable
borrow,
and
here
you
have
a
mutable
borrow,
and
the
borrow
is
a
very
important
term
in
rust.
I
will
show
you
the
different
types
of
memory
usage,
so
it
can
guarantee
you
that
there's
no
sec
faults,
no
data,
races,
no
null
pointers
to
me.
It
feels
a
bit
like
having
this
guy
sitting.
Next
to
me,
everybody
knows
this.
Guy
some
nodding
faces
I
love
this
guy.
So
this
is
from
karmic.
A
He
wrote
doom
and
quake
and
he's
one
of
my
super
heroes.
When
it
comes
to
programming-
and
he
knows
C++
probably-
is
one
of
the
ten
best
C++
programmers
in
the
world.
He
would
say
well
you're,
freeing
it
here
and
you're,
freeing
it
there
that
doesn't
work
or,
oh
you
sure
about
this-
might
be
not
pointer
right.
So
I
have
the
little
Tron
karmic
built
into
the
compiler
and
elected
there's
three
different
types
of
let's
say:
data
references
in
rust.
A
A
Even
if
it's
a
quarter,
you
can
tune
that
car.
You
shouldn't,
you
have
total
control
over
it.
In
this
read
write
and
then
you
have
mutable
boroughs,
which
means
you
can
take
it
and
you
can
modify
it.
But
it's
not
yours.
It's
like
a
guest
book.
Somebody
gives
it
to
you.
You
write
your
name
in
you,
give
it
back
you're,
not
the
owner,
you
just
you
can
modify
it
and
you
do
that
with
saying
and
mute.
A
A
It
there's
no
locking
because
it
will
check
at
compile-time
if
you
break
this
rule
in
some
place.
So,
for
example,
if
if
you
have
two
places
where
you
see
variable
and
they
run
sequentially,
that's
totally
fine
for
the
compiler
compiler
say:
okay,
I
use
it
here,
but
you
you
give
it
back
and
then
somebody
else
uses
in
perfect.
A
You
fine,
but
if
you,
if
it
will
see
that
maybe
have
your
multi-threaded
programming
program
and
they
will
access
the
same
amount
of
memory,
it
will
tell
you
this
is
not
okay
and
then
you
can
say:
okay,
maybe
I
need
a
mutex
or
I
need
some
other
way
of
locking
or
a
lot
free
data
structure.
But
that's
up
to
you,
then
it
will
give
you
some
freedom
there,
but
it
will
definitely
tell
you
when
you
have
more
than
one
access,
but
it's
smart
enough
to
see
when
it's
just
sequential
and
it's
fine.
A
A
Yeah,
that's
that's
also
very
interesting
question
you.
Basically
it
will
create
some
kind
of
flowchart
internally
and
it
will
say
add
it
makes
sense
to
me
and
we'll
just
look
for
breaches
in
those
flowcharts,
and
so
you
have
in
the
flow
graph
you
can
see
there
might
be
a
double
access
here,
yeah
and
that's
very
news-
research
from
the
last
10-15
years
that
they
built
into
their
language
from
coming
from
academics.
So
this
is
what
you
don't
get
in
other
languages.
A
You
don't
get
that
control
flow,
static,
analysis,
type
of
stuff
at
compile
time,
and
then
you
can
have
an
immutable
bottle.
You
say
you
can
have
many
many
copies
of
that.
So
imagine
you
watch
a
movie
with
your
friends.
Everybody
is
watching
the
same
movie
at
the
same
time,
but
you're
not
modifying
the
movie
you're
just
watching
it.
A
So
that's
an
immutable
borrow
and
you
just
remove
the
mute
here
and
you
get
back
an
immutable
borrow,
so
that
was
very,
let's
say,
language,
specific
I'm,
more
of
a
hands-on
type
of
guy.
So
maybe
you
say:
okay
I
want
to
write
some
roast
code.
What
are
the
idea
is,
what
can
I
use
so
there's
a
visual
studio,
that's
not
a
screenshot
of
mine,
it's
running
on
Windows,
it's
has
its
said
to
be.
It
has
very
good
ruff
support.
By
now
they
will
work
on
a
lot
of
integration.
Here.
A
I
mainly
use
this
one
because
it
runs
on
Mac,
a
Visual
Studio
code
and
recently
they
released
a
rustic
old
plugin
and
it's
very
awesome.
You
can
get
the
slides
after
the
presentation.
There's
there's
a
couple
links
in
there
for
you
to
set
it
up,
but
what
you
get
gives
you
code
completion.
It
will
give
you
a
compiler
built
in
and
and
everything
highlighting
pretty
awesome,
and
it's
just
an
extension,
but
if
you
are
more
of
an
exome
type
of
guy
also,
this
one
is
pretty
nice
language,
rust
plugin
at
Adam.
A
A
I
will
get
some
message
here
at
the
bar
and
it's
just
a
bit:
hacky
there's
cargo
cargo
is
a
package
manager
for
system
programming
languages,
and
this
is
specifically
for
rust,
and
this
imagine
there's
a
package
manager
for
this
language
and
there's
no
package
manager
for
at
least
no
standard
one
for
C++
or
C.
So
how
do
you
know
what
stuff
is
out
there
and
if
you
share
something,
how
can
somebody
else
integrate?
It?
A
That's
a
real
problem
in
the
real
world,
but
they
did
something
very
right
with
this
tool
because
it
has
everything
built-in
you
can
build,
you
can
create
documentation
for
it
automatically.
You
can
create
a
new
project.
It
will
set
up
a
git
repository
for
you.
You
can
run
it.
You
can
test
your
unit
tests.
You
can
run
benchmark
tests
which
I
will
not
go
into
today.
You
can
update
the
dependencies
of
your
tool.
You
can
search,
you
can
publish
and
you
can
install
it
even
on
your
local
machine.
A
Of
course
it's
a
very
young
language,
so
there's
some
tools
that
are
missing
and
there's
some
tools
that
work
great.
So,
let's
go
through
that
list.
Unit
testing,
as
I
said,
is
built-in.
You
have
a
function
and
you
can
write
a
test
with
just
a
this
test
meter
tag
here
and
whatever
is
written
below
it's
just
unit
tests
that
will
be
executed
very
awesome,
there's
support
for
unit
tests
and
their
support
for
integration
tests
already
built
in
and
benchmarks.
A
As
I
said,
the
package
manager
supports
all
that,
so
it
supports
build,
run
install
then
you
have
syntax
highlighting
as
I
showed
you
in
many
programming
languages
in
in
IDE
s,
formatting
is
done
by
rust
format,
which
is
similar
to
go
form
it.
It
will
do
the
right
thing,
so
you
should
run
it
on
safe
code.
Completion
is
done
by
racer
uhm
debugging
support
is
pretty
hacky,
so
there's
3
DB
support,
but
don't
want
to
talk
about
it.
A
Clippy
is
nice
for
static
analysis
as
a
linting
tool.
You
have
cargo
bench
for
benchmarking.
Profiling
is
awesome,
not
done
yet
there's
something
like
torch,
which
looks
a
bit
like
this.
So
it's
a
tracing
filer
and
it
will
show
you
how
many
calls
it
had
for
each
line
very
useful.
For
example,
here
you
might
say:
okay
I
want
to
optimize
this
part
and
because
maybe
the
the
square
root
is
a
bit
expensive
to
calculate
here
will
tell
you
pretty
awesome
guide
is
a
logic
shout-out
to
this
one.
A
A
A
You
can
click
on
them
later,
like
a
safe,
open,
SQL
wrapper,
my
sequel
wrapper
very,
very
nice
or
safe
OpenGL
wrapper
some
bonus
links.
If
you
have
time
go
to
the
roast,
Amsterdam
meetup
never
been
there,
but
those
guys
sound,
pretty
cool.
We
have
a
cologne
meetup
in
in
Germany
view,
are
very
welcome
to
join.
A
A
A
They
are
good
friends,
I
would
even
say
this
is
not
rust,
rust
in
maybe
semen
in
Ruston,
but
I
wanted
to
have
it
the
different
way,
because
I
would
say:
Russ
is
more
powerful
and
nobody
really
likes
a
Robin,
but
he
has
to
are
on
it
or
any
side.
Socket
foreign
function.
Support
is
very
nice.
You
can
remove
this
standard
library.
You
can
replace
everything
that
is
built
there
and
you
can't
just
run
it
from
Ruby
or
Python
as
an
extension,
and
it
will
just
work.
It
will
not
even
find
out
the
difference.
A
A
A
A
Okay,
let's
say
you're
a
web
developer,
just
assume
you're
a
web
developer.
No
I
was
expecting
this
okay,
then
let's
do
something
else:
okay,
just
assume
you're
game
developer.
You
write
an
OpenGL
game
like
the
next
doom.
You
can
use
gloom
right
now,
which
is
a
wrapper
around
OpenGL
without
the
error
checks,
because
the
error
checks
will
be
done
at
compile
time,
so
it
will
run
even
faster
than
C.
It
will
run
your
open
called
faster
and
C
because
you
can
disable
those
checks.
A
I
was
if
you
read
this
code,
you
blown
away,
because
this
is
exactly
why
it's
very
useful
you
get
to
a
lower
level.
Even
then
see
exactly
the
same
for
diesel.
You
have
an
SQL
wrapper
and
usually,
if
you
use
a
norm
and
object
relational
mapper,
I
guess
then
you
know
it
might
be
some
overhead,
but
in
rust
it's
not
overhead,
it's
even
a
performance
gain.
A
So
the
newest
version
is
faster
than
writing
your
SQL
yourself
because
it
uses
I,
don't
know
I'm,
not
an
expert
in
that,
but
some
kind
of
caching
for
there's
some
kind
of
string.
Caching,
for
the
SQL
queries
statements,
and
so
it's
faster
than
executing
that
from
a
normal
SQL
statement,
but
look
it
up.
I
mean
too
much.