►
Description
It seems like most developers these days have heard about Rust, but many are still wondering if the language is relevant to them. In this talk, we'll explore why learning Rust might be of interest to you.
Rust Linz at https://rust-linz.at
Twitter: https://twitter.com/rustlinz
Ryan Levick: https://twitter.com/ryan_levick
Speak at Rust Linz: https://sessionize.com/rust-linz
A
A
See
if
I
get
drawn
on
again
all
right
so
yeah
as
I
was
saying
cloud
developer
advocates,
and
I
do
everything
related
to
russ
with
that
being
said,
I'd
like
to
give
a
shout
out
to
my
employer
so
that
I
can
continue
to
pay
the
bills,
but
also
there's
a
really
great
thing
for
those
in
austria.
There's
a
bunch
of
free
learning
resources,
some
classes
that
you
can
go
ahead
and
learn
about
azure
and
as
well
as
as
a
theme
of
the
talk
today.
A
It's
all
about
learning.
So
if
you
want
to
go
ahead
and
take
a
look
at
that,
then
feel
free
to
take
a
look
at
that
link
and
with
that
we
can
get
started
before
we
really
dive
into
why
you
should
care
about
rust.
I
want
to
have
a
couple
of
quick
disclaimers
for
everybody,
because
when
you're
talking
about
how
great
a
programming
language
is
often
times
those
conversations
devolve
into
how
terrible
other
programming
languages
are.
That
is
not
what
I
hope
to
accomplish
today.
A
So
the
first
one
is
that
there
is
no
perfect
programming.
Language
rest
has
a
ton
of
flaws
in
it.
Just
like
every
programming
language,
but
learning
those
flaws
is
a
lot
of
fun
and
we'll
we'll
talk
a
little
bit
about
them
today.
But
part
of
the
discovery
of
learning
a
new
language
is
to
learn
why
it's
not
perfect.
A
So,
when
you're
looking
to
pick
a
programming
language
for
a
certain
thing,
don't
just
take
somebody's
word,
for
it
do
a
little
bit
of
research
figure
out
what
you
think
will
be
best
for
getting
the
job
done
and
when
in
doubt,
use
whatever
makes
you
happy.
So
if
you
use
rust,
then
it
makes
you
happy
as
it
does
for
a
lot
of
people,
including
myself.
Then
that
is
it's
in
some
ways.
Reason
enough!
A
A
You
know
creating
cool
things
having
fun
and
we
don't
always
have
to
worry
so
much
about
if
we're
using
the
right
thing
all
the
time
and
lastly,
learning
can
be
an
end
and
not
just
a
means
to
an
end
and
what
I
mean
that
by
that
is
that
sometimes
it's
just
nice
to
learn
new
things,
even
if
you
don't
have
a
reason
to
learn
them.
I
have
had
several
times
in
my
career
where
I've
learned
new
technologies,
including
rest
itself.
A
When
I
first
started
learning,
I
didn't
have
a
reason
to
learn
it.
I
didn't
need
it
for
my
job.
It
was
0.10,
it
wasn't
even
really
usable
for
production
yet,
but
I
chose
to
learn
it
just
because
I
like
learning-
and
it's
worked
out
really
great
for
me-
I
now
get
paid
to
to
write
in
the
language,
but
even
if
that
didn't
happen,
sometimes
it's
just
nice
to
learn
and
it
will
have
positive
effects
later
on
in
life
and
also
can
just
make
you
happy.
So
let's
not
take
this
too
seriously.
A
A
Maybe
you
won't
like
about
the
language,
so
the
first
language
we're
gonna
start
start
with
is
the
c
programming
language
which
is
an
oldie,
but
a
goodie
and
c
has
been
around
for
quite
a
while
now
and
is
used
in
a
lot
of
things,
but
especially
in
kind
of
low
level
use
cases,
and
especially
nowadays,
with
you
know,
the
rise
of
c
plus
plus
and
then,
of
course,
the
rise
of
garbage
collected
languages
like
java,
c-sharp
and
then
going
on.
Now
we
have
a
whole
bunch
of
languages
that
we
can
choose
from
that.
A
We'll
talk
about
later
on,
there's
less
and
less
need
in
a
for
a
lot
of
programmers
to
uc,
but
it's
still
used
a
lot
today
for
a
lot
of
different
reasons,
and
that
might
be
things
from
microcontrollers
to
airplanes
to
operating
systems
and
a
lot
of
different
things
are
written
in
c,
and
that's
really
great
one
terrifying
thing
about
that
is
that
c
is
a
very
dangerous
language
and
you
can
very
easily
make
mistakes
and
that's
something
that
as
a
c
programmer
you
might
love
about
rust.
Is
that
rust
is
100
memory
safe?
A
What
do
we
mean
by
memory
safe?
Well,
if
you've,
if
you've
done
seed
programming
before
you
know
about
things
like
use
after
free
or
double
free?
These
are
common
mistakes
that
you
might
make
when
you're
handling
memory
management,
because
in
c
memory
management
is
completely
manual,
you
as
the
programmer
are
in
charge
of
it.
You
can
make
mistakes
and
one
graph
that
I
like
to
show
on.
Basically,
all
of
my
talks
now
is
this
graph.
A
This
is
a
graph
of
cves,
so
security
vulnerabilities
at
microsoft,
specifically
and
the
percentage
of
our
security
vulnerabilities
that
have
to
do
with
memory
safety
versus
not
memory
safety.
So
a
lot
of
c
programmers
out
there
are
very
proud,
which
is
good
but
they're,
very
proud
that
they
don't
make
mistakes.
And
if
you
make
a
mistake
and
see
it's
because
you're
an
idiot,
we
have
proof
that
either
most
people
are
idiots
or
that
everybody
makes
mistakes.
A
Safety
issues
this
can
be,
can
be
quite
dangerous
and-
and
this
isn't
just
microsoft,
but
this
particular
data
is
just
microsoft.
But
when
talking
with
google
apple,
basically
every
big
software
engineering
company
in
the
world,
the
figure
tends
to
be
around
this.
And
so
this
is
why
you
see
more
and
more
companies
looking
into
to
rust,
because
we
need
secure
software
and
it
is
a
bit
of
a
shame
that
we're
still
using
a
language
that
where
you
can
end
up
so
easily
introducing
vulnerabilities.
A
We
have
a
person
struct
and
just
like
in
c,
your
purse
instruct
can
have
fields
on
it
and
we
have
two
fields
name
and
age,
and
name
has
a
string
attached
with
it
and
age
is,
is
a
eight-bit
unsigned
integer
that
we
have
here
and
we're
going
to
talk
about
this
like
single
quote
a
thing
right
here?
This
is
kind
of
the
whole
point
of
this
exercise.
A
The
string
that
you're
passing
in
might
not
actually
be
parsable,
and
that's
what
this
option
here
is
option
is
simply
a
type
that
wraps
another
type
and
says
you
either
have
that
type
or
you
don't
now
in
c,
you
probably
will
would
use.
I
don't
know,
maybe
a
null
pointer
or
something
like
that,
or
a
special
value
and
rust
we're
very
explicit
about
everything,
and
you
tend
to
not
have
special
values
and
rust.
A
You
tend
to
either
have
a
value
or
you
don't,
and
this
is
what
our
our
person
code
looks
like
it's
very
easy
to
to
see
to
see
what
it
does.
We
initialize
the
name
and
age
to
both
be
none.
So
we
don't
have
a
name
and
age
when
we
start,
and
then
we
get
the
lines
from
the
string,
and
this
is
just
a
simple
function
that
breaks
up
our
string
based
on
based
on
new
line
characters.
A
A
So
by
the
time
we
have
this
line
here
and
our
4n
loop.
What
we
have
actually
is
a
lined
a
single
line
at
a
time
that
does
not
have
white
space
at
the
beginning
of
the
end,
and
then
we
ask
if
the
line
starts
with
name
colon,
then
we
go
ahead
and
get
the
rest
of
the
line,
and
that
is
our
name
and
we
wrap
it
in
the
sum
which
means
hey.
We
now
have
a
name
and
the
same
for
age.
A
You
don't
have
to
make
a
lot
of
the
trade-offs
that
you've
had
to
make
before
then
at
the
end.
Here
with
the
question
mark,
that's
simply
saying:
if
the
name's,
not
there
return
back
a
nun
at
the
end
and
same
with
age,
we
parse
the
age
as
a
number
that
we
have
right
here
and
so
at
the
very
end
we
end
up
with
a
person
and
otherwise
we
would
have
propagated
out
our
none
here.
A
So
this
is
very
high
level
code
that
we
have
here,
but
again
it
compiles
down
to
pretty
efficient
assembly
code,
something
similar
to
if
you
were
to
have
written
it
in
c.
But
what
happens
if
we
do
something?
Silly
like
this
and
and
of
course,
all
the
examples
that
I'm
going
to
be
showing
today
are
quite
simplified.
The
reason
for
is,
I
don't
want
to
spend
an
half
an
hour
explaining
a
complex
example
that
you
would
run
into
a
real
world,
but
hopefully
you
get
the
idea
even
with
simple
examples.
A
Here
we
in
this
code
right
here
we
create
a
stack
allocated
string
that
that
contains
our
kind
of
unparsed.
You
know
person
content
here
and
then
we
call
the
the
parse
function
here
now.
If
we
go
back
to
the
previous
code,
what
we're
saying
with
this
tick
a
line
here
is
that
the
lifetime
of
person
is
attached
to
the
string.
That's
inside
of
it.
So,
however
long
this
person
lives,
then
the
string
inside
of
it
needs
to
live.
A
So,
however
long
the
string
that
we
pass
in
needs
to
live,
the
person
that
we
get
out
from
this
function
needs
to
live
the
the
at
least
that
long
or
sorry
at
most
that
long
and
this
is
enforced
by
the
compiler.
So
when
we
write
something
that
should
not
work
here,
we
allocate
this
string
here.
The
string
is
living
on
the
stack
here
by
the
time
that
it
gets
to
the
end
of
the
function
and
rest,
you
don't
have
to
explicitly
call
free.
A
A
You're
going
to
have
you're
going
to
have
a
dangling
pointer
here,
we're
going
to
at
the
end
of
this
function,
free
our
string,
but
we're
going
to
return
a
person
which
is
referring
back
to
that
string
that
has
now
been
freed
and
that
you,
you
can't
do
that.
This
is
a
bug
in
this
case,
happens
to
be
a
very
easy
book
to
to
see.
But
you
know
you
can
imagine
much
more
complicated
code
and
rust
will
will
statically
enforce
this.
This
is
all
static.
There's
no
garbage
collection!
There's
nothing
going
on
here!
A
It's
just
a
static
check
here,
that's
happening,
and
in
fact
this
is
the
error
message
that
you
end
up
with
here.
We
cannot
return
a
value
referencing,
a
local
variable,
which
you
know
if
you're
coming
from
c
background,
should
probably
seem
pretty
pretty
straightforward.
Okay,
yeah!
I
know
I
can't.
I
can't
return
something
that
refers
to
something
that's
been
allocated
on
on
the
stack.
That's
that's
wrong!
A
Fault
again,
which
is
which
is
really
great
all
right:
what
about
c,
plus
plus
developers
russ
definitely
has
a
lot
more
concepts
that
kind
of
go
in
with
with
with
c
plus
plus,
and
in
fact
this
whole
thing
about
dropping
at
the
end
of
of
a
function.
It
kind
of
reminds
you
of
the
raii
pattern
that
you
have
in
c,
plus,
plus
you
just
imagine,
take
away
all
the
baggage
of
kind
of
older
c
plus
and
only
have
the
the
kind
of
newer
more
more
safe.
A
More
you
know,
high-level
concepts
that
you
haven't
seen
plus
plus
nowadays.
So
you
end
up
with
a
dramatically
simpler
language
than
c
plus
plus,
is
with
all
the
benefits
and
there's
really
no
way
to
to
mess
it
up,
because
there's
no
kind
of
older
code
styles
that
you
have
to
worry
about
so
as
a
c
plus
plus
developer,
I
think
what
you're
really
going
to
love.
A
Besides
all
that
memory
safety
stuff,
is
the
default
build
tooling
that
that
rust
comes
with-
and
I
know
we'll
talk
about
this
in
his
talk
coming
up,
but
a
lot
of
it
has
to
do
with
cargo.
The
the
build
tool,
but
we're
gonna,
take
a
little
bit
of
a
look
like
that.
Here's
us
testing
our
our
function
that
we
had
from
before
our
parse
function
here
and
you
can
see
in
this
code,
built
into
to
rust,
already-
is
a
way
to
write
unit
tests,
and
this
is
default.
A
There's
no
extra
thing
to
download
from
google
or
whoever
you
just
get
it
right
out
of
the
box
in
the
default
tooling,
and
you
can
run
tests
and,
of
course,
the
the
cfg
at
the
the
top.
There
is
a
compiler
flag,
which
means,
at
the
end
of
the
day
that
when
you
actually
build
this
for
for
production,
this
all
just
goes
away.
So
you
don't!
A
Actually
you
don't
pay
a
price
in
your
in
your
end
binary
and
you
get
to
to
run
your
tests
and
you
get
this
nice
test
output,
where
you
can
see
that
our
test
pass,
which
is
really
great.
We
don't
have
any
doc
tests,
but
there
are
also
documentation
tests
as
well,
because
the
documentation
is
built
in
and
and
we're
real
great
we're
ready
to
go.
In
fact,
when
we
build
our
program,
we
just
have
to
cargo
build
dash
dash
release
here
and
as
a
new
rust
programmer.
A
Don't
forget
the
dash
dash
release
if
you
want
to
do
some
benchmarking
or
something
like
that.
That's
a
common
mistake
that
people
make
by
default
cargo
builds
in
debug
mode,
which
is
has
optimizations
largely
turned
off,
so
we
can
go
ahead
and
build
a
release.
Build
of
our
binary
here
and
cargo
also
comes
with
run
and
and
a
bunch
of
other
features
that
I
know
we'll
surely
get
into
later
on.
A
So
that's
really
great,
and
in
fact
here
we
have
our
cargo.tamil
file,
which
is
a
file
that
describes
our
project
and
it's
a
very
standard
file
that
everybody
in
the
rest
world
knows
about.
You
don't
have
to
learn
different,
build
tooling
systems,
and
you
know,
what's
the
next
flavor
of
the
month
cargo.
Is
it
and
it's
here
to
stay
and
you
can
add
dependencies
very
easily.
You
see
on
line
eight
here,
I've
added
the
nom
library,
which
is
a
great
parsing
library.
A
If
we
don't
want
to
do,
parsing
ourselves,
but
rather
want
to
to
you,
know,
use
a
library
to
do
that.
It's
as
simple
as
adding
this
one
line,
then
what
cargo
will
do
is
go
ahead
and
fetch
the
dependency
and
all
all
of
the
the
dependencies
that
that
dependency
uses
as
well
build
them
for
you
and
there's.
I
think
a
lot
of
reasons.
Why
c
and
c,
plus,
plus
programmers
try
to
avoid
dependencies
is
because
you
end
up
with
a
lot
of
build
headaches
because
of
that.
A
But
in
a
world
where,
where
you
have
kind
of
standard
build
tooling,
then
you
can
end
up
in
a
great
situation
where,
especially
in
the
beginning
of
a
project,
pull
off
some
things
from
the
shelf
go
ahead
and
get
your
project
running,
and
you
know
what,
if
you
don't
want
to
have
that
many
dependencies
at
the
end
of
the
day?
That's
fine,
but
you
can
start
with
those
and
then
get
rid
of
them
as
you
go
along.
A
If
that's
you
know,
if
you
need
to,
if
you
feel
the
need
to,
but
this
is
a
really
great
way
to
get
up
get
up
and
rolling
it's
all
built
in
out
of
the
box.
You
don't
have
to
kind
of
configure
anything
it
all
just
works,
which
is
really
wonderful
all
right.
So
we
talked
about
the
c
and
c
plus
plus,
I
think,
by
the
way,
c
and
c,
plus
plus,
are
the
languages
that
I
would
most
strongly
encourage
people
to
to
give
us
a
try.
A
A
It
wants
to
build
low-level
systems,
it's
a
systems,
programming
language,
and
that
is
the
area
that
cnc
plus
plus
currently
occupy
these
the
next
languages.
We're
going
to
be
talking
about
russ
can
do
a
lot
of
the
same
things
there,
but
it's
definitely
not
it's
first
and
foremost
goal
to
to
kind
of
compete
in
the
same
space,
but
for
cnc
plus
plus,
it
definitely
is,
and
so
you
know
give
it
a
try.
Why
not
yeah?
I
think
you'll
you'll
like
what
you
find
there.
A
So
now
we're
going
to
be
talking
about
c,
sharp
and
java.
The
reason
that
I
combine
these
two
together
is
because
they're
both
garbage
collected
languages,
they
both
are
object,
oriented
languages.
They
come
from.
You
know
the
90s
early
2000s,
so
they
have
a
lot
of
in
common
there,
and
one
thing
that
I
want
to
talk
about.
There
is
thread
safety
now.
C-Sharp
and
java
have
garbage
collectors.
So
this
whole
thing
about
memory.
A
To
worry
about
that
with
with
c-sharp
and
java,
because
you
have
a
garbage
collector
to
take
care
of
that
for
you,
but
what
you
don't
get
in
c-sharp
and
java
that
you
do
get
in
rust
is
the
idea
of
thread
safety,
so
rust
by
by
default,
is
100
thread
safe,
meaning
that
you
don't
get
any
data
races
happening.
You
never
have
unsynchronized
access
between
two
threads
to
a
piece
of
data
you'll.
A
The
language
guarantees
that
you
have
synchronized
access
between
things
in
memory,
and
so
I
want
to
show
an
example
that
has
nothing
to
do
with
threads,
but
I
think
because
threading
can
get
a
little
bit
complicated.
I
wanted
to
boil
it
down
to
something
that
I
think
is
related
to
why
rust
works
this
way,
and
here
is
a
thing
that
actually
I
haven't
done
this
in
c
sharp,
but
I
know
in
java
throws
an
exception.
A
And
you
know
if
you've
programmed
in
java
or
c
sharp
before
or
probably
any
programming
language
you
might
know
what
this
bug
is.
This
is
a
concurrent,
a
concurrent
modification
error
here,
which,
typically
in
other
languages,
would
be
a
runtime
exception,
where
we
would
detect
oh
you're,
trying
to
change
the
thing
that
you're
currently
iterating
over
well
in
rust.
You
can
see
on
line
four
there,
barely
that
there's
a
little
bit
of
a
squiggly
line
there.
A
It
turns
out
that
in
rust
the
compiler
stops
us
from
doing
this,
where
we
cannot,
while
we're
iterating
over
an
item,
push
something
onto
it
and
the
reason
I
wanted
to
show
this
example
is
because
there
are,
there
are
a
lot
of
things
that
fall
out
of
rust's
ownership
model.
The
borrow
checker
that
you
may
have
heard
stories
about
that.
Allow
you
to
to
write
code
fearlessly,
where
you
can
write
something
like
this
and
if
it's
a
terrible
idea
that
actually
this
would
end
up
corrupting
your
vector
as
you
as
you
iterated
over
it.
A
A
A
I
picked
these
two
languages
because
they're
kind
of
like
server-side-
and
you
know
five
ten
years
old,
now
used
for
a
lot
of
web
servers
and
stuff
like
that
people
compare
rust
to
go
all
the
time,
probably
because
they
came
out
around
the
same
time
goes
only
three-ish
years
older
than
rust
is.
I
would
argue
that
go
and
rust
are
very
different
languages
from
from
one
another
meant
for
very
different
things.
A
But
one
thing
that
I
wanted
to
talk
about
as
a
go
or
node
developer
is
the
robustness
that
that
rust
can
offer
and
a
robustness
that
that
these
other
languages
don't
make
a
point
of
trying
to
provide
to
their
users,
and
this
comes
through
a
powerful
type
system,
robust
error
handling.
So
if
you're
a
go
programmer,
typically,
the
the
old
you
know
joke
about
go
is
that
you
have
to
check
for
for
nil
every
you
know.
Every
other
line.
A
Rust
does
not
has
much
more
kind
of
succinct
error
handling
than
that.
Also,
you
know
we
talk
about,
go
not
having
generics
and
things
like
that,
although,
although
it's
coming,
of
course
rust
has
that
baked
in
and
and
also
there's
a
kind
of
rough
mentality
in
russ
that
you
know
if
it
compiles,
it
works,
and
you
know,
of
course
this
isn't.
This
isn't
true,
but
sometimes.
B
A
Feels
true
for
sure,
where
you
spend
a
lot
less
time,
debugging
your
programs.
Now,
when
you're
learning
you're
going
to
spend
a
lot
of
time,
fighting
the
compiler
and
getting
your
code
to
compile
in
the
first
place.
But
the
good
thing
is
that,
as
you
learn,
that
happens
less
and
less,
and
so
one
quick
negative
part
about
rust
here
for
for
go
developers
that
I
think
in
particular
will
not
find
it.
That
great
is
that
rust
is
definitely
not
as
simple
of
the
language
or
is
not
as
small
of
a
language.
A
Language,
and
so
we'll
talk
a
little
bit
more
about
that
in
just
a
second,
but
something
to
look
out
for
here's
a
an
interesting
example
of
the
of
this
robustness.
This
is
reading
to
to
a
string
here.
This
is
a
re-implementation
of
these
standard.
Fs
read
to
string
function
here
takes
in
a
path
and
it
returns
an
I
o
result
of
string.
Now
this
I
o
result,
as
you
maybe
can
even
tell
it's
a
result
of
doing
an
I
o
operation
can
either
succeed
or
can
fail,
and
that
makes
sense
right.
A
Reading
from
a
file
system
can
succeed
or
fail.
So
it
would
be
strange
if
it
didn't
if
it
only
returned
back,
a
string
and
russ
doesn't
have
exceptions,
so
we
can't
just
throw
an
exception,
and
you
know
document
hey.
This
might
throw
an
exception.
Rust
is
very
explicit
and
says
this
thing
might
succeed
or
fail,
and
you
know
that
on
line
eight
by
seeing,
I
o
result
there
and
then
on
each
line.
We
kind
of
follow
the
happy
path.
Where
we're
opening
the
file.
We
we
allocate
a
string
buffer.
A
We
read
to
that
string
buffer
and
you'll
notice
on
line
9
and
line
11
there.
The
question
mark
at
the
end
and
that's
our
error,
handling
for
this
file.
We
basically
want
to
say
if
it
at
any
point,
there's
an
error
from
doing
this
thing
just
bubble
it
up
to
the
user
and
just
with
one
little
character.
A
That's
what
the
question
mark
operator
does
there
all
right
now
we're
going
to
be
talking
about
swift
and
kotlin
as
two
languages
kind
of
very,
very
modern
languages
to
the
languages
that
I
in
particular
have
really
enjoyed
programming
in
in
the
past,
for,
in
particular,
for
ios
and
android
development,
and
I
think
what
you'll
love
if
you're
coming
from
these
two
languages
is
the
control
that
that
rust
offers
you.
This
is
sort
of
the
the
opposite
of
the
reason
that
you
probably
love,
swift
and
kotlin.
A
Swift
and
kotlin
have
really
great
abstractions
that
allow
your
code
to
still
be
very
performant,
but
you
don't
really
have
to
worry
that,
often
about
things.
The
languages
do
a
really
great
job
of
kind
of
abstracting
over
a
bunch
of
common
concerns
like
memory
management
for
one
and
and
you
can
kind
of
focus
on
your
core
programming,
but
the
unfortunate
part
of
that
sometimes
is
sometimes
you
need
to
know
exactly
what's
happening
in
the
machine.
You
want
to
know
how
many
times
am
I
allocating
to
the
heap?
A
Sometimes
you
know
for
a
fact
that
it
will
always
be
on
the
heap
in
the
case
of
garbage
collected
language
generally
or
you
know,
you're
not
sure
it
might
be.
Stock
allocated
depends
on
the
optimizer
blah
blah
blah
blah
when
you're
doing
low
level
systems
programming.
You
need
the
control
that
that
a
language
like
russ
can
afford
to
you.
So
that's
really
fine
grain
control
over
allocation
zero
cost
abstraction.
A
Sometimes
that
can
be
unclear
or
you
have
to
be
an
expert
in
the
language
to
really
understand
it
and
it
might
change
from
from
one
release
to
another,
and
you
have
to
always
keep
on
top
of
this
most
of
the
time.
You
don't
want
to
worry
about
that.
But
when
you
do
it's
nice,
that
you
have
a
language
like
russ,
where
you
can
know
exactly
what
kind
of
runtime
performance
you're
going
to
get
and
at
the
end
of
the
day,
you're
still
going
to
have
sensible
defaults.
A
So,
most
of
the
time
you
don't
have
to
worry
about
this
stuff.
But
when
you
do
want
to
worry
about
it,
you
can
worry
about
it,
which
is
which
is
really
great
all
right
now
to
to
go
to
a
really
different
language,
python
and
ruby.
I,
my
very
first
language
that
I
ever
learned
was
ruby,
where
I
learned
ruby
on
rails
back
in
the
day
and
still
have
a,
even
though
I
don't
write
any
ruby
anymore
whatsoever.
A
A
That's
typically
what
comes
to
mind
when
you're
thinking
about
ruby
and
python
is
that
they're
not
the
fastest
languages
in
the
world,
because
typically
they
don't
need
to
be
except
sometimes
they
do
need
to
be.
You
know
if
you
have
a
rails
application
running
out
there,
you
have
a
django
application
or
you've
got
a
machine
learning
model
that
you
you,
you
know
worked
up
in
python,
a
python
script,
real,
quick,
and
now
you
really
needed
to
be
quick.
A
A
A
But
you
can
know
that
you're
at
least
getting
kind
of
in
the
same
realm
as
cnc
pulse
plus,
when
you
write
rust,
which
is
which
is
nice
to
know,
and
and
you
know
why
would
you
give
up
your
your
beautiful,
ruby
or
beautiful
python
code
for
another
language?
Well,
you
want
to
do
it
to
get
some
performance,
so
it's
nice
to
know
that
you'll
get
that
with
rust.
A
A
quick
shout
out
to
a
a
project
that
I've
actually
not
used
before,
but
I
think
it's
so
cool,
there's
a
bunch
of
there's
different
ones
for
different
languages,
and
I
picked
this
one
because
there's
been
some
some
tweeting
happening
about
it
lately.
This
is
the
the
pio3
crate
kratos,
the
term
for
rust
package,
and
this
allows
you
to
write
rust
code
and
easily
embed
it
into
python
or
to
embed
python
in
your
rust
code
as
well,
and
it's
really
great.
A
This
is
what
some
example
code
looks
like
here,
where
you
can
just
simply
annotate
a
rust
function
with
pi
function
or
a
rust
function
with
pi
module
and
then
be
able
to
add.
You
know
native
rus
code
into
a
python
module
and
to
be
able
to
use
it
simply
from
python,
even
though
it's
implemented
in
rust,
where
you
don't
have
to
deal
with
the
the
you
know,
nasty
c
ffi
that
you
would
have
to
do
manually
if
you're
writing
this
in
c
or
if
you
were
to
do
the
thing
manually
in
rust.
A
I
think
what
you'll
really
love
about
russ
is
that
you
finally
get
a
choice
for
a
long
time.
Really,
the
only
way
to
write
a
front-end
application
in
particular
was
to
use
javascript
and
of
course
you
had
coffeescript
and
you
have
typescript,
but
those
are
just
you
know
pretty
face.
You
know
pretty
face
on
top
of
on
top
of
just
javascript
they're,
not
too
too
different
there,
and
you
know
if
you're
adventurous
or
something
like
that.
A
Where
I
talk
about
building
an
emulator
and
rust,
putting
it
into
a
web
page
and
of
course
the
ui
is
still
in
typescript,
you
can
write
it
in
russ,
it's
just
a
little
bit
more.
You
know,
there's
not
a
ton
of
reason
to
do
it,
but
it
is
fun
and
you
the
whole
thing
could
be
in
rust.
I
decided
to
mix
and
match,
and
it's
it's
a
fun
thing
to
write.
A
A
So
with
all
that
said,
there's
a
couple
of
things
that
I
want
people
to
be
a
little
bit
careful
about
when
they're
they're
learning
rust.
We
as
this
lady
here,
is
having
a
great
time
on
her
skates.
But,
oh
you
know
she
makes
a
little
mistake
and
falls
over
there.
That's
definitely
possible
to
do
and
rust
as
well.
So
a
little
a
couple
of
words
of
advice
here
rust
is
not
go.
Rust
is
not
c
plus
plus
is
not
c.
Rust
is
not
javascript.
A
Rust
is
not
swift.
This
is
all
this
is
fine.
These
languages
exist
for
a
reason
and
they're
all
great
in
their
own
right,
and
so
why
would
you
want
another
language?
That's
just
like
the
language.
You
already
know
some
words
of
advice
to
you
when
you're
learning
rust
for
the
first
time.
Take
it
slow
rest
is
not
a
simple
language,
but
it
is
a
language
that
makes
a
lot
of
sense.
So
you
just
have
to
learn
the
rules,
and
but
in
order
to
do
that,
you
got
to
take
it
slow.
A
You
got
to
learn
the
basics
before
you
start
hacking.
If
you
just
go
into
rest
and
say
without
reading
the
book
or
or
you
know,
listening
to
any
tutorials
or
something
like
that,
you're
setting
yourself
up
for
frustration
so
take
a
little
bit
of
time
to
learn
the
basics
before
you
really
dive
into
heck.
There's
going
to
be
plenty
of
opportunities
to
hack
in
the
future,
with
rust,
but
at
first
just
learn
the
basics
kind
of
the
old-fashioned
way
and
reach
out
for
help.
A
I
think
this
is
the
best
part
about
rust.
Is
the
community
is
so
wonderful
and
I'm
happy
that
we
have
more
meetups
like
this?
In
that
we
can
be
a
part
of
there's,
a
ton
of
resources
online,
a
ton
of
really
great
people.
You
can
reach
out
to
and
I'll
give
you
some
resources
in
just
a
minute,
don't
don't
be
afraid
to
to
reach
out,
and
if
you
have
a
bad
experience
come
talk
to
me.
I'd
be
happy
to
to
help
out
as
well.
A
Here's
some
a
couple
of
resources
to
take
a
look
at
here.
The
rust
programming
language
by
steve,
klapnik
and
carol
nichols
is
really
great.
It's
free!
That's
why
I
put
it
up
here.
There
are
other
awesome
books
out
there
that
you
can
take
a
look
at,
but
this
one
you
can
just
hop
on,
and
you
know
check
it
out
real
quick
before
you
decide
to
buy
a
hard
copy
of
it.
A
There's
also
the
the
rust
language
website,
which
has
a
learn
section
with
a
whole
bunch
of
different
things
like
the
wrestlings
course
bus
by
example,
and
a
lot
of
links
to
places
like
our
the
rus
discord,
where
you
can
get
help
and
stuff
like
that.
So
check
that
out
a
shout
out
to
this
really
great
guy
ryan,
levick,
not
sure
where
he's
from,
but
he
does
some
awesome
streaming
on
twitch
and
you
should
definitely
check
him
out.
A
There
are
other
people
out
there
also
doing
amazing
rust
streams,
so
there's
a
whole
community.
You
know
come
find
us.
Let
us
know
what
you'd
like
to
wear
to
learn
about.
I've
been
doing
a
lot
of
kind
of
intermediate
rust
programming
streams
lately,
but
if
you're
interested
in
a
beginner
rust
stream,
something
that
I'm
thinking
about
doing
so,
just
let
me
know,
and
with
that
I
think
we
still
have
a
little
bit
of
time
for
questions.
B
Thank
you
very
much
ryan.
We
definitely
enjoyed
the
talk.
The
the
discord
channel
was
was
running
over
with
messages
during
a
talk,
especially
when
you
showed
the
c
slide.
Everybody
was
posting
their
favorite
programming
language,
ranging
from
assembly
to
php.
So,
like
the
whole
spectrum,
do
you
have
any
anything
what
assembly
or
php
developers
would
love
about
about
rust?
I.
A
Think
for
for
php
developers,
it's
probably
the
same
as
for
ruby
and
python,
so
you
kind
of
get
kind
of
the
same
thing
happening
there,
which
is
which
is
really
great
and
for
assembly
programmers.
I
guess
you
get
to
use
a
high
level
language.
Maybe
you
don't
like
that
if
you're
an
assembly
programmer
but
but
yeah
come
join
the
rest
of
us
where
we
have
curly
braces
and
if
statements
and
you
don't
have
to
worry
about
registers
too
much
so.
A
We
have
we
find
a
lot
more
vulnerabilities
ourselves
instead
of
bad
people
finding
them
before
we
do,
which
is
good.
That's
that's
good,
but
what
hey?
Wouldn't
it
be
great
if
this
number
didn't
you
know
if
this
didn't
exist
and
we
didn't
have
to
worry
about
finding
them
before
the
bad
people
did,
because
they
just
didn't
exist
in
the
first
place,
and
so
looking
at
this
number,
where
you
see
70
of
the
security
vulnerabilities,
are
memory
safety
related
and
that
from
2006
to
2018
and
by
the
way
2019
was
the
same.
A
A
Well,
one
possible
way
to
do
that
is
adopting
a
language
that,
where
you
literally
can't
write
memory
safety
bugs
that
could
be
using
c
sharp,
and
so
one
aspect
of
that
is:
let's
use
more
c
sharp.
Let's
use
more
garbage
collected
languages,
they
get
rid
of
these
a
lot
of
these
issues
as
well,
but
we're
writing
windows,
we're
writing
office.
We're
writing.
Xbox
games,
controller
microcontrollers,
we're
writing
firmware
a
lot
of
these
things.
A
C-Sharp
is
just
not
going
to
probably
be
the
language
that
you
want
to
use
because
of
it's.
It's
garbage
collector,
and
so
we
need
an
alternative,
and
so
we
we
went
out
in
the
world
and
found
rust
as
the
best
alternative
that
we
that
we
can
adopt
and
we're
I
mean
microsoft-
is
a
slow
and
big
company,
as
most
big
companies
are,
and
so
we're
not
going
to
rewrite
everything
and
rest
tomorrow,
but
little
by
little,
more
teams
are
adopting
it.
A
B
A
Devices
they
are
active,
open
source
users
of
rus,
so
that's
no
secret
there.
There
are
other
teams
inside
of
microsoft
that
are
using
starting
to
use
rust
and
really
seeing
great
results
with
it,
and
if
we
could
just
get
my
colleagues
to
write
blog
posts
quicker,
then
you
know
at
some
point
we're
going
to
be.
A
B
Regarding
this
light
that
you
just
have
open
vladimir
wants
wants
to
know,
if
you
have
any
idea
what
happened
between
what
are
the
numbers,
2009
and
2011,
and
2012
and
2014,
I
guess
where
those
big
spikes
are
in
the
graph.
If
there
has
been
some
something
that
that
changed
or
that
that
got
attention.
A
No,
I
don't
have
an
answer
for
that.
I
think
maybe
my
my
colleagues
at
the
msrc
might
be
able
to
give
a
reason.
I
do
know
from
what
they've
told
me
before
that.
For
some
reason,
security
vulnerabilities
tend
to
come
in
waves
and
they're,
not
sure
why
that
is.
But
it
seems
that
when
you
find
one
issue
that
tends
to
lead
to
others
finding
other
related
issues,
and
so
that
can
lead
to
things
kind
of
increasing
in
number
and
then
you
hit
a
drought
and
then
it
increases
the
number.
B
A
Code
because
I
work
for
microsoft,
of
course,
not
no,
I
actually
long
time
user
of
him
and
decided
to
switch
to
vs
code
because,
frankly,
that's
what
a
large
portion
of
the
rust
community
uses
every
year.
There
is
a
rust
community
survey
and
I
think,
for
the
past
four
years
now,
vs
code
has
been
the
most
popular
editor
in
the
rest
community
and
it's
a
great
editor.
I
say
that
as
a
microsoft,
employee
and
also,
as
you
know,
just
a
person
who
uses
editors,
it's
a
it's
a
it's
a
great
one.
A
I've
heard
some
some
good
things
about
it
and
I
believe
the
person
who
is
now
writing
the
what
will
soon
be
the
official
rust
language
server
implementation
was
the
original
author
of
the
intellij
plug-in
for
for
rust,
and
so
you
know
it's
all
just
a
big
party
and
everybody's.
You
know
everybody's
having
a
good
time,
so
I
I
think
probably
intellij
would
be
fine
to
use
if
that's
what
you're
you're
used
to.
B
Very
cool
yeah.
This
is
something
that
I
noticed
when,
starting
in
with
rust
that
the
community
takes
care
of
a
lot
of
things,
so
everything
everything
runs
down
to
the
same.
If
not
people
the
same
organization
and
everything
is,
is
collected
at
one
place,
and
this
was
very
very
inspiring.
I
haven't
seen
it
in
any
other
programming
language
so
far,
yeah.
A
That's
that's
something
interesting
to
to
point
out
real
quick
is
that,
although
rust
is
was
started
as
a
mozilla
project
for
for
firefox
or
originally
for
servo,
and
then
for
firefox
and
there's
still
a
lot
of
people
who
are
employed
by
mozilla
to
to
work
on
rust.
It
is
largely
a
community
collaboration
and
even
for
people
like
myself,
who
are
employed
by
microsoft
and
go
into
the
russ
community.
We're
we're
in
some
ways.
First
rests
community
members,
and
then
you
know
employees
of
our
employers.
A
Second,
when
it
comes
to
to
rust-
and
I
think
that's
really
great-
just
because
there's
not
a
lot
of
this
kind
of
corporate
infighting
between
the
different
parties
and
the
russ
community.
Now
that
might
change
you
know
in
the
future,
but
russ
is
getting
more
and
more
popular
every
year
and
the
the
kind
of
core
of
the
community,
the
core
ethos
of
the
community
has
has
remained
the
same
over
that
time.
A
B
Cool
one
last
question:
before
we
we
switch
over
to
heiner.
There
has
been
a
research
project
called
verona,
a
language
project
from
microsoft
research.
How
do
you
see
rus
future
regarding
verona
being
on
the
horizon?
Is
it
something
that
competes
with
rusty
data
god
or
or
is
it?
You
know
just
a
research
thing
that
might
go
nowhere?
B
A
So
verona
is
a
really
cool
project.
It's
part
of
the
the
effort
at
microsoft
that
I'm
a
part
of
to
make
system
programming
safer
and
for
those
that
don't
know
it's
a
it's
a
project
by
microsoft,
research
for
looking
into
how
to
make
systems
programming
safer.
Now,
why
does
microsoft
research?
Do
research
projects
is
a
good
thing.
B
A
It's
meant
to
be
that
it's
meant
for
us
to
learn
more
about
it,
because
it's
the
way
that
it
handles
memory.
Safety
is
very
different
from
the
way
that
rust
handles
it.
And
if
nobody
did
research,
then
we
would
never.
You
know,
learn
new
ways
to
do
things,
so
this,
I
think,
is
very
important
that
we're
able
to
without
worrying
about
fitting
it
into
the
rest
programming
model
without
fitting
it
into
an
existing
language.
A
The
team
is
allowed
to
just
create
a
new
language
and
see
what
kind
of
comes
out
of
it.
Now,
what
will
be
the
future
of
that
there's?
A
lot
of
things
that
have
happened
in
the
in
the
past
with
microsoft
research
projects,
the
the
most
common
one,
unfortunately,
is
that
they
just
get
shut
down
because
they've
learned
stuff
and
they
don't
need
it
anymore.
A
I
could
see
verona
becoming
any
one
of
those
things
if
it
gets
folded
into
something.
I
think
I
would
love
to
see
some
of
the
ideas
get
folded
into
rust
and
who
knows?
Maybe
that
will
happen
in
the
future
and
if
it
get
product
gets
productized.
I
am
definitely
a
language
pluralist.
I
believe
that
more
languages
is
a
good
thing,
and
so-
and
I
know
what
the
team
is
trying
to
achieve
with
with
verona-
is
not
to
take
over
rust.
A
It
is
a
very
specific
aspect
of
of
systems
programming,
so
even
if,
in
some
chance
and
and
five
years
from
now
or
whenever
verona
becomes
a
thing,
a
productized
actual
language
that
you
can
really
write
production
code-
and
I
don't
I
would-
I
would
be
very-
very
surprised
if
that
threatened
the
rust
position
in
in
the
industry
today,
and
I
I
I'm
not-
I'm
not
worried
about
it
at
all.
In
fact,
I'm
hopeful.