►
Description
RustConf 2019 - Opening Keynote by Steve Klabnik & Florian Gilcher
Rust has wild years behind it: we released Rust 1.0 just a little over 4 years ago. We released 37 stable versions of the compiler and countless other releases. Edition 2018 happened. async/await is finally here! And this is not counting the uptake of general crates!
We're successful! Indeed, the Rust programming language and project are some of fastest growing globally. But Edition 2018 also was a breakpoint: it was a common goal to work towards. That is now gone.
With the explosive growth also comes a growing understanding of our processes and community, but also growing unclarity. Steve and Florian will share their thoughts on the last year(s) and especially on the future. This keynote wants to encourage you to form your own and grow a common understanding how to carve our way forward!
A
So
yeah
good
morning,
everybody
welcome
to
Russ
Kampf.
How
many
of
you
is
at
your
first
Russ
comp.
That
is
amazing
and
wonderful.
Welcome
we're
really
excited
to
have
you
here,
I'm,
always
surprised
by
the
number
like
every
year.
It
gets
to
be
more
and
more
people.
What
you
think
is
a
conference
would
go
on.
It
would
be
less
and
less,
but
we're
clearly
like
growing.
That's
super
super
exciting,
so
yeah
I
I
saw
this
tweet
yesterday
and
I
I.
A
A
lot
of
this
is
kind
of
about
like
your
role
in
leadership,
not
like
our
roles
as
to
what's
going
on.
So
this
is
like
funny
but
I
think
also
very
insightful,
so
for
some
backgrounds,
a
little
bit
about
the
both
of
us,
I'm
Steve
and
before
rust,
I
did
Ruby
and
Ruby
on
Rails
stuff
a
long
time
ago,
and
that
was
really
great.
I
started
writing
rust
in
2012,
so
I'm,
one
of
the
older
folks
around
here
I
joined
the
core
team
in
2014
and
I'm,
the
co-author
of
the
rust
programming
language.
A
So
that's
pretty
cool.
It
took
me
a
very
long
time
and
Carol
and
I
worked
really
hard
on
it,
but
I'm
super
super
proud.
The
most
thing
you
need
to
know
about
me
is
I
tweet
far
too
much,
and
so
not
only
did
too
much
of
my
personal
account
but
I'm
also
rustling
on
Twitter,
but
like
don't
tell
anyone
that
other
people
on
the
team
have
access
to
and
tweet
sometimes,
but
most
of
the
time
like
that,
that's
me
so
yeah,
yes,.
B
Hi
I'm
Lauren.
This
is
actually
my
first
time
to
the
yes,
and
this
is
also
my
first
time
running,
giving
a
keynote,
and
that's
quite
funny,
because
I've
replaced
tweeting
by
running
events.
I
run
meetups
like
the
rust
meetup.
That
founded
in
Berlin
alone,
has
over
100
events.
We're
doing
that
together.
As
a
team.
Obviously
I'm
my
partner,
rust,
was
or
into
the
last
project,
was
getting
becoming
a
community
member
in
2015
on
the
invitation
of
Steve
and
now
being
an
observer
to
core,
which
is
like
the
path
to
joining
core.
B
A
So
first
thing
we
wanted
to
do
is
recap:
what's
like
gone
on
this
year,
there's
been
a
lot
of
stuff
happening
in
rust
world
and
it's
really
easy
when
you
like
pay
attention
to
every
single
release.
That
happens
to
not
like
take
a
step
back
and
look
at
just
like
how
much
stuff
we
actually
like
accomplished
and
so
yeah
there's
some
some
achievements.
Yeah.
B
B
A
So
one
interesting
thing
specifically:
what
this
is
is
the
most
loved
programming
language
and
what
that
means
is
people
that
are
using
it
today
that
want
to
keep
using
it
in
the
future,
and
so
when
you're,
a
young
small
language,
that's
really
easy,
because
the
only
people
that
use
it
are
the
people
that
love
it.
So
the
measure
of
success
for
a
programming
language
is
really
when
people
who
don't
love
it
are
forced
to
use
it
at
their
jobs
right.
So
people
people
would
always
say,
like.
A
Oh
yeah
rust
won
this
a
couple
years
in
a
row.
But
that's
because,
like
you
know,
no
one
uses
it.
So
it's
fine,
but
this
year
we
actually
got
more
love
like
that
number
increased,
as
the
community
grew.
So
you
know,
surveys
are
like
kind
of
silly
or
whatever,
but,
like
it
looks
nice,
whatever
I'll
put
on
a
slide
anyway,.
B
Then,
if
services
silly
competitions,
there
is
the
yearly
I
CFP
international
conference
for
functional
programming
contest
where
everyone
can
enter
and
it's
a
reasonably
hard
contest
to
enter
and
there's
always
one
winner
every
year,
and
they
call
the
language
that
wins.
The
language
of
choice
for
discriminating
hackers
and
we've
won
that
this
year
and
the
year
before
and.
B
Conferences
my
lifeblood.
So
last
year
we
had
three
conference
brands.
There
was
Rosco.
Obviously
this
was
spelled
rust,
which
is
the
tiny
conference
in
the
Rust
Belt,
which
I
heard
is
awesome.
That
I
was
not
able
to
visit.
Sadly,
and
in
Europe
we've
got
rust
fest,
but
since
last
year
we
actually
gained
seven
new
conferences,
rust
rush,
one
in
Asia,
Colorado
gold,
rust,
Great,
Pond,
rust,
low
Tom
in
Montevideo.
Also
great
conference,
the
organizers
around
here,
Russ
Tokyo,
is
coming
up.
B
There
was
oxidize,
conf,
conf
or
a
conference
focused
on
just
embedded
development
of
rust
and
another
one
in
Europe,
Ross
lab
Italy.
So
that's
a
total
for
we
went
from
three
conferences
to
ten
and
those
are
all
conferences
that
will
probably
repeat
so.
Actually
I
love
conference
organisers.
Can
you
all
give
them
a
huge
applause.
A
B
Yeah
and
Berlin,
we
have
rosbridge
the
events
that
run
around
at
the
conferences
that
are
trying
to
get
more
organized
people
into
rust,
and
the
Berlin
chapter
of
the
rest
community
has
actually
started
its
own
local
West
Kaptur
to
continuously
run
those
events
in
the
city,
and
they
have
just
formed
two
days
ago.
So
would
also
be
great
to
give
a
huge
round
of
applause.
B
B
A
A
A
So
another
huge
thing
that
happened
this
year
that
is
like
in
the
past
like
we're.
When
we
talk
about
this
year,
we
mean
like
from
August
to
August,
not
like
you
know,
2019
or
whatever
it
to
be
clear,
Rus,
2018
and
finally
shipped
in
December,
which
is
a
super
huge
effort
amongst
the
entire
project
from
a
lot
of
people,
and
it
took
a
lot
of
work,
and
so
we're
really
happy
and
excited
that.
That's
the
thing
that
was
successful.
You
know
up
until
the
last
second
you're
always
like.
Oh,
is
this
actually
happening?
A
And
to
talk
about
that,
like
it's
one
thing,
but
actually
it
was
like
a
lot
of
stuff.
So
as
a
small
example
of
the
number
of
things
that
we
ended
up
actually
shipping
there's
the
brand
new
module
system
infiltrate
in
all
the
places.
The
dine
keyword
to
make
dynamic
dispatch
a
little
more
obvious
to
people
non
lexical
lifetimes,
which
basically
means
rust,
complains
at
me
less
default
match
bindings.
A
This
is
one
of
my
favorite
features,
never
write
the
ref
keyword
ever
again,
more
lifetime
elision
and
inference
actually
I
had
to
remove
the
advanced
lifetimes
chapter
of
the
book,
because
all
my
examples
no
longer
needed
the
syntax
that
it
showed
off
the
compiler
just
infers
it
now.
So
that's
cool.
A
It
doesn't
mean
I
get
bugs
filed
now,
where
people
like
wait.
Where
did
the
syntax
go
and
like
you
don't
need
it
anymore?
The
the
inclusive
range
operator
dot
equals
which
took
a
really
long
time.
To
surprisingly,
you
would
think
that
inclusive
range
is
not
complicated,
but
programming.
Language
design
is
hard.
Sim
D
happens,
keeping
up
on
our
speed
stuff.
We
got
the
beginnings
of
incremental
compilation
and
like
global
allocators
and
stuff
too,
and
this
is
obviously
an
extremely
short
list.
But,
like
you
know,
there's
a
lot
of
stuff.
A
Originally
sort
of
planned
to
be
part
of
the
2018
edition
shipping,
but
you
know
here
we
are
a
little
while
later
and
it's
taken
a
while,
but
that's
because
it's
so
good,
like
good
things
just
take
time.
So
more
specifically,
I,
don't
know
if
you
saw
pull
requests.
63
209
happened
recently,
which
also
is
an
amazing
like
measure
of
how
you
know
active.
A
The
Russ
project
is
like
we've
had
five
digit
numbers
of
pull
requests,
but
this
actually
merged
a
couple
days
ago,
so
this
is
now
actually
going
to
be
stable
sometime
in
the
future.
Originally
we
were
hoping
to
be
like
it
stabilized
yesterday
we're
on
stage
woohoo,
but
now
it's
like
okay
you'll,
get
it
in
like
eight
weeks
or
whatever.
So
that's
fine.
It.
A
Yeah,
that's
that's
what
actually
counts,
and
it's
also
important
I
think
there's
been
so
much
hype
around
async/await
to
remember
to
there's
even
more
good
stuff
coming.
This
is
like
the
MVP
version
of
the
feature,
so
the
lang
team
is
been
working
super
hard
on
this
for
a
really
long
time
and
they
definitely
I
think
deserve
a
round
of
applause.
A
A
A
We
had
this
this
future
struct.
This
is
a
screenshot
of
Russ
stock
back
in
the
zero
point
ten
days,
but
he
goes
even
further
back
than
that.
Actually
I
did
some
digging
and
in
0.5,
which,
incidentally,
is
one
of
the
first
versions
of
Russ
that
I
ever
used.
This
says
July
3rd
2013,
but
it
definitely
released
earlier
than
that.
Actually,
who
knows
github
metadata
I
think
we
made
tagged
too
late
or
something
but
here's
what
rust
code
looked
like
back.
Then
this
is
sort
of
a
little
small.
A
Maybe
on
this
slide,
so
you
might
want
to
check
it
out
later,
but
this
is
actually
an
example
of
the
pull
the
stuff
out
of
the
future
code.
The
first
thing
I
want
you
to
notice.
Is
this:
the
return
type
is
ampersand
self
/a
a
long
time
ago.
That's
the
one
of
the
syntax
is
that
we
tried
to
use
for
lifetime.
So
if
you
hate
the
syntax
for
lifetimes,
think
of
this
as
better
or
worse,
maybe
you,
like
it
I,
don't
know,
there's
also
some
other
interesting
things.
A
You'll
notice
in
the
middle
of
this
match
block
it
says,
fail.
Tilde
quote
recursive
fortunate,
forcing
a
future.
This
is
two
features
that
used
to
exist.
The
first
is
that
panic
used
to
be
called
fail
way
back
when-
and
this
is
near
and
dear
to
me,
because
I
actually
submitted
the
pull
request
to
rename
it
and
then
I
wrote
a
script
on
github
to
fork
every
Russ
project
and
send
them
a
pull
request.
Saying:
hey
sorry,
I
broke
your
code,
but
here's
a
PR
to
update
it
to
panic.
A
Instead,
so
that
was
cool
and
then
the
squiggly
like
this
is
basically
the
dot
to
string
of
the
day.
So
there
was
syntax
for
own
types
and
it
used
the
squiggle.
So
that's
kind
of
cool.
Lastly,
right
above
this
bottom
match
block
self
dot
state
and
then
like
bracket
bracket,
state
mem
swap
had
syntax
in
the
language
at
the
time,
which
is
pretty
cool.
A
So
it
turns
out
that,
like
this
has
been
in
the
making
for
like
a
very
very
very
long
time,
not
just
like
the
most
recent
efforts,
which
obviously
are
also
Herculean
but
like
it
just
it
takes
a
really
long
time
to
make
great
features
and
async/await
is
like
super
fantastic
and
rust,
especially
because
we
have
one
of
the
most
performance
and
like
interesting
implementations
of
the
idea
that
is
existed.
This
is
sort
of
a
field
report
recently
from
the
Libre
folks,
so
Facebook's
cryptocurrency
shenanigans.
If
you,
if
you
look
at
their
like
forum.
A
Basically
this
is
a
post
they
made,
which
is
really
fantastic.
They've
been
using
async
await
since
I
think
roughly
the
start
of
the
year
and
I'm
not
gonna,
read
all
the
shenanigans
to
you.
I
just
want
to
mostly
put
that
up
there,
but
the
reason
that
they
set
a
single
weight
is
awesome
and
if
you
haven't
like
heard
of
async
await
or
if
you
haven't
been
doing,
async
stuff
and
rust,
I
want
to
sort
of
briefly
explain
like
a
lot
of
people,
don't
understand
why
it's
so
deeply
desired.
A
They're,
like
we
already
have
futures
and
async
like
what's
the
big
deal,
and
usually
that's
said
by
people
who
have
not
written
a
ton
of
async
code
because,
like
futures
are
great
but
because
the
baro
checker
does
not
understand
the
combinators
of
futures,
you
end
up
doing
stuff
like
this,
so
here's
an
example
of
updating
a
hash
map
where
you
have
to
wrap
it
in
an
arc
in
a
mutex
and
then
for
each.
You
know
future
that
comes
down
the
stream.
A
You
have
to
like
undo
the
lock
and
deal
with
the
ref
counts,
and
then
you
do
it
again,
and
you
have
to
unlock
it
here
and
so
there's
all
this
overhead
that
doesn't
actually
need
to
be
there,
and
so
what
this
code
turned
into
in
their
code
base
looks
much
more
like
this,
so
you
have
an
async
block
and
then
inside
of
it
you're
able
to
call
stream
next
Auto
and
then
just
write
your
regular
code.
So
there's
no
arc
reference,
counting,
there's
no
more
mutex
back-and-forth!
A
You
just
write
regular
sort
of
rust
code
with
a
couple,
a
sinks
and
a
weight
sprinkled
in
there
and
you
get.
You
know
super
super
powerful,
fast
code,
so
this
has
been
like
a
really
really
awesome
thing
and
people
are
definitely
super
excited
about
it
and
as
an
example
of
like
I
mentioned
this
briefly
a
minute
ago,
but
like
one
of
the
things
that
I
think
is
really
interesting
and
why
async/await
is
huge
for
rust
is
because
we
are
in
a
super
super
fast
at
it.
A
So
all
benchmarks
are
done,
but
this
benchmarks
looks
good
and
so
I'm
putting
it
on
a
slide
anyway.
Take
this
with
a
giant
grain
of
salt,
because
C++
is
actually
coming
for
us,
but
on
this
benchmark
we
still
are
the
fastest.
By
far
you
notice
a
stick
score
and
ax
xpg.
Both
are
the
gold
standards
in
this
particular
test
and
the
next
best
framework
is
at
65%.
So
it's
like
almost
twice
as
fast
as
the
next
nearest
one
on
this
this
particular
benchmark.
A
A
A
Russ
20:18
has
been
successful
enough
and
like
we
modeled
it
after
the
way
that
Java
and
C++
do
their
compilation
stuff,
but
they're
now
people
trying
to
seriously
proposed
that
C++
adopts
additions
as
a
concept,
because
they
think
it's
been
so
successful
for
us
and
they
want
a
way
to
advance
their
language
forward
without
breaking
old
people's
code.
So
I
also
just
think
that,
like
that's
a
great
impact
that
we've
had,
is
that
like
introducing
interesting
ideas
to
other
languages
and
their
ability
to
like
do
things?
So
that's
also
been
been
super
good.
B
It's
also
quick,
quite
fun
that
when
we
constructed
the
stock,
because
Edition
2018
was
a
huge
amount
of
labour
and
everyone
came
away
exhausted,
and
so
when
we
started
constructing
that
keynote,
it
was
a
much
more
thoughtful
and
like
focused
on
the
things
that
went
wrong
thing
and
when
we
actually
started
or
like
hey.
Let's
have
a
look
at
what
we
all
achieved.
There
was
just
a
bigger
pile
of
things
that
we
wanted
to
talk
about,
giving
it
a
lot
more
positive
spin.
B
It's
amazing
for
what
the
teams
have
done
so
also
one
thing
that
I
forgot
on
the
slides.
The
embedded
working
group
has
made
embedded
development
on
Ross
stable
last
year,
August
and
since
then
it
has
been
picking
up,
usually
so
we're
now
also
in
the
embedded
space
as
a
newcomer
but
yeah
yeah,
huge
round
of
applause
to
them.
Yeah.
B
B
The
rest
website
now
has
six
translations
and
more
coming
down
the
stream
and
there's
a
huge
amount
of
people
working
on
them
and
they're,
probably
going
to
start
working
on
the
books
and
whatever
later
so.
That's
a
huge
thing
and
the
other
kind
that
I
made
is
how
many
people
have
actually
contributed
to
one
repository
on
github.com
slash
lost
lang.
This
is
including
our
Fork
of
the
yellow,
VM
and
Jade
Malik,
just
for
make
sure
I
did
who.
B
That's
great
and
we
won
also
they're
one
of
the
largest
projects
that
we
have
around
and
that's
a
huge
amount
management
and
but
yet
being
part
of
the
community
team.
The
more
and
more
I
get
the
feeling
that
some
people
do
contribute,
but
then
never
counted
somewhere
like
they're
running
an
event,
they're
running
a
meet-up
they're
running
something
they're,
teaching
or
whatever,
and
it
becomes
more
and
more
of
a
problem.
A
Because
you've
got
that
you
did
that
fifty
four
hundred
by
downloading
the
git
repos
and
looking
and
get
logs.
But
there
are
so
many
people
that
have
done
so
much
work
that
is
so
important
to
rust
and
deserve
to
be
thanked
and
recognized
for
it.
And
it's
really
hard
when,
like
we're
used
to
making
computers,
do
the
job.
But
we
can't
be
like
computer,
who
has
been
all
the
organizing
teams
of
all
of
the
rust
conferences.
Right
like
that,
doesn't
actually
work.
And
so
this
is
a
tough
problem
that
we
don't
like
tackle.
B
Model
actually,
if
we're
a
language
that
wants
to
be
adopt,
but
the
reason
why
I
joined
the
rust
project
back
ban
is
because
it
always
had
the
air
of
we
want
to
build
something
that
people
use.
So
if
you
want
to
be
a
project,
that's
in
the
hands
of
people
just
being
at
a
company
and
we're
an
open
source
project
and
telling
people
this
would
be
something
interesting
to
adopt
and
trying
to
get
a
raise.
Adoption
of
language
is
already
contribution.
We
can't
lock
that
anywhere.
We
never
find
a
trace
of
that.
B
B
So
I'm
not
just
talking
about
it
like
something
that
goes
on
in
my
mind,
but
something
that
we
as
a
community
team
experience
that
some
people
just
feel
like
hey
I,
actually
invest
the
time
into
this,
but
I
don't
feel
like
I
get
like
at
least
the
recognition
back,
and
a
lot
of
the
recognition
happens
on
the
hallway
here.
So
if
you
meet
someone
consider
like
talking
to
them
about
what
they
were
involved
in
and
actually
just
saying,
thank
you.
B
That's
a
pretty
big
power
move
to
say,
I'm,
giving
people
the
feeling
that
the
work
they
have
invested
into
the
project
they're
there
around
is
is
really
really
important
because,
like
I
recently
last
week,
read
a
nice
comment
about.
Why
is
Ross
popular?
Why
do
people
take
every
announcement
that
the
rest
project
doesn't
just
put
it
out
everywhere?
And
someone
responded
to
that
question
with
its
built
in
large
part
by
Mozilla,
which
enjoys
special
love
as
an
open
source
company,
and
that's
actually
quite
interesting.
B
People
still
perceive
it
at
that,
but
even
when
we
had
rosters
Kiev
we,
the
statistic
was
already
like
75%
of
what's
built
on
the
worst
project
is
built
by
non-muslims.
We
are
incredibly
good
at
having
non-modular
contributions,
not
to
diminish
the
value
that
Mozilla
have
brought
to
it.
The
second
is
Ross,
provides
tangible
bama
benefits,
it
solves
practical
problems,
but
the
third
is
the
community:
is
nice
and
talented,
so
it's
fun
to
see
what
they
up
to,
and
that's
all
about
you
and
not
about
us.
B
B
More
puns,
please,
but
that
also
brings
a
lot
of
organizational
challenges
to
the
project
and
that's
becoming
more
and
more
problematic,
and
we
need
more
people
that
do
actually
manage
the
project
just
to
make
sure
that
stays
in
shape,
and
that
is
it
stays
running.
So
we
need
people
who
are
not
building
new
stuff,
but
making
sure
that
stuff
that
exists
remains
in
the
state
that
it
is.
That
also
means
we
need
to
train
up
new
people
on
managing,
and
that
is
one
of
the
shifts
that's
happening
this
year.
B
New
people
are
stepping
up
and
one
of
the
problems
in
there
there,
and
this
is
what
the
community
it's
important,
that
the
community
stays
kind
about
it.
Those
people
will
fail
at
their
tasks
in
different
degrees,
probably
even
hard,
and
it
must
be
possible
that
they
are
allowed
to
do
that,
because
otherwise,
you
don't
learn
and
the
rest
project
has
people
in
team
management
that
are
23
year
olds
to
somewhere.
That's
an
incredible
chance.
B
This
is
actually
how
I
got
into
Ruby
Ellen,
truly
at
the
University,
and
the
Ruby
community
was
so
kind
to
allow
me
to
try
out
my
stuff
and
just
be
bad
at
it,
which
I
couldn't
do
at
the
University
and
we,
as
a
community
I,
have
a
chance
to
give
other
people
the
ability
to
join
the
Russ
project,
and
we
have
that
experience
for
their
own
personal
lives.
Yeah
and.
A
I
think
all
the
stuff
ties
in
together
I've
been
thinking
about
this
a
lot
not
just
because
we've
had
these
challenges
in
rust,
but
I
actually
became
a
product
manager
at
my
new
job
recently
and
so
I've
been
reading
about
management
stuff
and
a
thing
that
I
ever
thought
about
before.
But
a
concept
I
came
across
when
I
was
looking
up
like.
Why
do
we
call
people?
A
Folks,
you
know
like
sending
in
patches
is
very
much
like
furthering
the
goals
of
the
language,
but
as
we
like
grow
open-source
projects
into
like
larger
organizations,
we
also
need
help
from
people
doing
all
this
sort
of
like
support
work
in
some
sense
and
like
there's
other,
like
not
not
support
in,
like
a
like
helping
users
support
but
like
supporting
the
goals
of
the
organization.
In
a
way.
That's
not
sending
in
patches
and
like
this
is
an
area
where
we
as
a
project,
are
like
a
little
deficient
and
are
looking
to
sort
of
like
improve.
A
I
am
terrible
at
scheduling
and
running
meetings.
Don't
tell
the
people
who
hired
me
as
a
manager,
but
that's
like
a
skill.
That's
like
important
and
needed
in
the
RUS
project,
and
so
it's
like
a
thing
that
I
would
like
to
work
at
because
it's
not
it's
something
we
need
and
I'm
not
good
at.
So
you
know:
yeah,
okay,.
B
This
is
something
that,
for
reasons
of
this,
being
legalities
mostly
is
hidden,
but
we
need
to
talk
to
lawyers
more
and
that's
that's,
for
example,
something
where
it
becomes
problematic.
When
someone's
is
responsible
for
running
crates,
AO
on
the
legal
side,
they
can't
be
a
volunteer,
because
I
really
don't
want
to
get
volunteers
sued
for
not
replying
on
an
email.
A
It
turns
out
the
people
that
enforce
laws
don't
care
when
you're
like
sorry.
This
is
my
side.
Project
I,
don't
have
time
to
like
follow
the
law.
So
it's
like
kind
of
important
that
we
comply
with
those
things
and
like
a
lot
of
people
and
programmers,
don't
think
that
open-source
has
to
like
deal
with
legal.
A
lot
but,
like
you
know,
especially
in
running
crates,
IO
is
like
one
of
the
bigger
things
right
now
but
like
there
will
be
other
things
in
the
future.
A
B
B
So
it's
time
to
review
and
change
our
practices
and
that
review
also
needs
feedback.
So
if
someone's
like
I'm
seeing
something
that
could
work
better
or
if
you
have
experience
from
another
open-source
project
where
you
know
you've
solved
something,
we
they
open
to
talk
to
anyone
on
any
of
the
teams
and
help.
A
Them
improve
a
lot
of
the
reason
why
we're
successful
as
we
are
as
due
to
like
our
and
other
folks
in
rusts
history,
specifically
in
Ruby,
but
also
in
other
projects,
like
the
reason
that
cargo
is
the
way
it
is,
is
because
yahuda
had
worked
on
bundler
and
had
learned
what
worked
well
and
what
didn't
work
well
and
same
in
a
lot
of
crates.
Ios
stuff
and
like
a
lot
of
the
aspects,
are
things
that
we
have
brought
from
things
that
we
did
before
rust.
A
And
you
know
we
don't
have
experience
everywhere
and
so,
like
like.
We
took
the
RFC
process
sort
of
from
Python
and
their
pet
process
is
another
a
great
example
of
a
language
influencing
us.
And
so
you
know
if
you
work
in
a
project,
and
you
have
some
stuff
that
works
really
well
like
there's
a
lot
of
stuff
that
we
don't
do
really
well,
and
it
would
be
great
to
figure
out
someone
who
does,
and
there
was
the
answer.
So
we
can
improve
yeah.
B
So,
and
one
thing
that
I
would
like
to
talk
about
from
my
experience
is
a
lot
of
the
problems
that
I
see
popping
up
everywhere
around
like
people
getting
angry
at
the
project
or
disgruntled
are
actually
communication
problems
and
one
of
the
things
that
we
don't
do
quite
quite
as
much
is
modeling
what
the
communication
of
the
bus
project
is
and
because
we're
growing
that
constantly
changes.
So
when
I
joined
like
the
roast
like
ecosystem,
it
was
basically
10
hackers
somewhere
and
a
couple
of
people
around
it.
B
So
you
could
just
on
any
kind
of
communication,
assume
that
everyone
had
a
full
picture
of
what
Ross
currently
was
and
was
building
nightly
every
5
days
and
would
just
be
ok,
was
figuring
out
and
what
just
broke
and
where
they
would
find
out
what
broke.
And
since
then
that
has
been
growing
all
the
time
and
just
a
couple
of
weeks
ago,
I
read
it
read
an
interesting
blog
post
about
from
the
developer
developer
relationship
community,
how
they
model
communication
with
their
communities
and
what
they're
using
is
a
model
that
they
call
Orbitz.
B
B
Is
it's
actually
not
bad
to
be
in
orbit
for
orbit
for
basically
says
I,
really
don't
care
about
what
you're
doing
as
long
as
my
product
works
and
my
stuff
builds
and
I
know
about
all
the
important
stuff
that
I
need
to
know
about
what
breaks
and
what
not
while
oh
with
one
is
those
are
basically
personal
friends
that
I
need
to
regularly
talk
to,
and
two
and
three
are
other
ones.
We
probably
would
have
a
different
kind
of
modeling
there,
but
the
important
part
is
the
more
and
more
we
grow,
the
more
and
more.
B
We
grow
groups
that
need
different
kinds
of
communication.
Some
just
need
to
change
law,
others
need
very
direct
communication
and
because
of
the
size
of
a
project,
we're
starting
to
be
in
an
area
where
even
communication
between
team
members
already
has
that
notion
where
some
people
just
want
to
be
informed,
what
a
team
does
some
people
want
to
be
consulted?
What
a
team
does
for
people
that
remember
last
year's
keynote,
why
wasn't
I
consulted
is
a
huge
problem,
but
also
finding
out.
B
A
For
example,
earlier
I
mentioned
when
I
changed,
fail
to
panic
and
I
wrote
that
script
I
looked
up,
everything
on
github
and
I
think
it
was
like
65
projects
on
github
that
happened
to
be
panicking
basically,
and
so
I
was
able
to
like
send
a
PR
to
literally
every
person
with
like
fairly
minimal
effort.
As
we've
grown.
You
know
we
developed
crater,
which
is
like
a
super
wonderful
tool
to
be
able
to.
You
know
see
like.
A
Oh,
is
this
impact
like
what
is
the
impact
of
a
particular
change
and
like
how
is
that
going
to
affect
the
rust
world?
Because,
for
a
long
time
you
know
we
had
basically
like
servo
and
then
like
open
source
code
like
other
open-source
code,
that's
like
on
crazy
IO,
because
we
didn't
have
a
lot
of
adoption
within
companies.
A
But
now
we've
grown
to
the
point
where,
like
crater,
while
it's
still
an
amazing
tool,
can't
actually
like
tell
us
what
the
real-world
impact
of
changes
to
the
language
are
going
to
be
because,
like
we
don't
have
access
to
say,
like
Microsoft
or
Facebook's
internal
repositories,
where
they're
doing
private,
you
know
code
or
whatever,
and
so
the
infor
team
has
some
ideas
on
how
to
work
there.
But,
like
the
point,
is
if
you
would
analyze
how
that
worked
at
any
given
point
in
the
project's
lifetime
like
and
you
stuck
with
it
the
entire
time.
A
The
situation
has
changed
from
out
from
underneath
your
feet,
and
so
we
haven't
needed
to
like
think
about
these
kind
of
things
before
but
like
as
we
grow,
we'll
need
to
continue
reevaluating
these
kind
of
things
so
I'm
sure
this
is
a
theme
that
you'll
see
like
in
the
future
in
general,
that
you
know
as
we
grow
stuff
changes.
It's
different,
so
you
need
to
do
different
things.
It
seems
very
basic,
but
it's
hard
to
actually
internalize
that.
That's
true
also.
B
For
some
time
that
just
works
organically
one
interesting
experience
I
had
over
the
last
week,
Aaron
started
writing
a
marketing
handbook
for
us
like
one
or
half
years
ago,
or
something
like
that
and
that
kind
of
window
the
way
because
people
didn't
have
the
time.
But
during
the
last
three
months,
I
had
multiple
people
finding
out
that
the
shell
of
this
book
exists
and
asking
us
directly.
Hey
could
I
actually
contribute
to
that.
Could
I
like
take
all
your
experience
and
just
put
it
into
that
book.
What
would
you
be
up
for
an
interview?
B
So
even
communicating
we've
got
interest
in
writing.
Something,
and
my
theory
around
this
is
the
people
that
were
doing
marketing
for
us
previously
was
a
small
enough
group
that
we
could
just
do
that
verbally
and
now
it's
becoming
more
and
more
that
that
we
don't
have
the
time
anymore,
to
actually
talk
to
everyone
who
is
interested
in
that.
So
we
need
to
write
it
down.
So
writing
down.
More
is
like
if
you
enjoyed
writing.
Please
talk
to
us.
We've
got
a
lot
of
writing
to
do
writing.
B
B
The
stability
guarantees
that
we
have
our
security
policy
and
all
that,
but
that's
actually
not
what
people
like
us
for,
because
guarantees
are
only
the
last
line
and
that's
something
that
people
often
miss
what
people
enjoy
rust
for
is
the
quality
that
we
constantly
deliver
and
that's
actually
higher
than
the
guarantees
that
we
have.
For
example,
we
have
a
couple
of
targets
that
are
officially
Tier
two,
but
people
are
using
them
because
they
experience
for
them
is
oh
they're
great
and
we
can
use
them
absolutely
no
problem.
B
A
But
at
the
same
time,
like
those
three
years
of
like
pain
of
not
having
a
single
weight
is
also
the
reason
that
we
have
an
extremely
high
quality.
World-Class
implementation
of
that
feature
and
figuring
out
where,
like
what
stuff
is
okay
to
ship
a
little
bit
earlier.
And
what
stuff
really
needs
to
take
time
to
polish
is
really
important
and
difficult
and.
B
It's
really
important
to
be
honest
and
subtle
around
this,
for
example.
Just
last
week
the
goal,
the
final
goal
for
having
async/await
in
beta
was
the
last
beta
release
last
week,
and
we
didn't
actually
manage
that
for
a
number
of
reasons,
people
didn't
figure
out
fast
enough
that
it's
probably
going
to
be
delayed,
which
meant
we
couldn't
allocate
enough
resources
to
it
because
kind
of
the
message
got
lost
and,
in
the
end,
the
release
team
doing
what
was,
in
my
opinion,
the
right
decision.
Saying
hey.
B
B
It
would
have
been
quality
wise
better
if
you
actually
hit
the
communicated
deadline
that
people
were
expecting
at
the
quality
level
that
we
wanted
to
and
the
subtlety
honesty
comes
in
at
the
moment
where
we
need
to
take
this
event
just
neutrally
and
talk
about
okay.
How
could
we
have
improved
in
and
could
we
have
improved
our
processes
or
where
are
the
flaws
in
our
processes
to
actually
make
sure
that
we
could
have
caught
that
early
and
got
it
over
the
finish
line
on
the
date
we
wanted
and
the
quality
we
want
it.
B
A
And
this
also
takes
like
a
big
back-and-forth
between
you
all
and
the
teams
as
well
right,
because
it's
like
your
goal
to
communicate
to
us
what
stuff
that
you
want,
and
it's
our
job
to
make
that
happen.
But
that
also
requires
some
charity
on
both
ends.
Whenever
you
ask
for
something
that
we
feel
is
impossible
or
when
we
ship
something
that's
like
a
little
later
than
maybe
we
originally
said
right.
A
So
it's
like
a
symbiotic
like
work
together,
kind
of
like
situation,
and
that
requires
this
kind
of
honesty
and
subtlety
with
each
other,
so
that
you
know,
there's
not
like
a
whole
big
animosity
between
everything
about
how
stuff
goes
like
I've
worked
in
languages
and
ecosystems
where
the
users
of
the
language,
like
hate,
the
team
that
makes
the
language
and
it's
like
not
a
great
place
to
be
in
so
we
don't.
We
don't
want
that
to
happen.
The
rest
also.
B
So
as
a
conclusion,
one
thing
that
I
always
liked
about
the
rest
project.
It
was
pragmatic,
active
and
results
based,
so
pragmatic
in
the
sense
of
we
actually
want
to
solve
problems
in
the
sense
of
we
want
to
come
up
with
an
idea
that
solves
problems,
in
short
to
medium,
run,
we're
not
aiming
for
the
moving
of
like
in
20
years.
We
rebuilding
a
research
language
that
in
20
years
might
be
picked
up.
B
Rust
was
always
the
language
that
would
take
the
languages
from
the
90s
pick
up
their
ideas,
reintegrate
them
and
actually
give
it
to
people,
and
it
was
also
always
an
active
project.
It
is
incredibly
geared
by
what
are
actual
problems
that
our
users
have.
How
can
we
solve
them,
and
how
can
we
integrate
that
into
a
good
whole,
like
the
whole
features
story
from
like
five
six
seven
years
ago?
Is
it
is
an
instance
of
that?
B
How
can
we
take
this
idea
and
actually
turn
it
into
something
that
is
usable
and
productive
for
people
it
might
take
five
years
or
it
might
take
just
two
weeks
and
that
we
are
always
trying
to
figure
out
what
the?
What
those
are
and
that
we
are
actively
trying
to
figure
out
what
the
issues
are
and
asking
people
one
thing
that
I
always
also
enjoyed
about
the
RUS
project
is
how
open
we
were
to
go
to
companies
and
say:
hey.
You
know
what
you're
using
our
language.