►
From YouTube: Armin Ronacher: A Python and Rust love story
Description
Our experiences at Sentry of marrying Rust and Python and why it’s a great match for many applications. We will go over a quick intro to Rust, how to translate common concepts from Python to it, and how to make extension modules in Rust.
A
A
A
So
I
originally
worked
a
lot
of
libraries
like
flask
and
other
things,
and
then
about
two
years
ago,
I
worked
or
I
started
working
on
a
software
project
called
century,
which
is
a
software
service
crash
reporting
service
and
one
of
the
nice
things
about
this.
Is
it
gives
you
the
opportunity
to
optimize
like
processes
that
we
have
to
do
and
I
started
playing
around
with
rust
in
this
context
a
little
bit,
and
so
this
is
my
experience
report
about
how
would
it
rust
that
century
and
how?
A
Maybe
you
can
utilize
rust
in
in
your
own
projects?
If
you
want
to
find
me
on
the
internet,
these
are
some
of
the
locations
that
you
can
do
so
I
mentioned
built.
This
thing
now
work
at
century,
and
the
lot
of
people
have
talked
to
me
recently
over
the
last
couple
of
years.
Whenever
they
talk
to
me
in
person,
I
heard
that
you're
doing
rust.
Now
do
you
still
do
Python,
and
the
answer
is
that
yes,
I
still
do
Python.
A
In
fact,
I
love,
Python
century
loves
Python,
and
there
are
a
lot
of
reasons
for
a
loving
Python
that
didn't
change
or
the
last
couple
of
years.
The
biggest
one
is
that
the
ecosystem
is
really
strong,
and
this
is
something
that,
for
instance,
if
you
compare
to
rust
the
rust
ecosystem
is
very
specific
in
some
areas.
It's
very
good.
They
happen
to
overlap
a
little
bit
with
the
work
that
we're
doing,
but
it's
different.
The
the
the
ecosystem
is
very
hard
to
get
rid
of.
A
So,
for
instance,
if
you
need
mud
for
mathematical,
prodding
libraries
like
mad
foot
lip
or
statistical
everies,
there
is
a
lot
of
stuff
already
there.
It's
really
good
to
use
a
lot
of
there's
already
written
in
C,
for
instance,
behind
the
scenes,
so
you
actually
get
performance
out
of
this
as
well.
So
there's
no
reason
for
dropping
that,
because
one
of
the
arguments
factory
using
rust
is
performance,
so
we
use
for
us
to
augment.
A
We
don't
use
it
to
replace
it.
Is
it
particularly
true,
because
Pythian
is
very
good
at
fast
iteration,
something
that
rust
is
not
good
at
the
compile
times
and
rust
are
not
particularly
great
and
it's
a
compiled
language,
so
iteration
speeds
are
not
nearly
as
close
as
you
have
as
Python,
and
this
is
I
think
the
biggest
redeeming
quality
of
Python
compared
to
many
of
the
other
systems
that
were
using
is
that
the
ecosystem
is
very
stable,
there's
very
little
breakage
that
comes
with
package
updates.
It's
very
rare.
A
That
deployments
fail
because
of
something
there's
one
famous
case
that
was
recently
where
I
think
setup
tools
got
an
update
that
broke,
but
it's
very
rare
in
comparison,
for
instance,
to
our
front-end
JavaScript
applications
where
stuff
moves
so
quickly
that
sometimes
it
just
doesn't
work
for
us.
Also
one
of
the
good
features
in
five
minutes
that
has
very
powerful
meta
programming,
which
makes
it
very
possible
for
us
to
build
ap
eyes
that
are
really
nice
to
build
internally.
A
We
can
instrument
a
lot
of
the
codes
so
that
we
can
see
what
it's
doing
at
runtime
and
we
have
fast
interpreter
introspection,
which
means
that
we
can
actually
see
variables
when
a
crash
happens.
We
can
look
at
the
frets
that
are
running,
so
it's
for
building
software
service
applications
is
really
great,
and
this
doesn't
at
all
apply
to
rust.
A
A
Applications
and
those
crashes
involve,
in
some
cases
dealing
with
raw
binary
data
and
and
Russ
is
actually
really
good
at
this,
because
rust
is
least
partially
written
in
rust
and
since
the
compiled
language
it
has
binding
style
I'll,
be
it
has
lots
of
people
that
wrote
libraries
for
parsing
Marshall
files,
which
are
with
ten
binaries,
so
there's
a
lot
of
functionality
which
we
can
use
in
rust.
That
would
also
exist
in
C++,
which
doesn't
exist
in
Python,
so,
whereas
breathing
this
works
really
well.
Reliability
is
also
for
rust.
A
So
what
we
use
it
for
is
I,
don't
know
if
you
ever
heard
of
dwarf
files,
but
it's
a
it's
a
debug
format
and
the
libraries
for
rust
that
can
parse
this
format
and
the
only
other
libraries
I
know
that
do
this
are
written
in
C
and
C++
and
it's
a
lot
more
fun
to
work
in
rust
and
in
C++.
So
that
was
a
big
argument
for
picking
us
ma,
who
is
some
is
a
binary
format
for
Mac,
binaries
and
iOS.
Miner
is
so
there's
also
a
really
good
support
for
this.
A
We
also
parse
travel
script
source
maps.
That
was
the
first
thing
we
did
with
it.
It's
huge
chasing
dumps
and
actually
turned
out
that
that
was
from
a
performance
perspective.
Doing
that
in
earlier
was
not
a
good
idea.
Recently
we
decided
to
mean
Program
Files,
which
also
like
huge
text
files
that
need
to
be
parsed,
and
then
we've
built
a
command-line
utility
in
it.
The
first
way
of
those
things
are
actually
written
as
peyten
modules,
so
there
this
is
a
rest
library.
A
The
run
is
available
from
the
pipe
interpreter,
whereas
the
command-line
tools
is
a
full
Russification,
but
has
no
pipe
in
it.
So
if
you
use
Python,
then
it
makes
a
lot
of
sense
to
see
like
how
is
compared
to
rest.
As
far
as
the
basic
sort
of
tooling
goes,
I
think
we
have
a
lot
of
tools
that
we
have
to
work
with.
I
think
the
majority
of
us
are
probably
using
virtual
end
of
pipe
digital's
and
set
up
tools
and
in
rust
that
comes
out
of
the
box
in
form
of
two
utilities.
A
One
of
them
called
rust
up.
Rasta
is
a
way
for
you
to
manage
multiple
rust
installations.
So,
instead
of
installing
rust,
you
install
rest
up
and
then
rest
up
manages
here,
rest
installations.
So,
for
instance,
you
can
track
stable
or
beta
releases
at
the
same
time
and
you
can
switch
on
a
project-by-project
basis
between
them.
The
nice
thing
about
rest
up
is
also
that,
unlike
most
other
managed
like
multiple
Python
or
Ruby
managers,
it
also
comes
with
a
full
documentation.
A
A
A
The
the
second
set
of
tools
that
is
quite
useful
for
this
is
it's
called
Rostock
and
Rostock
can
build
documentation
out
of
your
rust
projects.
So
if
you
have
a
library
or
an
executable
and
there's
functions
and
structs
and
all
kinds
of
other
stuff
in
there,
you
can
just
run
a
cargo
dock
and
it
will
build
the
documentation
for
it
with
the
help
of
Rostock
and
it
opens
up
in
the
browser-
and
you
can
read
it
it's
a
little
bit
like
pi
dock,
it's
less
like
stings,
so
it
will
open,
it
will
build.
A
Documentation,
looks
a
little
bit
like
like
every
object
in
your
API
and
then
the
documentation
string
for
it
right.
It's
very
convenient
that
it's
built
in,
and
it
also
means
that
if
you
have
dependencies
in
the
application,
if
you
do
cargo
dock,
it
will
also
build
a
documentation
for
your
dependencies,
which
means
that
you
don't
have
to
go
to
the
internet
to
consult
the
documentation.
It's
always
there
and
it
is
the
documentation,
the
correct
version,
which
is
really
good.
So
this
is
restore
the
documentation
builder.
A
So
I
have
a
lot
of
code
on
the
slides
and
I
think
for
the
most
part
you
can
kind
of
ignore
it.
It's
just
sort
of
a
way
as
a
taste
to
see
how
the
language
looks
like.
So
this
is
the
obvious
one.
I
hope
it's
big
enough.
It's
it's
hello
world!
It's
a
function
called
main
prints,
hello
world,
but
he
already
shows
one
thing
which
I
think
is
interesting
for
rust.
A
A
You
own,
you
can
also
write
compiler
plugins
for
the
language,
so
a
lot
of
the
more
involved
libraries
for
rust
will
have
some
of
this
meta
programming
code
in
it.
This
is
a
second
slide.
I
want
to
film,
which
is
it
should
show
two
things:
I,
don't
know
how
well
I
will
do
that.
But
the
first
part
is
there
is
some.
It
will
show
you
a
little
bit
how
input
syntax
looks
like
it's
more
or
less
similar
to
how
you
do
it.
You
have
modules
you
can
import
stuff
from
it,
but
they're
two
differences.
A
The
first
one
is
in
line
you
can
see,
there's
a
hash
map
being
imported
and
it's
a
type
and
it's
a
type.
That's
generic
over
the
stuff.
That's
in
the
hash
map,
so
it's
like
a
dictionary,
but
unlike
a
Python
dictionary,
which
can
store
arbitrary
objects,
this
hash
map,
when
created,
will
be
restricted
to
a
certain
set
of
types
and
the
biggest
one.
A
The
biggest
restriction
you
will
see
here
is
that
we
are
actually
reading
strings
from
the
from
the
coma
from
the
assignment
input
and
these
strings,
because
they're
read
here
and
sort
of
this
in
the
middle
of
the
screen,
there
will
be
stored
in
the
hash
map
as
a
string.
So
this
is
the
hash
table
from
that
moment,
be
restricted
to
strings
only
and
the
reason
why
you
don't
ever
see
that
this
is
a
hash
map
of
type
string
is
because
rust
will
actually
infer
the
types
for
you.
A
So
you
don't
have
to
write
this
a
hash
map
of
string
to
string
string
to
integer,
because
we're
counting
up
its
it's
a
hashmap
that
will
automatically
get
this
type
information,
and
the
second
thing
I
want
to
point
out
is
that
there's
an
import
up
there
for
a
thing
called
a
freed,
but
if
actually
looks
through
the
slides,
there
is
no
Ezra
code.
There
is
no
puff
read
anyway
here
and
what
this
does
is
it's
a
trait
and
traits
are
a
little
bit
like
in
Python.
This
special
underscore
methods.
A
So
friends,
if
you
want
to
add
a
plus
a
a
plus
B
in
five,
maybe
a
under
under
under
under
B
traits
are
similar
to
this.
So
traits
are
wastes
at
special
behavior
to
objects,
even
if
the
objects
are
not
yours,
so,
for
instance,
puff
read
is
the
behavior
for
for
all
the
methods
for
doing
buffered
reading
on
something.
So
when
I
create
a
buffer
puff
reader
in
the
middle
of
the
screen,
the
Alliance
method
will
magically
appear
just
because
buffer,
it
is
in
context,
so
I
can
add
methods
on
to
other
things.
A
This
way,
the
the
interesting
thing
about
rust
is
that
it
tracks
ownership.
So
if
you,
for
instance,
here
change
my
visitors,
this
used
to
be
a
conversion
of
items
into
an
iterator
and
that
it
only
takes
the
first
ten
items
if
it
change
it
to
counts,
which
is
an
object
from
up
there.
It'll
actually
not
compile,
and
the
reason
for
that
is
that
it
will
tell
you
that
this
object
has
been
moved
into
something
else.
A
So
rust
follows
a
very
strict
ownership
idea
that
any
object
can
only
have
one
owner
and
that
owner
can
borrow
it
out
to
some
limited
degree,
but
it
will
stop
you
at
compile
time
from
doing
all
kinds
of
stuff.
That
would
be
perfectly
fine
in
another
programming
language.
So
that's
how
this
looks
like
for
the
most
part,
but
I
want
to
show
you
that
rust
is
actually
very
close
to
PI.
For
me,
in
many
ways
it
follows
the
the
sin
of
Pi
I.
A
Think
it's
a
beautiful
language,
and
one
of
the
ways
in
which
is
beautiful
in
my
mind,
is
that
it
has
a
lot
of
support
in
the
language
for
effectively
automatically
doing
things
that
are
very
boring,
and
so
friends,
if
you
have
a
written,
a
Web
API
in
Python
or
you
consume
the
Web
API.
A
lot
of
the
things
that
you
will
do
is
manually
pause,
some
trees
and
stuff
drag
it
in
break
it
out
with
rust.
You
have
this
automatic
ability
to
the
right
thing
and
since
by
saying
this
the
right
means
Eliezer.
A
It
will
automatically
make
this
struct
into
something
it
can
see.
Your
license
is
chasing
and
I.
Don't
have
to
do
that
and
then
this
is
from
actually
more
or
less
copy
pasted
from
one
of
our
tools.
This
does
an
HTTP
request
and
then
automatic
converts
it
into
a
list
of
deployments.
So
it's
like
the
entirety
of
serialize
and
deserialize
is
covered
in
hitman.
For
you,
it
follows
pythons
general
rules
of
being
explicit
rather
than
implicit
biggest
one
is.
There
is
no
none
in
the
language,
so
everything
has
to
be
explicitly
set
as
optional.
A
Then
it's
funny,
you
think
follows
the
idea
that
simplicity
is
better
than
complexity.
I
want
to
just
generally
show
you
that
this
looks
more
or
less
like
Python
codes.
I
mean
obviously
it's
different,
but
it
definitely
doesn't
look
like
C
code
or
C++
code,
even
though
it's
at
this
very
low
level-
and
this
is
an
example
from
Redis
library
where
you
can
do
very
complex
operations
with
it,
and
it
doesn't
really
look
very
complex.
A
It's
just
a
nested,
not
less
the
cause,
it's
chained
calls,
and
this
I
think
is
the
best
part
of
the
language.
Is
it
gives
you
a
lot
of
it
gives
you
a
lot
of
information
about
what
you're
doing
wrong
through
linters
and
warnings
and
compiler
errors,
so,
for
instance,
here
I'm
opening
a
file
but
I'm
never
handling
the
error
that
being
returned
from
it
in
in
C.
That
would
be
like
not
a
warning
at
all,
because
it
wouldn't
even
know
if
you
have
to
do
something
return
value
in
rust.
You
can
explicitly
define.
A
A
Errors
are
very
different
and
I
think
that's
the
part,
that's
really
relevant.
If
you
want
to
use
rust
with
Python.
By
often
you
want
to
build
extension
modules
and
errors,
you
have
to
make
sure
that
they
are
being
caught
within
rust
and
then
translated
over
to
the
Python
world.
In
some
way,
there
are
two
mechanisms
for
errors
and
rust.
One
of
them
is
called
panics
kind
of
like
exceptions,
and
the
second
one
is
is
explicitly
returning
results
and
that's
basically
like
returning
a
special
value
that
indicates
failure.
A
That's
I
think
the
interesting
parts
that
yes
a
rest
program.
We
have
very
quickly
seen,
and
but
it's
a
concept
doesn't
really
exist
in
Python
as
much.
If
you
raise
an
exception
in
Python,
it
bubbles
up
to
whoever
decides
to
call
it
down,
I
catch
it
down.
It's
very
often
used,
for
instance,
a
library
like,
let's
take
a
request
for
an
example,
anything
HTTP
requests.
A
Instead
of
getting
a
requests
exception,
you
might
get
the
socket
IO
error
and
the
reason
for
that
is
that
nothing
in
in
accepting
requests
caches
down
the
IO
error
and
converts
into
something
else.
So
you
can
have
these
errors
bubble
up
and
that
might
be
errors
in
it,
which
you
don't
really
expect
from
the
API
in
rust.
It
come
to
that
when
you
propagate
an
error,
you
have
to
convert
the
error
into
a
common
type
or
you
have
to
handle
it
internally.
A
So
there's
an
idiom
in
rust
called
the
question
mark
operator
which
will
try
to
execute
an
operation
and
when
it
fails,
will
convert
the
error
into
the
common
area
of
a
library.
So
a
user
of
your
code
only
sees
one
error
type
and
that
might
have
sub
error
types.
So
if
you
want
to
try
it,
the
way
to
do
it
I
would
recommend
is
to
build
extension
modules
and
I.
Had
this
argument
with
a
bunch
of
people
that
said
like
the
future
is
service-oriented
architecture.
A
You
should
build
like
individual
rust
services,
individual
ghost
services,
that
this
would
speak
network
calls
to
each
other.
That's
a
lot
of
complexity
and
I.
Don't
actually
think
it's
a
good
idea
and
there
is
definitely
more
to
the
world
than
a
monolithic
application
and
service-oriented
architecture.
I
think
it's
absurd.
The
solution
for
this
is
modular
code,
have
individual
bits
and
pieces
that
can
be
individually
deployed
and
then
just
live
in
the
same
interpreter.
So
extension
modules
is
a
very
good
way.
So
how
do
you
marry
time
and
rust?
A
And
this
is
the
part
where
I
find
a
little
bit
of
frustration
in
it,
because
I
I
think
I
found
a
really
good
way
in
which
it
could
theoretically
work,
but
in
practice
it
involves
a
lot
of
pain
and
sweat
and
tears
because
of
setup
tools
and
I.
Don't
know
if
you
ever
use
setup
tools
like
internally
tried
to
make
it
work
in
ways
in
which
was
not
originally
intended
to
be
used.
A
So
the
way
I
would
recommend
or
way
I
would
like
it
to
work
and
I
can
give
you
an
indication
of
how
good
it
actually
works.
At
this
point,
is
you
build
rust
library
you
make
a
C
API
for
it,
which
is
more
or
less
means
the
rest
of
it
can
be
consumed
through
CF,
fi
or
C
types.
If
you
want,
and
then
you
import
it
in
Python.
The
tools
for
this
is
cargo,
CFI,
a
set
of
tools
and
and
the
real
thing,
and
this
is
sort
of
what
I
want
to
achieve.
A
It's,
not
you
sleep,
because
I
I
will
skip
ahead
a
little
bit
because
I
want
to
show
you
this
point
here.
It's
arable
this
here.
If
you
ever
went
to
the
pip
page
of
pillow,
it's
a
library
written
in
C,
it
is
images
and
whenever
these
people
make
a
new
release
their
heroes,
because
just
for
Python,
2
and
PI
3,
not
counting
I,
think
Windows
is
not
on
there.
A
So
the
path
of
success
is
not
linked
to
lip,
but
you
see
FFI,
because
then
this
is
what
we
do.
You
end
up
with
just
package
name
in
the
wheel
format,
just
the
version
it
works
with
Python
and
Python
3.
It
doesn't
have.
It
doesn't
think
as
the
Python,
so
there's
no
ABI
and
the
only
thing
you
have
to
do
is
at
the
platform
tag
and
theoretically,
you
can
build
get
away
with
rebuild,
ignoring
Windows
Windows
boot
before
builds,
and
you
can
do
this.
A
So
there's
a
catch
to
this,
and
this
is
where
it's
absolutely
absurd.
You
need
to
basically
build
version
of
your
library
if
to
have
it
running
on
the
next,
with
a
very,
very,
very
old
version
of
Linux,
so
you
can
install
these
docker
images.
It's
called
many
Linux
one
I,
don't
have
anyone
ever
built
binary
wheels
for
Linux
No,
so
the
way
it
works
is
these
docker
images,
if
you
install
them
in
your
locker
they're,
very
old,
they
have
an
ancient
version
of
CentOS
in
it
and
I
think
so.
It
Stephanie
not
supported
anymore
I.
A
Think
at
this
point
it's
eight
years
old.
It
doesn't
do.
Is
it
basic
on
20
has
a
sell
requests
to
any
modern
server
because
it
doesn't
support
SNI
and
is
really
super
painful.
There
are
some
modern
tools
in
it,
but
more
or
less,
not
really
so,
for
instance,
days
and
ancient
version
of
the
new
compiler
collection
there
and
all
kinds
of
stuff,
and
this
is
sort
of
the
best
way
to
build
binary
extensions
for
Python
and
it's
a
super
manual
process.
So
this
is
sort
of
my
points
to
raise
awareness
is.
A
It
would
be
really
cool
if
people
that
have
an
interest
in
either
s
extensions
or
C++
or
C,
and
that
feel
a
pain
and
maintaining
this
to
bundle
together
and
don't
work
on
a
way
to
actually
bridge
between
Python
and
rust,
or
between
Python
and
C++.
That
doesn't
require
lip,
so
I
would
quickly
show
you
roughly
how
this
looks
like
the
bridge
between
rust
and
Python.
Is
you
have
an
error
handler?
A
This
error
handler
is
more
or
less
set
up
that
when
you
actually
erase
and
a
panic
and
exception
in
rust,
nothing
happens,
then
you
need
to
make
a
function
that
you
execute,
which
will
indicate
an
error
to
the
Python
library.
So
when
you
fail
in
rust
you
the
pipe
inside,
can
know
that
if
an
error
happened
could
look
more
or
less
like
this.
You
have
an
error
that
you
indicate
on
that
never
happened
and
then
in
Python
you
look
at
this.
A
Then
you
do
all
kinds
of
metric
to
actually
set
up
a
common
way
to
catch
the
sound
I.
You
don't
have
to
look
at
the
code,
I
just
I'm
pregnant.
This
is
actually
a
lot
of
tooling
that
goes
on.
Before
you
have
one
function,
then
you
need
to
actually
build
every
usable
thing
that
sets
up
the
landing
pad
and
only
then
you
can
actually
call
this
find
one
function,
and
we
are
doing
this
right
now
manually
all
the
time.
A
Then
we
have
to
actually
bridge
this
library
header
in
C,
because
the
common
interface
between
rust
and
Python,
sadly
you
see,
then
we
can
finally
call
this
and
it's
a
lot
of
work.
I
did
this
for
three
or
four
libraries
at
this
point.
It's
kind
of
frustrating,
but
the
problem
is
like
a
lot
of
reusable
tooling
doesn't
exist.
So
what
is
missing?
We
need
a
better
way
to
build
wheels.
A
Reusable
docker
images
and
an
arrest
of
a
sci-fi
so
a
way
to
not
go
through
sea
layer,
ideally,
but
what
are
the
results
and
I
think
this
is
the
part
where
I
want
to
like,
despite
the
pain
that
you
might
see
in
this,
the
results
are
pretty
good.
So
this
is
total
CPU
usage
for
all
of
our
servers
on
the
before
the
deployment
where
we
introduced
a
source
map
handling
in
rust
and
an
empty
part
after
we
not
only
basically
kills
the
entire,
like
the
server's,
basically
were
idle.
A
We
only
have
to
put
individual
problems
into
faster
solution,
so,
for
instance,
source
map
handling
for
us
was
30
percent
of
what
we
did
in
total
by
just
putting
this
little
piece
of
code
into
rust
gave
us
a
lot
of
room
that
we
can
use
the
Python
runtime
effectively.
In
other
ways,
the
problem
is
when
things
goes
wrong.
This
is
a
bug
I
introduced
two
days
ago
after
deployment.
All
the
service
ran
out
of
memory.
Reason,
for
that
was
that
there
was
about
not
in
the
Python
code.
A
There
was
a
bug
in
the
shrimp
it
Windom
that
cost
the
destructors
never
to
run
so
memory
was
just
never
freed,
so
I
think
it's
great,
but
we
need
better
tooling,
and
if
anyone
has
an
interest
in
rust
as
a
language
or
in
C++
as
a
language
that
we
want
to
use
with
Python,
maybe
talk
to
me
afterwards,
because
I
did
this
many
times
now
that
it
really
wants
to
actually
build
a
reusable
thing
so
that,
instead
of
this
becoming
I,
could
talk
about
all
the
complexities
involved
in
it.
It
becomes
small
affair.
A
Hey
this
is
like
one
thing:
your
install
and
it's
awesome.
You're
right,
the
rust
function
becomes
call
em,
because
I
actually
think
that
as
a
language,
it's
one
of
the
most
innovative
things
that
happened
in
the
last
couple
of
years
and
the
fact
that
we
can
use
it
in
Python
is
really
valuable
and
I
think
it
would
be
great
if
this
sort
of
mindset
starts
to
develop
a
little
bit
that
you
can
actually
combine.
Python,
verse,
rust
for
very
good
effect,
and
with
that
I,
take
questions.
A
Rust,
it's
both
so
rust
is
the
joke.
Kinda
goes
that
the
current
version
of
rust
is
built
in
a
previous
version
of
for
us
is
built
in
a
previous
version
of
rust
and
eco
all
the
way
down
until
there
was
a
version
of
the
language
which
look
completely
different
ten
years
ago,
eight
years
I
don't
know
when
it
actually
started.
So
what
has
happened?
A
Oh
I
would
say
the
last
four
years
is
that
a
lot
of
people
that
actually
involve
the
rust
language
got
ideas
from
Swift
and
a
lot
of
people
that
work
on
Swift
happen
to
also
be
rust
developers.
So
there
is
a
lot
of
intermingling
going
on
in
yeah,
so
Apple
got
a
bunch
of
engineers
that
who
used
to
work
at
Mozilla,
at
least
temporarily
and
there's
a
lot
of
information
exchange
going
on.
A
A
I
think
there
are
a
lot
of
rust
users
at
this
point
that
are
very
hidden
from
the
world.
So,
for
instance,
a
lot
of
back-end
services
start
to
look
into
rust
as
a
way
to
like
solve
individual
problems
like
we
did.
I
know
that
Dropbox
is
doing
that.
I
know
that
obviously
we're
doing
that,
but
there
I
don't
have
a
list
right
now
but
difficult
to
rust,
Lang
friends
of
rust.
There
is
sort
of
an
enumeration
of
companies
that
are
using
it
and
another
way.
A
I
see
people
using
it
is,
for
instance,
the
company
that
habitat
I
think
is
it
habitats,
yeah
I,
think
it's
habitat
like
I,
think
comes
from
op,
Scott
or
chef.
They
built
a
new
deployment
system
entirely
in
rust,
because
one
of
the
biggest
problems
with
distributing
command-line
tools
is
that
you
not
only
need
a
command-line
tool.
You
need
to
run
time
for
it
like
you
need
to
have
the
right
version
of
Ruby
or
Python
or
whatever.
A
If
you
actually
ship
a
rust
binary
to
users,
they
don't
have
to
have
anything
other
than
that
binary
and
how
big
is
the
community?
It's
very
hard
to
say
it's
definitely
one
of
these
small
languages.
At
this
point,
it's
not
like
gold.
That's
exploding
very
rapidly
and
becoming
like
everybody,
wants
to
build
the
services
and
go
because
rust
is
really
only
good
for
subsets
of
problems
like
I.
Think
it's
very
good
for
high
performance
code
is
very
good
for
consuming.
Rest.
Api
is
surprisingly
enough,
building
quantum
utilities
building
extension
modules,
but
it's
a
horrible
choice.
A
If
you
want
to
build
everything
in
it,
so
people
don't
build
entire
applications
in
rust.
They
build
little
bits
and
pieces,
so
it's
very
hard
to
look
over
the
entirety
of
the
community.
One
of
the
things
that's
great,
though,
is
that
the
community
is
an
actual
community,
so
you
can
get
involved
in
it.
The
organise
conferences.
They
have
an
outreach
program.
There's
there's
a
lot
going
on,
so
it
feels
very
welcoming
to
actually
participate
in
it.
Even
though
it's
such
a
low-level
language,
unlike
support
post
fences,.
B
A
So
I
will
put
this
lights
on
on
my
websites.
I
never
will
link
to
this
stuff,
how
we
are
bridging
rust
right
now.
So
the
reason
why
I'm
I
want
to
quickly
point
is
that,
because
when
I
did
the
slides
originally,
there
were
a
lot
more
positive,
because
I
didn't
realize
that
we
had
a
massive
issue
in
how
we
actually
build
the
binary
wheels
and
I
discovered
that
actually
the
way
we're
doing
it
happens
to
work
by
accident
to
some
degree.
A
So
I
want
to
point
out
that
maybe
not
go
entirely
by
our
code
reservoir
now,
because
I
want
to
fix
it
by
next
week,
but
I
I
want
to
put
up
a
repository
that
actually
shows
how
you
can
build
an
extension
module
for
Python
with
rust
that
that
you
can
actually
start
looking
at.
Maybe
together,
people
could
help
to
actually
make
it
a
reusable
thing
and
I
probably
will
write
an
article
about
this
at
one
point:
how
we
actually
do
this
there's
one
in
the
century
blog
it's
a
little
bit
outdated
now
and.