►
From YouTube: RustFest Rome 2018 - Aaron Turon: Grappling with growth, and other good problems to have
Description
On the eve of Rust 2018, we have so much to celebrate! From the core language to tools to community outreach to adoption, the Rust project has made enormous strides. But with success comes new challenges. Looking ahead to the next Edition of Rust, this keynote will lay out some of these challenges along three dimensions: Stakeholders, Governance, and Product. I'll pitch some personal ideas for how to grapple with these challenges, taking a frank look at what's working well and what needs to change, and inviting community-wide discussion as we go into our planning for next year.
https://rome.rustfest.eu/sessions/keynote
https://media.ccc.de/v/rustfest-rome-1-keynote
A
Yeah
so
I'm
Erin,
Tehran
and
I'm
really
excited
to
be
here
at
my
very
first
thrust.
Fest
I
have
sadly
had
to
miss
out
on
the
previous
instances,
for
various
scheduling
reasons.
I
was
curious.
How
many
of
you
is
this?
Your
first
rust
fest
Wow,
awesome
well.
Well,
welcome!
So
we'll
all
sort
of
experience
this
together.
A
A
How
many
of
you
are
familiar
with
the
coyote
and
roadrunner
cartoon?
Okay,
most
of
you,
but
not
all
of
you.
So
let
me
let
me
just
fill
you
in
because
it's
gonna
be
sort
of
running
metaphor
for
the
talk.
So
in
this
cartoon
you
have
two
characters:
the
coyote
and
the
roadrunner,
and
the
principle
is
very
simple:
the
coyote
is
very
hungry
and
is
chasing
the
roadrunner
trying
to
catch
it
and
eat
it.
A
I
think
for
many
people,
rust
is
something
deeply
aesthetic.
You
know
it's
beautiful.
They
wanted
to
be
perfect
for
other
people.
There
are
particular
features,
but
for
the
core
team
we
tried
to
have
a
vision
of
success
that
wasn't
tied
to
any
particular
aesthetics
or
features,
but
was
more
in
terms
of
adoption,
rust,
actually
being
used
and
surviving
as
a
language,
and
we've
wanted
to
seek
that
goal.
A
While
staying
true
to
our
core
values
and
I'll
be
talking
about
that
throughout
the
talk,
so
in
particular
the
way
that
we
want
to
measure
our
success
is
we
want
to
see
people
not
only
using
rust
in
production
but
getting
genuine
value
out
of
it
in
a
way
that
that
is
really
unique
to
rust.
So
that's
our
road
runner.
We
as
a
community
have
been
the
coyote
chasing
the
success
and
I
want
to
start
by
talking
about
the
last
three
years,
which
I
sort
of
see
as
the
first
era
of
rust
development.
A
Where
we've
been
chasing
this,
this
road
runner
of
adoption,
right
and
so
rust
in
some
sense,
really
got
its
start
back
in
2015
with
rust.
One
point
out-
and
this
was
when
I
say
it
got
its
start.
What
I
mean
is
that
was
the
point
where
adoption
became
a
realistic
thing,
because
at
one
point
no,
we
stopped
breaking
the
language
every
day
and
it
became
possible
to
actually
build
things
on
top
of
rust,
and
so
that
that
was
a
great
starting
point.
A
But
to
reach
that
point
where
we
could
make
promises
about
the
language
and
compatibility
and
so
on,
we
had
to
strip
it
down
to
its
core
so
that
we
could
be
sort
of
confident
in
what
we
were
shipping.
We
could
be
prepared
to
make
those
promises-
and
you
know
not
actually
have
to
go
through
much
breaker,
so
the
process
leading
up
to
1.0
was
a
lot
of
stripping
down,
so
that
was
a
successful
launch.
But
after
that
we
have
felt
the
need
to
sort
of
build
things
back
up
right.
A
So
when
we
strip
things
down
to
the
core,
we
had
a
language
that
we
could
make
promises
about,
but
not
one
that
was
necessarily
especially
productive
to
start
with,
because
it
had
been
so
stripped
down
and
so
in
in
this
first
map.
One
of
the
things
that
we
highlighted
as
our
major
goal
to
drive
toward
adoption
was
improving
the
productivity
of
rust
and,
in
particular
with
1.0.
It
was
clear
that
rust
was
a
language
for
writing
fast
programs
and
for
writing
reliable
programs,
but
we
wanted
to
make
productivity
a
sort
of
another
key
pillar.
A
Now,
if
you've
been
following
the
development
closely,
you
might
know
that
this
goal
of
2017
was
a
little
bit
optimistic
and
in
2018
we
set
out
another
road
map,
which
is
essentially
said.
You
know,
promising
to
ship
all
of
the
things
that
that
we
worked
on
in
2017
and
so
that
this
is
all
coming
together
in
a
new
version
of
rust,
which
probably
most
of
you
have
heard
about
rust,
2018,
which
is
trying
to
bring
together.
A
Basically
all
the
work
that
we've
done
since
1.0
and
and
put
it
out
into
the
world
as
a
clear
milestone
in
the
development
of
rust.
So
so
this
is
great
and
I'll
talk
a
little
bit
more
detail
about
what
all
these
pieces
mean.
But
suffice
it
to
say
that
we
have
been
working
really
hard
since
1.0.
To
do
everything
we
can
to
spur
adoption
of
rust
to
make
rust
an
appealing
language,
a
useful
language
for
people
to
use.
A
A
Yes,
so
that
that
will
be
shipping
along
with
many
other
improvements
to
the
core
ownership
system?
There
is
also
the
the
module
system
revamp,
which
I
think
was
a
great
example
of
our
community
coming
together
and
working
through
a
huge
design,
space
working
through
contentious
issues
and
winding
up
with
something
that
pretty
much
everybody
seems
happy
with
their
number
of
other
language
features,
but
also
a
lot
of
great
documentation,
changes
of
bran
new
primary
book.
A
That's
terpil
is
the
rust
programming
language,
as
well
as
a
number
of
new
books
this
year
that
are
focused
on
particular
application
domains
for
us,
like
embedded
command
line,
applications
and
web
assembly,
and
then,
in
addition
to
that,
the
tooling
has
gotten
a
lot
better.
We
have
incremental
compilation,
we
have
much
improved
IDE
support.
Russ
format
is
going
to
be
reaching
one
point
now:
the
ecosystem
has
been
growing
and
in
the
next
week,
we'll
be
releasing
our
completely
revamped
website
right.
A
Just
a
couple
of
posts
from
social
media
from
the
last
month:
okay-
and
this
is
just
a
selection
and
I-
see
these
kinds
of
posts
fly
by
all
the
time.
So
this
one
is
a
tweet
from
somebody
on
the
Firefox
team.
Probably
most
of
you
know
that
Mozilla's
Firefox
now
uses
quite
a
bit
of
rust,
but
perhaps
even
more
interesting.
If
you
look
at
the
last
year
of
development,
most
new
code
added
to
the
code
base
is
in
rust.
A
very,
very
little.
A
C++
code
was
added
over
this
last
year,
so
it
hasn't
been
just
particular
modules
getting
ported
over,
but
actually
a
whole
change
in
the
mentality
of
adopting
rust
within
Firefox,
which
is
very
exciting,
but
we're
also
seeing
rust
pop
up
in
all
kinds
of
other
application
areas.
So
there
you
know
our
announcements
of
software
like
discord,
using
rust
to
power
some
of
their
networking
along
with
game
SDKs,
and
the
suite
on
the
bottom
is
about
another
new
game
studio.
A
A
So
adoption
is
definitely
happening.
It's
picking
up
steam,
it's
really
exciting.
You
know,
I,
can
feel
a
shift,
especially
this
year
and
there's
one
other
angle
on
adoption
that
we
like
to
keep
track
of.
That's
that's
really
important,
which
has
to
do
with
the
kraits
IO
ecosystem
and
basically
the
open
source
world
of
rust.
A
So
there's
a
interesting
paper
called
empirical
analysis
of
programming
language
adoption,
and
this
paper
did
extensive
surveys
and
other
studies
to
figure
out
what
makes
organizations
decide
to
use
one
language
versus
another,
and
it
turns
out
that
the
top
factor
is
the
strength
of
the
open
source
ecosystem
around
language.
So
this
is
I,
think
a
leading
indicator
of
language
adoption.
So
it's
something
we
need
to
pay
a
lot
of
attention
to,
and
we
see
lots
of
good
news
here
too.
A
So
here's
the
graph
of
the
download
count
per
day
from
crates
I
owe
over
the
last
few
years
since
its
inception,
things
are
trending
in
a
positive
direction.
This
is
very
good.
Another
of
my
favorite
stats
is
you
can
query
github
for
PR
account
by
language
over
time?
This
is
year-to-date
in
2018,
and
these
are
the
top
15
languages
used
in
github.
Rust
is
the
15th
one,
so
I
mean
it.
On
the
one
hand,
it's
kind
of
sad
to
be
at
the
bottom
of
this
chart,
but
on
the
other
hand,
we're
in
pretty
amazing
company.
A
Everything
else
on
this
list
is
a
major
major
language
that
you
know.
Everybody
is
aware
of
and
notice
in
particular
we're
neck
and
neck
with
Scala
and
Swift.
And
if
you
look
at
the
trend
lines
we
backed
in
2019,
we
will
surpass
Scala,
and
you
know
perhaps
Swift
as
well,
and
just
to
give
you
some
sense
below
rough.
Here
are
several
other
really
major
languages
right.
A
A
Okay,
so
that
was
the
optimistic
part,
so
the
thing
is
one
of
my
favorite
episodes
of
the
coyote
and
roadrunner
show
is
the
one
in
which
the
coyote
actually
catches
the
roadrunner.
The
problem
is
the
roadrunner
through
some
magic
has
transformed
into
a
giant
bird.
So
that's
the
Roadrunners
leg
and
the
coyote
is
sort
of
non-plus
doesn't
know
what
to
do
right,
and
this
is
basically
what
my
talk
is
about
right,
I
feel
like
as
of
2018.
You
know
we
can
really
see.
The
trajectory
is
clear.
With
rust,
adoption
is
happening.
A
Everything
is
trending
in
a
good
direction,
so
it
feels
like
we're
about
to
catch
the
roadrunner
and
that's
kind
of
a
problem.
So
what
I
want
to
talk
about
in
the
rest
of
this
talk
are
some
of
the
dark
sides
to
success.
Basically,
as
we
look
out
ahead
now
now
that
we've
reached
a
certain
level
of
adoption,
we're
going
to
have
a
whole
new
set
of
problems,
the
game
is
no
longer
going
to
be
about
getting
rest
adopted
at
all.
A
It's
gonna
be
about
coping
with
what
adoption
actually
means
and
growing
as
a
community
to
handle
those
changes.
So
I'm
going
to
go
through
three
overall
kinds
of
problems.
You
know
that
I
expect
to
arise.
This
isn't
comprehensive,
but
these
are
some
of
the
things
that
I
and
the
core
team
have
been
thinking
about.
So
the
first
one,
perhaps
the
most
obvious
one
is
as
we
gain
adoption.
We
are
bringing
a
whole
new
set
of
stakeholders
into
the
rustboro
into
the
rest
community,
which
sounds
great
and
in
fact
it's
sometimes
sounds
really
great.
A
So
I've
had
this
conversation
with
multiple
giant
companies,
where
these
companies
are
already
paying
people
to
develop
rust
itself,
in
some
cases,
full
time
as
well
as
contractors
and
they're
still
not
satisfied.
They
also
want
to
just
throw
money
at
the
rust
community,
which
seems
like
a
great
problem
to
have
right.
A
So
so
the
thing
is,
while
this
this
is
an
amazing
development
there's.
There
are
also
a
lot
of
pitfalls
around
the
growth
of
money
and
value
and
in
the
Rust
community,
and
this
spells
a
lot
of
change
for
how
we
operate.
So
one
of
the
challenges
here
is
that
it's
very
easy
for
money
to
become
equated
with
power
right.
So
if
all
these
companies
are
pouring
megabucks
into
rust,
they
might
accept
expect
to
get
something
out
of
that.
And
what
does
that
mean
for
us?
A
And
you
know
one
of
the
things
that
the
core
team
has
been
a
little
bit
hesitant
about
going
down
this
road.
So
we've
tried,
you
know,
setting
up
sort
of
more
of
a
matchmaking
thing
like
hey.
If
you,
if
you
want
to
support
rust,
we
know
some
people
who
would
love
to
be
supported
and
you
can
choose
we're
not
going
to
choose
for
you,
but
even
that
is
fraught
because
which
people
go
on
the
list.
A
Right
I
did
a
personal
little
attempt
at
this,
and
you
know
had
my
set
of
people
who
I'd
sort
of
personally
vetted
and
I
just
try
to
try
to
be
clear
like
hey.
This
is
just
the
thing
I'm
doing
on
the
side
and
I
got
lots
of
email
saying
why
why
aren't
I
on
the
list
can
I
be
on
the
list?
So
again
what
once
money
comes
into
the
picture?
A
Things
can
get
dicey
and
then,
of
course,
I
think
it
might
be
a
bit
early
to
ask
this
question,
but
eventually
the
question
of
Enterprise
rust
and
what
that
means
is
going
to
be
really
important
for
the
community
to
focus
on.
So
that's
that's
one
new
challenge,
a
good
problem
to
have
there's
a
lot
of
money,
but
money
creates
problems.
A
Here's
another
set
of
problems
again
coming
from
some
conversations
I've
had
with
folks.
So
as
people
are
using
rust
in
production
and
we've
got
all
this
great
stuff
and
development,
that
I
was
talking
about
with
rust,
2018
and
so
on,
not
all
of
it
is
shipping,
as
students,
people
would
prefer,
and
so
sometimes
people
in
these
organizations
end
up
using
unstable,
rust
and
sometimes
as
their
projects
get
higher
profile.
Management
feels
a
little
unhappy
about
that
right,
and
so
then
it
comes
back
around
to
the
core
team
and
others
and
they're
sort
of
asking.
A
What
can
we
do?
How
can
we
get
this
API
stabilized
right
and
again
with
with
strong
production
usage,
the
pressure
to
shift
throws
also
people
start
doing
things
that
we'd
prefer
that
they
didn't
so,
as
as
you
might
know,
or
perhaps
I'll,
let
you
in
on
the
secret,
it's
possible
on
a
stable,
rust,
compiler
to
use
unstable
features
if
you
pass
in
a
magic,
bootstrap
key,
which
is
what
we
use
to
be
its
traffic
compiler
and
in
fact,
the
initial
version
of
this.
We
made
it
really
hard
for
people
to
do
this.
A
We
don't
want
people
to
do
this,
but
we
have
to
have
it
for
bootstrapping
purposes
and
of
course,
people
found
it
and
do
it
right
there
by
sort
of
subverting
the
whole
system.
So
again,
when
you
go
into
production
use,
there
are
all
kinds
of
new
pressures:
people
have
to
slap
things
together
and
ship,
and
that
is
a
change
in
the
rust
community.
A
As
we
grow
adoption,
these
kinds
of
pressures
are
going
to
be
more
prominent,
so
I'm,
a
big
fan
of
shipping
I
feel
like
in
fact
most
of
what
I
do
in
the
rust
communities.
Try
to
help
us
ship
things.
So
that's
definitely
not
inherently
bad,
but
if
you
look
at
what
has
made
rust
what
it
is
so
far,
you
know
we
have
a
community.
A
That's
been
built
largely
of
passionate
enthusiasts
and
small
companies,
there's
a
risk
that
those
people
are
going
to
get
drowned
by
the
needs
of
bigger
and
bigger
companies,
bigger
and
bigger
money
going
into
rust.
And
so
it's
a
question
of
balance.
How
how
do
we
make
sure
we
continue
to
make
rust
the
best
it
can
be
well
supporting
all
of
these
new
production
users
who
are
getting
a
lot
of
value
out
of
it?
How
does
our
consensus
process
from
the
RFC
process
withstand
this
increasing
pressure?
Alright,
these
are.
A
So
in
another
category
of
problems
we
want
to
think
about
is
contributor
growth
right.
So,
as
the
production
usage
increases,
so
does
the
open
source
contribution,
that's
fantastic
and
in
fact
you
can
see
a
sort
of
pivot
point
at
2018
for
various
reasons:
the
the
growth
of
the
formal
rust
team.
So
this
is
all
of
the
different
rust
teams
like
language
and
compiler
and
libraries,
documentation
and
so
on.
It's
really
exploded
and
that's
been
very
intentional.
A
We've
been
trying
to
empower
more
and
more
people
to
get
involved
in
setting
the
direction
of
rust,
so
this
is
great,
but
again
it
brings
some
problems
with
it.
So
here's
a
quote
from
Brian
Anderson
made
I
think
maybe
a
year
or
two
ago,
sort
of
talking
about
some
of
the
problems
that
come
about
by
this.
This
growth
in
team
size
and
basically
the
issue
is
when
the
community
grows
so
big
when
the
teams
are
growing
so
big,
it's
not
really
enough
for
people
to
just
show
up
and
start
hacking
on
stuff.
A
You
really
need
management
and
you
need
a
lot
of
management
right.
So,
as
we
grow
the
number
of
teams,
we
need
to
grow
the
number
of
middle
managers
who
can
help
people
find
their
way
to
make
an
impact
on
rust,
and
it
turns
out
that
is
really
hard
it
from
from
where
I
sit
the
most
precious
commodity
in
the
rust
community
is
technical
leadership
like
when
it
comes
to
engineering.
If
we
have
a
clearer
engineering
problem,
we'll
just
give
it
to
Alex
it'll,
be
great
I
mean
sorry.
A
A
You
know
it
takes
kind
of
a
special
kind
of
person,
so
you
spend
their
volunteer
time,
scheduling,
meetings
and
sending
emails
to
people
and
just
trying
to
help
people
work
together
if
you're
one
of
those
special
people,
please
let
me
know
we
really.
We
really
need
more
of
you
and
you
know
in
the
coming
years,
I
think
the
the
core
team
wants
to
put
a
lot
more
work
into
supporting
and
guiding
these
growing
sets
of
leaders,
making
it
more
clear.
A
A
What
what
are
we
making
promises
about?
The
working
groups
just
do
stuff
and
doing
stuff
has
been
really
great,
and
so
we've
been.
We've
had
working
the
four
really
important
working
groups
this
year
as
part
of
Rus
2018
on
domains
of
use,
some
of
which
I
mentioned
earlier.
So
we
have
embedded
CLI,
networking
and
web
assembly
and
they
have
been
just
knocking
out
of
the
part.
It's
been
incredible,
but
there's
a
lot
of
interest
in
and
making
more
and
more
of
these
and
that's
fantastic.
A
A
There
are
risks
that
teams
will
be
pulling
in
different
directions
or
doing
contradictory
things
and
I
find
often
if
you
get
a
team
of
people
who
are
all
super
enthusiastic
about
a
certain
technical
area
like
collections,
for
example,
it's
very
common
for
that
team
to
start
proposing
very
esoteric
stuff,
because
they're
really
into
collections
right
and
so
they're
they're,
just
thinking
about
collections
and
not
any
other
part
of
the
picture.
So
we
have
to
figure
out
how
to
balance
that
kind
of
drive
like
we
want
those
experts
to
be
doing
that
work.
A
But
we
have
to
balance
it
with
a
sort
of
global
coherence
to
make
sure
that
the
RUS
project
is
fitting
together
well
and
that
we're
not
getting
too
lopsided
in
one
direction
or
another
and
part
of
this
too,
is
the
core
team
has
continued
to
grow
and
I
think
we're
sort
of
straining
to
be
effective,
and
so
in
the
coming
years.
I
think
we
want
to
restructure
how
the
central
leadership
works
to
and
I
have
ideas
about
that
I'm
not
going
to
get
into
it
and
the
talked
on.
A
But
if
you
have
thoughts,
I'd
love
to
chat
with
you
after
okay,
so
those
those
are
problems
related
to
contributor
and
team
growth
and
then
there's
one
more
set
of
problems,
and
these
relate
to
using
rust
in
larger
and
larger
scale
programs.
So
you
know,
as
rust,
initially
gets
adopted.
Obviously,
people
are
writing
brand
new
code
that
the
code
bases
are
not
that
big,
there's
not
initially
such
a
thing
as
legacy
rust
code,
but
that's
changing
over
time.
So
this
graph
excuse
me
is
from
our
2018
survey
the
blogpost
on
the
survey.
A
Results
should
go
out
next
week,
but
this
is
a
little
sneak
peak.
So
this
is
a
breakdown
that
we
give
every
year
of
the
size
of
the
code.
Rust
code
bases
that
people
are
working
on
from
the
survey
respondents
and
what
we've
seen
unsurprisingly
each
year
is
that
the
proportion
of
larger
code
bases
is
growing
right.
So
20%
of
the
survey
respondents
and
we
had
it,
run
around
I-
think
five
or
six
thousand
twenty
percent
of
them
say
they
work
on
code
bases
between
10,000
and
a
hundred
thousand
lines
of
code.
A
That's
pretty
sizable
and
three
percent
work
on
code
base
is
even
bigger
than
that,
so
this
is
great
right.
This
is
a
sign
that
not
only
is
rust
getting
adopted,
but
it
has
a
sort
of
lasting
place
in
these
organizations
that
you
know
for
the
code
bases
to
get
this
big
people
are
continuing
to
use.
Rusts,
that's
awesome,
but
as
with
all
these
other
things,
it
leads
to
problems
as
well.
A
So
you
know
again
going
back
to
cases
where
features
are
unstable
or
things
have
only
partially
shipped
etc.
Sometimes,
we'll
hear
from
these
big
production
users
saying
that
they're
doing
just
insane
things
to
make
it
work
and
they're
under
pressure
to
ship.
This
is
natural.
This
is
just
what
happens
with
software,
but
it's
going
to
exert
some
new
pressures
on
language
design
and
you
know
other
aspects
of
the
technical
direction
of
the
project
right,
so
just
to
make
this
a
little
more
concrete.
A
You
know
this
is
something
I
I
in
the
language
team,
worried
about
a
lot
where,
partly
because
of
our
consensus
process
and
partly
because
of
just
the
nature
of
shipping
software,
we
often
end
up
with
these
kinds
of
cliffs
that
you
can
fall
off
in
the
language.
So,
for
example,
the
infiltrate
feature
was
has
been
hotly
desired
since
well,
before
rust.
1.0
even
and
we
eventually
did
ship
a
stable
version
of
infiltrate,
but
it
only
works
in
sort
of
inherent
methods
or
free
functions.
A
A
Similarly,
we've
had
associated
type
since
1.0,
but
there
are
limitations
are
on
them.
They
can't
be
generic,
so
this
is
also
known
as
higher
kind
of
types
or
generic
associated
types.
We
have
non
lexical
lifetimes,
which
is
amazing,
but
if
you've
been
following
me,
COEs
excellent
blog
series
you'll
know
that
there
are
still
lots
of
limitations
around
borrowing,
especially
across
multiple
functions.
Right
and
so
there's
there's
a
huge
list
of
things
like
this,
and
you
know
I
think
part
of
the
takeaway
here
like
it's,
it's
unsatisfying
that
we
have
these.
A
The
problem
is
now
that
we're
successful
with
that
and
people
are
picking
up
rust.
They
become
intermediate
users
and
then
they
start
hitting
these
cliffs.
And
it's
it's
easy
to
sort
of
see
how
to
solve
all
these
problems.
Right,
like
we
can
add
generic
associated
types,
we
can
extend
the
borrowing
system,
we
can
add
infiltrate
into
traits
all
right.
A
We
sort
of
know
the
story
for
all
of
these
things,
but
there's
a
risk
that,
by
filling
in
all
those
gaps,
we
also
increase
the
complexity
and
learning
curve
of
the
language
overall
and
therefore
sort
of
defeat
our
original
goal
of
making
it
a
newcomer
friendly.
So
one
of
the
challenges
you
know
in
the
next
years
is
going
to
be:
how
do
we
balance
between
filling
out
these
gaps?
And
you
know
staying
friendly
to
two
newcomers
and
you
know
staying
a
language
that
you
can
fit
in
your
head.
A
Here's
another
preview
from
the
survey
results
where
people
were
asked
to
rate
their
expertise
in
rust.
I
really
want
to
know
the
people
who
are
on
the
ten
I.
Definitely
don't
count
myself
there,
but
you
know
I
think
this
is.
This.
Is
a
really
interesting
curve
and
one
that's
maybe
a
little
different
from
from
past
years,
where
it's
kind
of
clumping
around
the
middle
right,
so
people
consider
themselves
intermediate
row
stations
a
lot
right
and
this
this
is.
A
A
Talking
about
this,
how
there
are
patterns
of
using
rust
or
any
other
language
that
you
could
do
at
the
very
beginning,
like
all
the
features
were
there,
but
nobody
knew
how
to
do
that,
and
it
takes
years
of
exploration
and
building
software
and
curry
the
hacks
to
start
to
identify
these
patterns
and
make
them
part
of
the
culture
and
community.
And
so
you
know,
part
of
the
premise
of
Florian's
post
is
circa
2018.
A
Not
only
do
we
risk
alienating
newcomers-
and
you
know
raising
the
learning
curve
again,
but
we
may
create
deeper
problems
in
the
language
that
we
can't
anticipate
or
rule
out
patterns
that
we
haven't
discovered.
Yet
so
again,
there's
there's
a
tricky
balance
here.
The
pressure
is
going
to
increase
more
and
more
over
time
to
fill
in
these
gaps,
as
these
big
production
users
are
are
hitting
these
problems,
but
we
also
need
to
take
our
time
and
make
sure
we
fully
understand
how
to
use
this
language
that
we're
all
developing
together.
A
So
those
are
some
of
the
challenges
that
I
see
ahead
of
us.
Some
some
themes,
I'm
sure
that
you
can
think
of
others
and
I
think
you
know,
as
we
kick
off
the
process
of
thinking
ahead
for
the
next
three
years
to
the
next
edition
of
rust.
Let's
call
it
rust,
2021
I'm,
not
really
so
worried
about
just
the
pure
technical
pieces,
like
we
have
a
very,
very
technically
minded
community.
We
have
a
lot
of
excellent
people.
The
RFC
process
catches
all
kinds
of
mistakes.
My
worries
are:
almost
all
people
worries.
A
How
do
we?
How
do
we
grapple
with
this
growth?
These
are
really
hard
challenges.
They're
challenges
that
every
successful
language
community
has
faced-
and
you
know
I
didn't-
want
to
go
into
examples
here,
but
you
can
look
at
language
communities
that
have
stumbled
on
some
of
these
challenges
and
that
has
caused
all
kinds
of
damage
right.
A
A
These
problems
is
to
have
clarity
and
commitment
to
our
core
values
and,
to
me
the
most
part
value
of
rust
is
that
it's
an
empowering
technology,
it's
a
technology
that
can
take
a
JavaScript
developer
and
let
them
write
systems
code
or
take
a
grizzled,
C++
hacker,
and
let
them
be
far
more
ambitious
with
the
kinds
of
things
they
do
right
it
can.
Let
you
face
down
concurrency
without
being
terrified
of
bugs
or
program.
Your
first
embedded
device
right
rust
is
just
full
of
possibilities
and
empowerment
and
I.
A
C
A
D
How
to
keep
track
of
the
language
and
understand
language
as
it
grows,
and
it
seems
to
me
like,
and
maybe
you've
already
considered
this
a
more
formal
approach
to
the
language
could
help
in
that
direction.
So,
for
example,
Rawls
and
Derek's
work
on
Rust
Belt,
some
like
may
be
helpful
to
keep
track
of
understanding
what
the
current
language
is
and
how
it
could
evolve
in
a
way
that's
safe.
Do
we
have
thoughts
about
this
and
something
they're
thinking
about
yeah.
A
Absolutely
so,
just
for
those
who
aren't
aware
of
this
work,
so
this
is
there's
something
called
the
Rust
Belt
project
and
Ralph
young
who's.
Here
today
is
you
know,
sort
of
I
would
say
the
lead
of
this
project,
and
so
part
of
its
goal
is
to
mathematically
prove
both
the
sort
of
safety
and
soundness
of
core
rust,
but
also
give
you
the
tools
to
verify
that
unsafe
code
actually
behaves
safely
right.
So
this
is
critically
important.
A
Looking
at
things
like
the
standard
library,
where
we're
using
unsafe
code
to
build
up
the
basic
substrate
of
rust-
and
you
know,
Ralph's
group
has
already
verified
a
bunch
of
the
core
pieces
in
the
standard
library
and
also
found
some
bugs.
So
this
is
hugely
important
work
and
one
of
the
things
that
I
find
really
exciting
about.
It
is,
unlike
many
academics.
A
A
I
completely
agree,
that's
that's
critical,
for
especially
these
extensions
to
the
language
that
are
more
fundamental,
that
sort
of
risk
soundness,
but,
at
the
same
time,
a
lot
of
the
growth
and
features
that
I'm
thinking
about
I
don't
feel
like
soundness
is
a
primary
worry.
It's
you
know
like.
If
you
look
at
something
like
hire
kind
of
types,
that's
very
well
understood,
I,
think
we
know
more
or
less
how
it
should
taste
in
language.
The
fear
is
more
that,
once
you
add
that
high-powered
features
you
create
more.
C
A
More
more
places
of
interactions
between
those
features
and
other
ones,
so
not
not
to
pick
on
another
language,
but
I'm
gonna
pick
on
another
language,
so
I
back
in
grad
school
I
played
around
with
Haskell
a
bit
high
schools
of
really
cool
language,
lots
of
good
ideas,
and
it
has
lots
of
extensions
that
you
can
turn
on
with
all
kinds
of
bells
and
whistles
and
new
features.
And
my
experience
using
this
is,
if
I
turn
on
one
of
those
extensions
and
started
using
one
of
those
new
features.
B
A
A
great
question,
so
one
of
the
things
that
I
love
about
being
part
of
the
rest
community
is
because
it's
it's
gotten
so
big
generally
people
come
to
us,
so
we
do
have
contacts
with
sort
of
representatives
from
lots
of
other
language
communities
that
participate
on
on
RFC's.
So
like
we
will
frequently
if
we're
talking
about
something
in
a
trait
system.
There
are
a
couple
of
prominent
Haskell
people
who
will
be
on
the
thread
and
say
well.
A
We
had
this
in
this
experience
with
type
classes
in
high
school,
and
you
know
here's
the
link
in
a
paper
and
so
on
so
yeah.
We
we
definitely
try
to
be
aware
and
delight
within
the
language
team.
Also,
we've
tried
to
have
a
diversity
of
language
backgrounds
to
draw
those
things
in.
So
you
know
it's
definitely
something
we
do.
On
the
other
hand,
you
know
language
design
is
very
particular
so
things
that
are,
you
know,
even
though
Haskell's
type
classes
and
Russ
traits
look
very
similar
superficially.
A
A
A
B
A
Is
a
very
interesting
question
and
yeah
I've
definitely
had
conversations
with
leaders
in
other
communities
like
Martin
in
Turkey,
first
scala,
for
example,
and
to
be
honest,
I
think
in
a
lot
of
ways.
Rust
is
blazing
its
own
path
with
the
RFC
process
and
the
way
that
we
view
governance
and
I,
don't
I
I
feel
like
the
direction
of
influence
is
largely
flowing
from
Russ
to
other
languages,
which
is
something
I'm
very
proud
of
all.