►
Description
APOLOGIES FOR THE POOR AUDIO ON THIS TALK - SADLY A CABLE WAS LEFT UNTERMINATED AND THIS CAUSED A LOT OF DISTORTION AND FUZZ IN THE AUDIO RECORDING. WE HAVE TRIED TO CLEAN IT UP AS BEST WE CAN.
In only three years, Rust came from a long way from being an interesting new research language to a productive language used by industry players such as Dropbox, Facebook and others.
Shortly before its third birthday, I’d like to take the chance to give an overview of the language. What do we have, what’s missing, what’s coming and what changed in the last three years?
A short introduction into the hallmark features of the language is included.
This talk will give a useful overview both to curious non-practitioners as well as seasoned Rustaceans.
A
Just
shortly
before
I
come
to
the
talk
a
little
bit
about
me,
I'm
Fran,
hi
I
used
to
be
very
active
in
the
Ruby
and
elasticsearch
seen
a
couple
of
years
ago.
Maybe
someone
has
my
name
from
that:
I'm,
mainly
known
as
doing
event,
organization
and
community
work.
Less
than
actual
programming
project
work.
I
spent
my
time
professionally.
A
The
reason
for
that
is
that
I
found
that
the
impression
of
such
projects
for
people
is
extremely
localized
to
the
angle.
They
are
approaching
the
project
and
often
doesn't
tell
the
whole
story
to
the
point
where
I
was,
for
example,
recently
at
a
conference
as
an
exhibitor.
So
we
were
there
with
a
with
a
small
booth
and
someone
approaches
and
was
like
oh
wait.
C
A
Was
okay
but
before
I'm
talking
about
the
project
for
those
people
that
have
never
heard
about
the
language,
I
would
actually
like
to
introduce
a
language
who
here
has
ever
had
a
look
at
rust:
okay,
quite
a
couple
of
people,
but
still
quite
some
that
I
wear
any
to
give
a
little
bit
of
an
introduction.
So
what
is
rust?
Rust
isn't
used
to
since
programming
language
that
powers
and
was
developed
along
with
several
a
new
browser
engine
by
Mozilla
research
servo
is
explicitly
a
research
engine,
so
some
people
believe
servo
is
the
next
Firefox.
A
It
is
not.
It
is
not
intended
to
be
and
it
will
never
built
be
its
developers
around
the
community
and
the
first
release
was
in
on
the
15th
of
May
2015.
So,
roughly
three
years
from
now,
next
month's
third
birthday,
it
is
therefore
providing
an
alternative
to
seem
to
C++,
but
also
to
higher-level
languages,
and
its
credo
is
safe.
A
Concurrent
fast,
it's
generally
perceived
that
safety,
especially
memory
safety,
comes
at
a
longtime
cost.
That's
why
the
credo
for
us
is
actually
safe,
concurrent
fast,
big
three,
the
core
features
of
the
language
are:
it
has
a
static
type
system
with
local
type
interference.
It
has
an
explicit
notion
of
mutability,
so
if
to
select,
if
something
is
mutable
or
not,
and
the
language
knows
about
this
and
makes
conclusions
using
that
this
same
thing,
that
we
call
zero
costs
abstractions,
which
means
it
has
higher
level
extractions.
A
That
may
seem
like
a
higher
level
language,
but
when
we
have
these,
we
make
sure
that
they
compile
down
to
something
which
is
basically
equivalent
to
your
best
handwritten
code.
It
has
run
them
at
one
time:
independent,
concurrency
safety
I'll
talk
about
that
for
very
short,
while
in
a
second
hours
of
values,
so
there's
no
exception
handling.
You
pass
around
any
kind
of
error
as
a
normal
value,
there's
no,
no
to
avoid
any
kind.
Problems
was
known
as
it
has
something
that
would
usually
refer
to
a
static
automatic
memory
management.
A
So
it
feels
like
the
memory
management
is
automatic,
but
it's
actually
all
happening
at
compile
time.
Which
brings
me
back
to
this
a
that.
The
perception
of
memory
safety
is
that
it
has
a
one-time
cost.
We
don't
use
a
garbage
collector
or
anything
like
that
for
that
it's
completely
completely
through
static
analysis.
So
what
does
it
look
like?
This
is
a
piece
of
rust
that
opens
the
temporary
directory
opens
a
file
within
it
and
if
it
can't
open
it,
it
actually
crashes
in
a
safe
fashion.
A
It
just
aborts
the
program
in
a
controlled
fashion,
so
the
language
feels
a
little
bit
like
C
from
the
general
syntax,
so
it
has
curly
braces
and
all
of
that
it
also
has
a
notion
of
aggravate
at
the
break
data
types
like,
for
example,
functional
languages
have
so,
for
example,
if
you
open
this
temp
tear,
this
is
a
folio
operation.
So,
after
that
you
would
have
to
check.
Has
it
worked
or
not
using
this
match
syntax
matching
between
the
options,
okay
and
error.
When
there
was
okay,
you
would
get
the
actual
directory
handle.
A
The
same
goes
for
creating
that
file
which
might
fail
or
not
what
I
mean
by
this
static
automatic
memory
management.
Once
all
of
these
values
drop
out
of
scope,
they
will
be
removed
for
memory
automatically
for
you.
So
the
scope
is
the
time
that
some
some
of
your
data
is
alive
and
it's
fundamental
to
how
the
language
works.
A
The
first
place
concept
that
language
is
based
on
is
any
kind
of
mutability.
So
here's
a
small
example
I
have
a
data
structure
that
it's
in
itself
holds
a
data
structure
again
in
a
data
which,
in
in
it
has
a
number
I,
can
construct
that
this
is
the
construction
syntax
assigned
to
it.
The
compiler
will
complain
because
it
says,
cannot
assign
two
immutable,
fealty
d
dot,
another
12,
the
interesting
thing
here
is
it's
the
binding.
That's
immutable,
so
D,
because
D
is
not
mutable.
A
I
cannot
mutate,
anything
that's
inside,
so
it's
not
a
property
of
the
structures.
It's
a
property
of
the
location
where
I
use
it
here.
I'm
saying
I
want
to
have
immutable
data.
I
could
have
immutable
data
somewhere
else
and
I
introduced
that
by
acts
accident
by
actually
telling
the
compiler.
This
is
mutable
and
now
I
can
change
it.
A
A
On
top
of
that,
it
has
two
other
base
concepts,
and
this
is
ownership
and
borrowing,
and
these
are
the
most
important
parts
of
it.
Just
sometimes
at
the
beginning,
people
have
said:
rust
is
hard
to
learn,
and
one
of
the
problems
of
it
is
ownership
like
talking
about
ownership
of
data,
is
something
that
people
are
informally
used
to,
but
not
formally
used
to,
because
there's
no
other
programming
language
that
we
D
does
it
that
way.
A
So
the
very
first
basic
concept
you
hit
in
rust
is
new,
so
it
takes
a
while
to
finally
click
and
how
it's
important
and
the
way
that
works
is
every
piece
of
data
and
rust
is
uniquely
owned,
and
this,
for
example,
makes
that
memory
management
work,
because
you
know
when
you
know
that
it's
only
uniquely
owned
when
it
drops
out
of
scope.
It's
gone.
A
It's
basically
reference
counting,
but
you
can
only
count
to
one
and
that
statically
solvable
that's
the
compiler
can
do
that
for
you,
ownership
can
be
passed
and
when
owned
data
reaches
the
end
of
a
scope,
it
is
destructed
so
here,
for
example,
again
I'm
opening
a
file
and
I'm
taking
it
and
I'm
writing
to
that
file.
Passing
it
over
to
take
and
write
to
file
by
value
to
another
function
and
a
write
to
the
file,
hello,
aku
conf,
the
researchers
explained
say
at
the
end
of
taken
right
to
file
the
file
is
destructor.
A
A
Now
this
is
is
a
solid
base,
but
it
isn't
very,
like
sometimes
you'd
like
to
pass
things
around
and
actually
not
give
up
ownership.
You
would
like
to
call
a
function
twice
on
file,
and
this
gives
you
an
additional
piece
here,
which
is
borrowing
you
can
borrow
a
way
to
add
the
access
to
one
of
these
pieces
of
data
mutable
or
immutable,
and
you
can
do
that
mutable
once
or
multiple
times,
immutably.
A
This
is
exclusive,
so
whenever
you
borrow
something
away,
buta
bleah
you're
not
allowed
to
get
a
mutable
access
to
it
at
the
same
time
and
the
other
way
around.
So
speaking,
more
on
a
systems,
programming,
language,
language,
rust
forbids
aliasing,
mutable
pointers
strictly
so
the
same
here,
I'm
opening
a
file
I'm
writing
through
the
file
twice,
and
the
only
difference
is
that
I'm
actually
using
different
syntax
here,
I'm
using
an
ampersand
to
indicate
a
borrow
or,
if
you're
coming
from
the
C++
world.
This
is
basically
a
reference
and
the
moot
again
describes.
A
A
A
So,
for
example,
if
I
have
a
I
have
a
vector
containing
three
elements
and
I
access,
one
of
the
elements
immutably
and
then,
while
this
is
active,
I'm
trying
to
write
to
it,
the
compiler
will
actually
error
and
say
you
cannot
borrow
this
vector
is
mutable
to
actually
mutate
it,
while
there's
still
an
immutable,
borrow
active
classic
problem.
If
I
mutate,
a
vector,
it
could
actually
be
moved
in
memory
and
the
first
pointer
might
end
up
being
invalid
during
that
time.
A
It
even
goes
as
far
as
checking
in
a
references,
for
example,
if
I
have
a
structure
which
holds
an
inner
reference
to
an
integer
and
I,
try
to
return
it,
and
in
this
case
ownership
says,
because
it's
introduced
within
because
number
is
introduced
within
returned
reference,
but
you're
trying
to
give
away
a
reference
to
it
through
that
data
wrapper.
It
will
actually
know
about
the
binding
relationship
between
the
two
and
will
know
that
the
inner
reference
will
end
up
being
a
dangling
one.
A
The
compiler
a
message
here
will
be
the
number
doesn't
live
long
enough
and
will
actually
tell
me
the
barrel
value
only
lives
until
here.
The
most
compiler
is
quite
known
for
giving
good
error
messages.
We
have
two
engineers
that
regulated
welcome.
That
almost
function
is
not
only
signal
data
types
but
also
mutability
ownership
and
interconnections
between
input
and
output
types.
This
is
quite
rich
if
you
like
working
with
functions
but
would
like
to
have
a
little
more
information
in
your
function.
A
Signatures
rust
is
probably
in
the
language
we
for
you
and
the
interesting
thing
here
is
these
properties
hold
and
can
be
checked
on
large
code
bases
of
basically
any
size.
This
is
one
of
the
parts
where
it
shows
that
the
language
comes
out
of
an
engineering
culture
that
owns
one
of
the
largest
C++
code
bases
in
the
world,
so
Mozilla,
because
sometimes
the
language
feels
a
bit.
Oh,
this
is
pretty
pedantic
for
a
2/3,
a
line
line
piece
of
code.
A
This
provides
a
set
of
abstractions
on
top
of
that
it
has
high-level
abstractions
through
generics
and
traits
similar
to
C++
templates
or
Java
generics,
which
I
don't
want
to
go
into
detail
here.
The
syntax
is
pretty
usual,
so
you
have
angle
brackets
for
introducing
generics
and
colons
for
introducing
bounds
on
these
generics.
It's
all
rather
standard.
A
The
program
is
because
I'm
capturing
a
value
of
the
moment,
I
stopped
the
thread.
I'm
passing
on
ownership.
I
can
only
do
that
once
I'm
trying
to
start
three
threads
how's
that
going
to
work.
So
this
moving
passing
on
ownership
off
the
counter
to
threats,
doesn't
work
the
people
and
their
solutions
for
that.
Let's
use
some
kind
of
data
sharing,
for
example,
a
menu
or
F
counter
to
do
this.
A
Less
provides
that
we
just
start
having
her
we've
wrapped
our
stuff
in
a
rev
counter,
er
the
rev
counter
API
works
through
that
works
by
actually
cloning
all
those
handles.
But
that's
a
detail.
The
interesting
thing
is
suddenly
the
compiler
states
who
complain
our
F
counters
cannot
be
sent
between
threads.
Why
the
standard
ref
counter
in
rust
does
not
synchronize
the
internal
reference
count
and
the
compiler
knows
about
this.
A
A
So
next
thing
we
do
we're
trying
to
use
another
kind
of
reference
counter,
and
the
other
thing
that
the
language
knows
about
is
even
if
I
were
using
another
reference
counter
I
would
still
not
sutras.
I
can
synchronize
on
the
value
which
will
bring
rust
to
the
point
where
it
will
ask
me
to
actually
provide
synchronization.
So
the
compiler
has
an
abstract
idea
of
what
it
is
of
sending
values
to
different
to
different
threats,
which
is
the
sending
of
the
rev
counter.
A
It
also
has
an
abstract
idea
of
what
it
means
to
share
data
between
threads,
which
would
be
synchronization.
It
has
these
two
turns.
Interestingly,
while
the
sending
and
syncing
part
is
part
of
the
language.
This
idea,
the
threading
API,
for
example,
is
part
of
our
standard
library.
If
you
want
to
use
your
own
sweating
implementation,
you
can
totally
supply
that
and
you
will
get
the
same
support.
So
it's
not
like
the
language
itself
has
primitives
like
thread
primitives
that
ensure
this.
The
language
itself
has
that
abstract
idea
of
sending
and
sharing
data
it
does.
A
C
A
So
the
swatches
are
introduced,
they're,
looking
a
lot
like
sea
structures
and
the
structure
like
the
standard
structure
layout
in
rust
is
not
defined
just
because
the
compiler
might
optimize
on
that,
but
there's,
for
example,
an
annotation
where
you
can
say
leprosy
which
would
make
that
structure
be
laid
out
like
sea
wood,
I'm
using
reusing
LLVM.
So
it's
using
the
back
end
to
actually
find
out
the
structure
of
this
and
then
giving
you
the
ability
to
just
directly
call
it
to
sea
and
back
we've
supported
the
sea
ABI
for
functions.
A
A
Because
it
knows
that
IRC
is
not
send
able
between
threads,
it
knows
that
by
the
type
definition.
So
the
rule
in
the
compiler
is
a
there's,
a
couple
of
types,
a
couple
of
primitive
types
that
are
sent
and
a
couple
of
primitive
types
that
are
sync
and
some
even
that
are
both
and
it's
automatically
derived,
and
so,
if
structural
holds
send
herbal
types,
it
will
actually
that
will
actually
bubble
up
our
sees
in
themselves
have
this
mutable
counter,
which
is
in
itself
not
in
neither
sin
nor
sink,
and
the
compiler
knows
about
this.
A
C
C
A
A
closure,
that's
a
closure,
it's
the
closure
with
no
arguments,
because
it's
the
threading
API
doesn't
pass
you
any
arguments.
What
it
does
it
is
it
closes
over.
We
have
it
be
using
the
feature
that
they
actually
closed
over
to
move
data
into
the
closure.
So
the
moment
that
I
refer
to
handle
I
will
actually
move
ownership
from
handle
to
the
thread
we
have
agree
using
this
move.
Moving
ownership
idea
in
the
threading
ap
is
not
so
much
in
the
in
async
api's.
B
A
B
B
A
B
A
A
This
multiple
problems
in
off
there
and
because
we're
based
on
the
LLVM,
the
LLVM,
for
example,
for
a
long
time,
had
an
annotation,
which
you
could
tell
it
by
the
way
this
point
it
doesn't
a
yes,
then
it
would
miss
compile
because
no
one
else
was
using
that,
so
we
had
strictly
more
information.
And
yes,
it
is
an
advantage
that
we
have
that
currently,
there's
mainly
because
they
get
language
is
young.
There's
no
rust
specific
optimizations
being
applied
at
a
larger
level,
because
of
that.
A
So
yes,
maybe
that's
an
option,
so
I
wouldn't
be
hopefully
so
they,
when
we're
talking
about
performance
for
us,
especially
we're
in
the
C
C++
area,
depending
on
benchmark
you'll,
be
faster
depending
on
the
benchmark,
we're
slower.
Sometimes
it's
C
with
GCC
is
faster
than
comes
rust.
Then
come
C
was
clang.
It's
that
kind
of
area.
It's
the
same,
ballpark
so
probably
about
that's.
The
thing
that
I
will
currently
think
about.
A
Also
getting
rid
of
existing
code
is
a
much
bigger
problem
than
just
having
an
alternative
language
around.
That's
the
reason
why
servo
is
not
built
for
replacing
Firefox
it's
the
testbed,
where
you
don't
have
to
build
on
a
production
system
to
actually
figure
out
stuff
before
you
port
it
to
a
production
system.
A
Which
leads
me
to
the
main
part
of
the
talk
with
three
years
of
rest,
because
we
are
young
language,
but
we
already
got
a
couple
of
things
figured
out
and
the
reason
why
I
do
these
kind
of
talks?
Is
anyone
here
involved
in
an
open
source
project
in
a
larger
one?
That's
great
I'd
love
to
hear
from
your
experiences,
because
one
of
the
experiences
I
have
is
that
actually
not
a
lot
of
people
have
a
lot
of
interaction
about
that
of
what
works
for
them
and
what
not.
A
So,
when
I
prepared
this
talk,
I
was
kind
of
thinking
on
how
to
structure
it
and
I
ended
up
with
a
lot
of
small
snapshots
from
the
last
three
years
and
I
try
to
find
a
structure
and,
in
the
end,
I
figure
that
I
can't
because
I'm
also
just
one
person
somewhere
and
the
project
is
global,
so
maybe
someone
else
would
have
their
number
of
snapshots
over
the
last
three
years.
It
could
be
something
completely
different.
A
So,
let's
start
at
the
beginning,
when
we
were
finally
done
2050
2050
was
West
is
a
10
year
old
programming
language.
It
is
as
old
as
go
and
before
that
it
was
a
research
language
at
Missoula
research
and
around
2014.
Someone
at
Mozilla
decided,
ok
people,
maybe
it's
a
good
time
to
finally
come
up
with
something
done.
Mozilla
is
an
organization
that
is
very,
very
focused
on
actually
building
final
products.
A
So,
even
when
you
are
in
Mozilla
research
everything,
your
research
has
to
be
released
every
two
month
like
a
clockwork
because
they
consider
releasing
part
of
having
software.
If
it's
not
releasable,
it's
not
software
by
their
definition,
and
that
was
also
something
that
attracted
a
lot
of
people
all.
It
definitely
has
attracted
me
because
it
meant
like,
even
though
you
had
the
chance
to
have
a
look
at
how
a
programming
language
is
produced.
A
Mozilla
did
it
in
the
open
that
was
first
of
all
the
chance
to
see
it
before
it
came
up
with
one,
oh
and
then
also
getting
like
kind
of
the
feeling
they're
on
to
something,
and
they
actually
want
to
use
that
for
something.
So
it's
not
going
to
be
the
next
language
that
you
learned
that
never
ends
up
being
in
production,
and
that
was
the
air
around
the
project.
Even
back
then,
obviously,
because
of
also
a
large
sponsor
that
had
a
vested
interest
in
actually
using
it,
and
that
actually
meant
removing
a
lot
of
features.
A
The
standard
lip
was
trimmed
tremendously
when
everything
will
that
wasn't
portable
everything
that
would
fit
like
the
new
goal
of
building
a
systems,
programming
language
that
would
be
that
he
could
end
up
putting
on
embedded
devices
but
wouldn't
fit
that
everything
that
was
a
trace
of
a
runtime
system,
reflection
or
whatever
anything
that
would
have
been
kept
or
needed
to
be
kept
around
in
the
binary
to
enable
that
was
killed
off,
and
that
was
only
in
the
last
couple
of
month.
So
this
certain
push
towards.
A
Oh,
we
have
a
date
now
and
we're
going
to
release
and
we're
going
to
release
on
that
date
and
it's
something
that
was
already
a
good
at,
and
that
was
very
interesting
to
see
it
gives
you
a
nice
respect,
also
a
lot
of
things
where
you
can
actually
read
up
the
old
male
sincere.
Why
isn't
rust
using
a
garbage
collector
anymore?
What
doesn't
rust
have
classes?
We
had
classes
at
that
point.
A
There
were
just
not
good
and
also
coming
up
with
economics
and
tooling
around
everything.
The
first
thing
was
we
established
an
RFC
process
even
before
the
language
was
released,
you
can
find
it
under
a
rust,
Lang,
/r
C's.
We
now
have
over
2000
of
those
documents
that
are
trying
trying
out
language
changes
just
as
a
discussion.
All
language
changes
have
to
go
through
that.
A
This
problem
is
solvable
by
money,
and
this
is
what
we
have
to
have
in
Mozilla,
yester,
a
torch,
a
magic
covering
the
the
ability
to
run
things
by
side
by
side
so
similar
to
our
VM
or
in
VM,
but
it
also
managed
this
the
whole
tool
chain.
So
the
rest
compiler
is
by
itself
across
compiler.
So
it
also
manages
being
managing
targets,
Sue's
roots
and
build
routes.
So
all
of
these
kind
of
things,
so
it's
strictly
more
than
what
Ruby
or
or
node,
have
a
documentation
tool
complete
with
API
searching
functionality
and
documentation
testing.
A
It
has
a
testing
mode
in
which
you
can
test
all
the
examples
that
you
wrote
in
your
Docs,
which
is
quite
neat
and
a
complete
book.
The
best
programming
language
first
edition
a
couple,
a
bit
of
compatibility,
tooling,
rust
gdb,
which
just
ensures
that
the
symbols
read
nicer
in
gdb.
The
actual
features
were
committed
to
gdb
of
them
plug-in
and
at
that
time
of
es
code
plug-in,
they
just
said
the
rest.
Come
holla
to
train
is
completely
cross.
A
Compiler
aware-
and
this
is,
this-
is
a
good
decision
to
do
that
early,
because
that
is
hard
to
retrofit
into
an
ecosystem.
The
whole
rust
ecosystem
at
least
has
awareness
of
cross
compilation.
The
release
circle
of
the
language
is
nightly
releases,
or
six
weeks
nightly
is
promoted
to
beta
after
six
weeks,
betas
promoted
to
stable.
So
the
thing
that
we
released
was
actually
the
compiler
version
from
March
and
we're
currently
at
version
125.
A
It
has
worked
instead,
this
the
idea
of
that
is
that
it
ensures
that
you
can
actually
go
from
version
to
version
without
having
a
change
lock
that
I,
don't
know
one's
a
small
highway
or
something
like
this.
It
also
ensures
that
if
people
have
new
features
coming
up,
for
example,
new
cross
compilation
targets,
there's
a
reasonable
time
frame
in
which
they
will
actually
be.
They
can
actually
be
moved
into
stable,
there's
the
Bochy
going
to
since
100.
You
could
there's
an
RFC
for
that,
and
you
can
read
up
what
it
is
it
rust
is
backwards-compatible.
A
The
stable
compiler
only
exposes
the
stable
interface.
So
if
you
are
downloading
rust,
125
and
you're
trying
to
use
any
kind
of
experimental
feature,
it
will
tell
you
I
know
about
this
feature,
but
I'm
the
stable,
compiler
you're
not
allowed
to
use
it
and
cui
interfaces
are
considered
interface.
So
if
you
build
any
kind
of
tooling
on
top
of
cargo,
like
on
top
of
all
of
these
tools,
that
I
mentioned,
you
can
rely
on
their
interface
staying
stable.
The
project
management
was
also
set
up.
A
That
back
then,
and
it
is
explicitly
anti
benevolent
dictator
for
life.
We
are
a
large
group
of
people
and
we
have
no
explicit
leadership
in
the
sense
of
one
person.
There's
a
couple
of
reasons
for
that.
One,
for
the
example
is
that
the
inventor
of
the
language
is
currently
a
product
measured,
Swift
adapter.
A
So
the
we
already
really
have
contributors
coming
and
going
and
leaving
their
mark
and
in
the
language
the
project
looks
fundamentally
different
than
from
rust
a
couple
of
years
ago,
so
this
was
kind
of
like
coming
out
of
the
history,
but
also
we're
quite
happy
with
it.
The
core
team
is
a
tiebreaker.
So
if
there's
any
kinds
of
issues
that
we
have
a
tie
on,
we
have
a
tiebreaker
most
contributions,
and
this
is
something
that
people
frequently
get
from
wrong
are
from
non
Mazzoni
ins.
A
The
project
is
hosted
at
mozilla,
but
mozilla
has
the
tendency
to
have
projects
that
factor
in
a
lot
of
contribution,
and
people
are
quite
good
at
that.
Programmers
at
mozilla,
pretty
good
at
reading
at
actually
code
doing
code
review
they're
much
better
at
that,
and
we
already
had
a
thousand
contributors
in
2015,
so
that
was
definitely
necessary.
All
of
this
was
closed.
A
Teams
are
needs
and
the
initial
team
was
caught
in
for
our
language,
library,
compiler,
documentation,
community
and
moderation,
which
is
also
I,
know
of
not
many
programming
languages
that
actually
have
an
explicit
community
team
or
an
explicit
moderation
team,
or
even
explicit
teams.
For
their
documentation,
we
found
that
actually
just
put
in
your
label
on
those
people
and
making
sure
that
they
have
an
email
address
where
they
can
be
addressed
and
and
an
IC
channel
where
they
meet,
or
we
can
actually
approach
them.
It
has
helped
us
a
lot
so
come.
Basically.
A
These
teams
are
mostly
for
communicating
who
is
actually
working
on
this.
If
you
want
to
talk
to
people
that
are
doing
this
talk
to
us
yeah,
but
it
raises
awareness
of
people's
work
and
makes
them
addressable
and
Batman,
because
we
were
small
project,
we
try
to
figure
out
a
couple
of
things
to
do:
low-friction,
community
interaction,
for
example.
A
Quite
a
while,
until
someone
came
up
with
oh
by
the
way,
I
could
write
a
weekly
newsletter
where
just
write
about
the
most
important
issues
and
what's
coming
out
with
a
project.
The
newsletter
now
is
up
to
250
editions
it's
running
since
3
years,
but,
for
example,
this
one
consumes
the
community
calendar
and
says
well.
Every
week,
I'm
just
gonna,
see
what's
coming
up
in
the
next
two
weeks.
A
Has
a
little
script,
puts
it
in
the
newsletter,
so
the
meetup
organizes
just
put
stuff
in
the
newsletter
and
we're
running
a
little
script,
sending
the
newsletter
away
and
suddenly
everyone
who
subscribes
to
a
newsletter
knows
if
something's
happening
in
the
area.
We
have
an
email
address.
That's
called
community
at
West,
London
org,
which
explicitly
is
for.
A
A
We
send
you
off
someone
calling
the
term
of
we're
the
Rost
languages
switchboard
and
obviously
we
have
forums,
IRC
channels
and
all
of
these
kind
of
things
you
should
totally
have
them
also
nowadays
there
so
may
provide
us
for
that
that
this
is
pretty
easy
to
set
up
for
any
kind
of
project
that
has
more
than
a
couple
of
people,
and
you
usually
find
someone
who
wants
to
do
the
moderation
work
and
make
sure
that
the
IRC
channel
stays
friendly.
The
other
thing
is
lower
friction
contribution.
A
People
want
to
contribute
and
a
thing
that
a
lot
of
projects
fumble
on
and
I,
don't
quite
understand.
Why
is
most
projects
have
no
tasks
for
people
that
just
have
five
minutes
at
a
time.
The
reason
why
I'm
doing
the
switchboard
work
is
I've
got
a
company.
I've
got
a
job,
I've
got
clients
but
I'm
on
the
training
lot.
A
So
when
I'm
on
the
train,
half
an
hour,
I
can
totally
write
some
emails
for
the
project
that
I
want
to
support,
building
a
compiler
future,
not
so
much
so
caring
about
that
has
helped
us
a
lot
and
totally
also
avoid
any
kind
of
lingering
tasks,
so
people
that
want
to
contribute
don't
really
appreciate
if
it
takes
four
weeks
to
just
get
a
reply.
So
goes
as
far
as
that.
A
We
have
a
bot
that
checks
if
someone
is
a
first-time
contributor
and
we
make
sure
that
we're
really
on
site
just
to
make
sure,
because
they
probably
have
far
bigger
question
that
someone
who
is
a
repeat,
contributor
and
often
also
far
easier
to
answer.
Questions
like
this
goes
here.
This
goes
there,
and
maybe
should
you
should
talk
to
that
person.
A
A
Stating
issues
is
great
just
as
long
as
people
are
realistic
about
fixes
something
you
just
can't
fix
next
week,
but
we're
working
on
and
we're
also
completely
fine.
If
people
call
us
out
and
not
working
on
them,
people
often
fear
that
this
is
kind
of
a
taut
with
people
that
are
sometimes
a
little
grumpy
Stern,
or
something
like
that.
That's
fine
grumpiness
is
not
overstepping
or
something
like
this
we're
very
happy.
We
have
a
lot
of
grumpy
people
around.
A
This
is
perfect.
It's
a
technical
project.
Okay,
we're
very
happy
with
the
still
in
discussion
on
a
technical
subject,
great
it's
just
that
we
found
that
whenever
it
goes
into
the
area
area
of
being
actively
insulting,
you've
got
a
problem,
because
people
start
engaging
in
discussions
and
especially
people
that
he
would
like
to
have
in
the
discussion.
A
A
So
the
conclusions
from
the
first
year
are
good
too
many
having
good,
tooling
early,
helps.
Establishing
a
productive
environment
is
work
and
non
programming.
Work
is
a
substantial
amount
of
running
such
a
kind
of
project
and
has
been
incredibly
beneficial
for
that
fast
to
be
very
early
and
crediting
that,
because
people
are
surprisingly
willing
to
give
free
work
to
project,
especially
to
Mozilla
projects,
but
they
would
really
like
to
get
their
little
bit
of
Fame
for
that.
A
It's
it's
a
bit
of
in
the
organization
that
we're
in
it's
a
bit
of
a
fuzzy
question.
For
example,
if
you
work
on
infrastructure
team,
you're,
probably
mostly
talking
to
whether
I
get
my
service
from
where
can
I
put
that
stuff
on
we're
running
one
of
the
largest
now
running,
one
of
the
largest
build
forms
for
an
open
source
project
because
compiled
the
LLVM
does
compile
very
long.
So
this
is
kind
of
like
an
in-between
between
managing
and
that
kind
of
work.
A
The
community
team
tends
to
be
pretty
big
because
there's
actually
a
lot
of
people
that
run
a
meet-up
and
would
be
interested
in
doing
something
else
for
the
project.
On
top
of
that,
so
the
ratio
is
probably
one
third
to
three.
It's
something
like
this,
and
also
pretty
often
the
team's
mean
the
teams
in
the
it's
self-managed
work.
So
there
might
be
people
that
build
a
piece
of
infrastructure
they're,
not
necessarily
in
the
infrastructure
team
if
they
have
no
interest
beyond
their
piece.
A
Because
of
that,
we
have
quite
a
lot
of
contributors,
and
so
kind
of
the
rule
of
thumb,
for
a
team
is
for
being
in
a
team
or
being
involved
in
team.
Is
you'd
like
to
represent
one
of
your
topics
actually
to
the
other
project
to
the
other
parts
of
the
project,
which
is
mainly
a
management
task?
I
would
consider
it
yeah.
B
A
A
Which
means
between
the
second
year
finding
adoption-
and
this
is
also
I
used
to
do
community
management
for
the
Ruby
world
before
and
the
one
thing
I
missed
in
Ruby
was
the
time
when
it
found
adoption
of
being
actually
involved.
I
was
more
involved
later,
so
the
interesting
part
here
was
for
me
to
actually
be
in
that
and
I
think
it's
very
interesting
to
see
how
programming
languages
grow,
because
it's
often
hidden
and
often
the
a
very
complex
thing.
A
A
I
missed
melon
on
the
project
desert,
but
there
seems
to
be
a
lot
of
people
that
do
that
and
half
of
them
in
projects
over
10-k
lines
of
code
of
rust,
like
we
explicitly
asked
for
what's
the
amount
of
rust
code
in
your
project,
which
is
also
quite
interesting
before
that
we
were
expecting
that
most
of
the
people
that
worked
on
larger
code
bases
were
basically
working
on
solar
or
rust.
C
proved
us
wrong.
A
Also,
the
Democrat,
the
demographics
frustations
actually
come
in
equal
parts
from
dynamic
languages,
Java,
Python
and
Ruby,
and
classic
systems,
programming,
C,
C++,
sometimes
D
or
functional
programming
like
an
Haskell
Scala
ever
that
was
also
pretty
interesting.
So
worst
tends
to
become
an
entry
point
of
people
for
people
that
would
like
to
go
back
into
systems
program.
A
Pretty
often
when
we
interview
these
people,
they
are
like
oh
yeah
I
did
it
a
new
University,
then
I
ended
up
having
a
table
and
some
kind
of
rails
agency
did
a
lot
of
rails
later
figured
out
that
maybe
I
should
rephrase
part
of
the
system
in.
Maybe,
if
has
a
programming
language,
but
C
is
memory
safe,
which
one
crashed
my
whole
rel
server
and
suddenly
there's
assistance
for
gaming
language
to
this
memory.
A
Safe
interesting,
so
pretty
often
in
these
kind
of
contacts,
rust
is
actually
not
used,
as
did
you
don't
go
the
whole
project
in
rust,
you're,
actually
building
dynamic
libraries
and
then
calling
into
them,
just
as
you
would
with
C
and
the
community
is
based
in
Europe.
It
was
also
something
you
like
most
of
the
marketing
obviously
comes
from
Mozilla
at
some
places,
so
it's
pretty
often
kind
of
biased
towards
us
style
of
marketing,
especially
this
is
one
of
the
things
and
we
have
other
huge
groups
in
China,
Russia
and
India.
A
This
was
also
something
very
new
to
us
and
we
also
conducted
a
production
user
survey
shortly
thereafter.
After
we
found
out,
we
have
production
users
in
that
size
and
feedback
was
good,
especially
for
low
reliability
and
pain
points,
whereas
is
expected,
so
the
production
uses
we're
mostly
really
using
it
as
an
alternative
language
to
see
a
language
to
write,
shared
libraries
in
well.
A
Finally,
concurrent
codes
such
as
servers,
which
was
a
good
thing
for
us,
because
that
kind
of
gave
us
that,
finally,
the
feeling
that
the
concurrency
same
features
that
we
have
are
actually
useful
in
proper
in
production
and
projects
tend
to
be
really
fully
rust,
but
important
parts
are.
That
was
the
time
when
Dropbox,
for
example,
decided
to
rewrite
large
parts
of
their
back-end
code
base
using
the
language.
But
that
was
only
more
writing.
One
aspect
of
it.
A
User
problems,
where
library
maturity
and
to
a
majority,
because
they
needed
a
certain
piece
of
tooling,
for
example,
for
certain
that
we
didn't
provide
yet
or
a
certain
library
for
a
problem
that
they
had
that
just
wasn't
written
yet,
but
in
general
it
ended
up
being
problems
or
the
kind
of
it's
not
there.
Instead
of
what's
there
is
problematic
and
so
which
ended
up
us
adopting
the
practice
of
being
more
conservative
was
actually
putting
stuff
like
out
finally,
and
actually
making
sure
that
what
we
put
out
is
really
working.
A
The
nice
thing
is
that
businesses
tend
to
be
a
very
different
crowd
of
users.
They
are
very
aware
of
context.
So
if
you
can
plainly
stay
to
them,
what's
not
there
and
plainly
state
to
them
what's
there
and
what's
actually
solving
a
problem
that
gives
them
that
gives
them
a
kind
of
a
feeling
of
kind
of
trying
to
figure
out
what
it
would
give
them
to
actually
adopt
a
new
programming
language,
giving
them
a
bit
of
a
feeling
might
end
up
being
either
something
where
they
say.
A
Okay,
this
is
a
manageable
risk
and
we
might
write
one
or
two
libraries
ourselves.
This
is
interesting.
We
wait
for
a
year,
that's
also
fine,
so
these
kind
of
discussions
were
extremely
useful
and
we
also
have
some
kind
of
production,
user
layer
song,
so
production
users
can
get
access
to
compiler
rated
things
or
hints
from
the
team
without
going
through
public
channels.
A
A
lot
of
companies
are
the
bit
closed,
like
they're
open
to
talk
about
what
they're
doing
in,
if
you're
doing
that
in
a
personal
chat
for
those
who
are
interested,
we've
got
the
friends
page.
This
lists
all
the
companies
that
are
using
rust
in
production
that
we
know
of
and
that
disappeared
us,
their
their
logos
and
a
short
description.
A
Users
are,
for
example,
Mozilla
Dropbox
I
just
mentioned
chuckle
fish
produces
computer
games
chef,
they
are
deploying
Facebook
NP.
So
if
you
download
any
kind
of
JavaScript
nowadays
you
are
using
rust
and
my
favorite
one,
the
opera
house
of
dogwood.
We
use
enough
reproduction
and
over
100
others.
So
a
lot
of
variety
there
so
believe
me,
and
how
do
we
compare
to
others?
And
this
is
a
huge
problem
that
we
have.
A
We
don't
know
we
don't
know
if
that's
good,
because
there's
no
data
on
where
was
go
but
I
think
this
is
talking
about
where
one
and
a
half
years
in
where
was
go
when
we
were
half
a
year,
one
and
a
half
years
in
where
was
javis,
but
no
js'
one
and
a
half
years
in
you
ever
see.
Where
was
no,
but
even
even
if
he
runs
surveys.
A
Other
projects
have
started
to
run
surveys
like
last
year
or
something
like
this.
We
have
no
comparison.
So
most
of
the
comparison
we
have
is
our
own
service
that
we
had
it's
a
really
big
problem
like
I
I
can
get
all
these
numbers.
We
can
get
all
these
numbers.
One
of
the
ideas
that
we
just
had
two
weeks
ago,
where
we
had
an
All
Hands
meeting,
was
that
we
need
a
crystal
ball
meeting.
A
Okay,
when
this
helped
Emma
community
side
is
still
working.
Integrating
beer
people
were
telling
people
that
want
to
run
a
meet-up
to
actually
default
or
not
having
talked
meetups
but
on
having
kind
of
hacking
learned
style,
get
people
in
a
room
start
working
on
projects.
Have
people
help
each
other.
That's
vastly
easier
to
set
up,
that's
vastly
easier
to
run
regularly
and
you
don't
need
extremely
experienced
people
for
that.
A
Most
people
are
not
yet
on
the
state
where
they
would
actually
like
to
give
a
talk,
or
they
didn't
feel
like
they
could
actually
follow
a
talk,
which
also
means
they
don't
show
up
but
having
something
where
they
can.
Just
then,
the
network
have
a
plug,
do
whatever
they
like
and
get
any
questions
answered,
but
someone
who
is
more
experienced
with
them
or
even
just
have
someone
else
working
on
the
same
problem
with
them
that
helps.
We
still
have
very
quick
review
times
for
patches
and
we're
helping
out
wherever,
if
you
can.
A
This
is
something
you
can
measure
very
well.
There's
services
for
that.
I
can
highly
recommend
using
them
if
you're
a
larger
project
that
has
a
little
bit
of
money
for
doing
this,
their
services
that
we
basically
throw
in
any
number
of
repairs
or
repositories,
and
they
tell
you
the
medium
time
of
merge
of
merging
discussions
or
how
long
issues
linger
until
there's
the
next
comment
it's
recommendable
and
we
also
integrate
people
into
the
project
quickly,
so
the
bear
of
actually
being
involved
into
one
of
those
teams
is
basically,
as
I
said.
A
So
in
60
members
of
the
year
where
we
start
conferences,
the
European
one
is
West
fest,
which
I
started
it's
in
Europe
every
half
a
year.
Next,
one
is
being
is
going
to
be
in
Paris
in
one
a
half
month,
what's
conf
in
the
US
every
year
and
respect
rest
also
in
the
US.
Interestingly,
all
these
are
organized
by
o
qo
rubyists
there's
a
basically
all
the
rest
community
is
run
by
old-school
rubyists.
It
must
be
the
first
two
characters
in
the
name.
I
don't
know.
A
And
interestingly
here
they
are
community
run
on
community
sponsored
West
fest
does
not
run
on
Mozilla
money.
Rustbelt
lost,
also
not
lost,
comes
a
little
bit
more,
but
we're
kind
of
making
a
point
that
if
you
want
to
have
a
community
that
holds
up
on
itself
without
having
the
large
sponsor
around,
we
also
need
to
do
that
within
the
community
and
outside
of
Missoula
and
everything
is
we
searched
for
ways
for
supporting
people
online,
we're
on
YouTube
I?
A
That
was
sometimes
during
the
night
someone
was
like.
Oh,
we
could.
Why
not
start
a
YouTube
account
and
just
get
all
the
videos
that
someone
has
about
rust
and
use
the
republish
feature
of
YouTube,
so
we've
got
like
basically
only
have
playlists.
That
say
this
was
at
a
conference
in
2015-2016,
something
like
that.
It's
now
our
biggest
social
media
outlet
and
speaker
than
the
Mozilla
YouTube
channel.
It
is
around
10
hours
of
work
per
year.
A
So,
if
you're
running
a
larger
project
and
you're
struggling
with
social
media,
YouTube
is
extremely
good
at
social
media
and
they're
extremely
good
at
promoting
videos,
not
always
in
a
good
way.
But
in
this
case
hopefully,
yes,
we've
got
a
Twitter
account.
Twitter
still
works
very
well
in
IT
communities,
also,
especially
if
the
account
has
a
name
for
actually
being
useful.
So
you
can
post
a
question
to
the
account
and
it
will
either
retreat
it
or
maybe
answer
it.
The
person
on
the
other
side
is
actually
the
head
of
our
documentation.
A
Team
I,
don't
know
how
many
arms
they
have
when
they
reach
home
or
something
they
must
be
alien,
but
the
account
is
active
and
that
helps
a
lot.
It's
as
big
as
the
Swift
account.
We
tried
running
a
global
hackfest
without
getting
Meetup
organizers,
run
something
on
the
same
weekend
where
people
could
chat,
doesn't
really
work.
It
ends
up
with
a
lot
of
people
randomly
at
the
same
time
being
somewhere
in
an
office
hacking,
but
not
really
interacting.
A
A
If
you've
got
a
question
and
if
you,
if
you
want
to
know
how
people
are
using
your
project
or
what
you
want
to
go,
where
you
want
the
project
to
go
and
actively
ask
them,
and
the
pop
factor
is
only
half
of
the
story
because,
especially
on
the
back
tracker,
there
is
rarely
any
kind
of
people
that
do
like
the
bug.
Tracker
is
mainly
hobbyists
for
us.
It's
pretty
rarely
production
users,
so
asking
production
users
is
very
useful
again,
so
the
base
is
better
than
aha
and
then
a
lot
of
half
solutions.
A
A
In
that
case,
let's
come
to
the
growing
pains
because
it's
not
like
we
got
that
all
settled
and
we're
just
chugging
along
it's.
Just
2016
was
kind
of
the
year
where
we
could
watch
things
growing
and
like
at
the
beginning,
growing
isn't
much
of
a
problem.
Hey
cool
people
are
adopting
our
thing.
We
got
a
fool
like
one
gap
here,
one
gap
there,
someone
starts
running
a
conference,
but
that's
also
ok,
so
yeah
so
Lane
nearly
doubled
in
2017.
A
We
asked
for
stability
that
year,
only
90
percent
never
had
an
upgrade
problem
from
the
other
one.
We
know
about
8%
that
they
hit
type
system
bug
which
needed
to
be
fixed.
Absolutely
so
that's
painful,
but
in
general
the
whole
thing
with
the
upgrade
story
worked:
almost
everyone
uses
our
tuning,
so
it
must
be
ok,
at
least,
and
from
a
couple
of
people.
We
know
that
are
not
using
our
tooling.
A
A
Community
99%
of
people
have
no
issue
with
the
community
and
75%
of
these
theater
community.
Favorably
I'm
was
also
surprised
of
the
numbers,
but
that
was
what
the
answer
was.
Still
all
these
numbers
good,
we
don't
know,
there's
no
comparisons.
Maybe
anyone
who
had
an
issue
with
the
community
community
just
didn't
reply
to
the
survey
and
didn't
want
him,
invest
10
minutes
in
going
through
all
the
questions.
A
So
again
it
could
be
that
these
are
just
perfectly
normal
numbers
for
programming
language
that
people
are
invested
in.
Maybe
the
numbers
are
the
same
for
go
or
high
school
or
whatever
in
this
case
well,
cool
I
got
the
same
at
I
didn't
like
at
least
we're
not
broken,
but
I
I
have
no
I,
haven't
I'm
happy
about
those
numbers,
but
I
have
no
good
feeling
on.
Is
this
a
success,
or
is
this
just
like
the
normal
state
in
our
community?
A
I
don't
know,
but
the
other
thing
that
we
figured
out
is
we
don't
know
rust
as
a
project
producing,
and
this
is
not
the
first
time
I
encountered
producing
the
language
doesn't
mean.
You
won't
discover
yourself
things
for
yourself.
One
of
my
most
beloved
nails
from
one
of
the
from
the
really
very
list
is
one
where
the
inventor
of
the
language
himself
says:
oh
wait,
that's
possible,
I,
didn't
know,
and
last
year
we
had
quite
a
lot
of
these
things.
A
There
are
new
api's
practices
forming
themselves
new
ways
of
interacting
with
the
language
making
things
new.
There
are
more
economics
without
actually
changing
the
language,
which
is
also
a
good
argument
for
not
changing
programming
languages
too
quickly,
because
some
of
the
issues
might
resolve
themselves
because
someone
fine
actually
finds
out
how
to
make
this
to
use
this
feature
in
a
genome
again.
A
Why
and
also,
how
do
we
include
that
should
be
how
to
how
to
include
rust
into
other
projects
is
actually
becoming
the
main
question
we
get
a
lot
of
questions
of
I've
got
this
project.
I
would
like
to
use
rust,
but
I
obviously
can't
put
the
project.
So
how
can
I
include
it,
which
means
that
a
lot
of
touring
around
this
will
be
written,
binding
generators
and
all
these
things
so
we'll
get
new
patterns
coming
up,
and
especially,
it
turns
out
that
a
feature
that
I
just
described
in
the
beginning.
A
So
at
the
beginning
a
lot
of
people
were
like
here.
Ownership
is
interesting,
but
then
there's
this
borrowing
thing.
Two
years
later,
it
turns
out
Boehm,
isn't
that
interesting
and
I
just
gave
a
workshop
yesterday,
whereas
that
the
final
part
of
the
the
workshop
I
talked
for
half
now
and
how
you
shouldn't
overuse,
boring
because
complex
pointer
situations
aren't
that
interesting,
because
usually
you
would
actually
like
to
copy,
which
means
your
own
memory
and
you
talking
about
ownership.
But
ownership
is
it's
probably
starting
to
become
used
for
a
lot
of
things.
A
There
are
state
statically,
enforceable
state
machines
written
using
the
ownership
system.
It's
used
to
model
device
drivers
in
memory
to
make
sure
that
people
don't
get
like
secondary
handles
on
these
kind
of
things.
It's
extremely
useful
in
concurrency,
because
most
of
what
concurrency
most
concurrency
problems
kind
of
boil
down
to.
Oh,
we
didn't
properly
figure
out
who's
actually
responsible
for
this
memory,
location
and
ownership
says
you
must
always
figure
out
who
is
responsible
for
this
memory
situation,
this
memory
location.
A
A
A
A
It's
like
all
respect
to
those
people
that
actually
do
it,
but
on
the
scope
of
the
project,
the
people
that
are
involved
in
actually
driving
language
features
becomes
smaller
and
smaller
driving
library
features.
That's
a
different
thing.
People
thinking
about
the
API
is
but
actually
starting
still
working
on
language
features,
and
everything
is
still
now
that
we
got
all
the
bases
covered,
which
areas
should
we
focus
on?
Are
we
even
solving
useful
problems
like
there's
some
people
that
totally
want
to
use
the
rust
and
game
development
or
prior
to
them?
A
You
can
totally
use
it
in
game
development,
but
is
this?
This
is
an
area
we
should
focus
on
like
should
all
next
economics
pushers
be
making
the
thing
for
game
developers
easier?
Should
it
be
making
things
for
embedded
developers
easier,
making
server
development
easier,
making
that
what
programming
is
easier?
This
suddenly
became
a
problem
which
also
led
to
us
going
like
kind
of
in
all
directions,
trying
to
figure
things
out,
and
the
thing
is
hobbyist
problems
aren't
necessary
production
user
problem.
A
So
I
recently
spoke
to
someone
on
conference
and
he
was
like
yeah
I
got
like
an
embedded,
an
embedded
development
environment
set
up,
and
that
took
me
the
better
part
of
an
evening.
Okay,
so
how
long
we
have
one
and
a
half
hours?
Okay!
Is
it
working
Malik?
Do
you
have
any
issues
of
that?
No,
it's
like
it's
already.
Fine,
it's
very
great!
It
just
took
me
one
and
a
half
hours
to
set
up.
A
This
is
not
a
production
user
problem,
because
if
you're
in
a
company,
then
someone
tells
you
take
some
one
hour
and
a
half
hours
to
set
that
up
managers
like
good,
because
these
obviously
for
hobbyists,
where
you
only
have
like
two
evenings
suspended
or
even
less
each
week.
This
is
an
issue
still.
The
question:
is
this
an
issue
that
you
on
a
larger
scale
as
a
project
need
to
cover,
or
is
there
a
way
to
basically
work
for
both
sides?
A
Talking
about
things
that
worked
I
recently
cycle
worked
so
after
two
years.
That's
time
to
look
back,
we
only
watched
one
release
which
was
114.
What
we
accidentally
made
made
an
API
mistake.
Otherwise
we
had
no
larger
issues
and
also
turned
out
the
benefit
of
actually
being
consumable
like
having
consumable
changes,
leads
to
people
updating
that
compiler
regularly.
If
it's
like
every
six
weeks,
and
if
it
says,
if
there's
changes,
we
do
duplications,
we
do
no
breakage,
but,
for
example,
we
do
deprecations
in
the
sense
of
now.
This
is
an
API.
A
You
shouldn't
use
anymore,
there's
something
else.
People
follow
that
pretty
quickly.
If
that's
the
thing
of
ten
minutes
to
follow,
people
do
that
and
interesting
me.
We
are
practices
leader.
People
often
don't
see
that,
but
the
Community
Action
interaction
that
model
that
we
have
was
adopted
by
OGS.
Swift
and
ember
projects
now
have
an
RFC
process
and
they
copied
ours,
and
our
management
model
in
general
has
taken
interest
in.
So
this
is
having
management
as
part
of
the
open
source
project
very,
very
early,
even
before
release,
and
not
calling
it
in
any
way.
A
A
Still
because
we're
running
that
for
a
while,
we
are
actually
running
into
issues
that
other
projects
will
run
into
the
RC
process
is
highly
successful
and
a
lot
of
people
are
proposing
things
that
brings
issues
first
of
all
on
these
kinds
of
forms,
there's
always
people
with
too
much
time
that
swamped
the
process.
There
are
FCS
that
obviously
have
no
practicality,
but
they
are
like
written
in
a
staggering
amount
of
words
into
how
we
basically
should
throw
it
all
away
and
rust
should
be
a
completely
different
language.
A
This
is
this
is
rather
rare,
but
also
there's
there's
people
that
on
any
kind
of
RC
they
have
their
opinions
to
put
in
which
is
okay,
it's
just
a
volume
that
you
need
to
handle.
Obviously
people
are
allowed
to
have
their
opinions
and
we
want
them.
It's
just
sometimes
like
the
amount
of
volume
that
you
need
to
handle
gets
staggering,
but
there's
also
people
because
of
that
volume
that
have
note
with
no
time
to
follow,
and
then
they
feel
excluded.
A
So
if
you
like
I,
don't
know
which
part
of
C
I
should
put
my
opinions
on
to
actually
just
like
give
people
a
glance
on
what
I
would
like
the
language
should
be,
and
this
tends
to
be
a
much
bigger
problem
like
the
ones
above.
If
it's
really
bad,
you
can
just
ignore
them.
Where
do
you
just
have
someone
who
goes
through
that
and
is
like?
Oh
that's
interesting.
That's
interesting,
that's
interesting,
and
that
not
these
kind
of
things,
but
people
that
don't
interact
well.
A
It
costs
you
direct
with
them
and
they're
still
frustrated,
and
the
other
thing
is
when
you're
talking
about
an
international
project.
Non
English
speakers
have
an
issue
to
follow
these
kinds
of
discussions.
First
of
all,
native
English
speakers
write
much
faster.
They
write
much
clearer
and
when
you're
doing
these
interactions
regularly,
please
check
if
that
other
person
is
a
non-native
speaker,
because
that
might
be
that
their
arguments
have
holds
just
because
they
can't
express
them
better
and
it's
a
real
problem.
A
If
you
have
various
people
that
are
very
strong
in
discussion,
that
jump
on
all
of
these
and
have
the
habit
of
destroying
other
people's
arguments
for
the
sake
of
destroying
other
people's
arguments,
this
is
even
if
speaker,
that
people
are
speaking
English
fluently,
something
where
they
tend
to
struggle,
and
that
leads
to
a
lot
of
problems,
and
that
was
the
ones
that
we
run
into
the
that
year
and
they
are
not
fully
solved.
I
have
to
say-
and
you
finally
got
adopted
by
Mozilla
the
end
of
2017.
A
We
finally
got
into
Firefox
the
CSS
styling
engine
is
now
powered
by
rust,
using
a
lot
of
the
concurrency
features,
but
before
that
it
was
basically
they're,
like
small
tests
that,
like
having
one
of
the
UL
passes,
we've
written
in
rust,
like
some
small
things,
some
of
the
media
parsing
to
see,
if
basically
to
see
if
the
build
system
worked
and
if
the
integration
work.
But
this
was
the
first
time
we
were
actually
powering
a
piece
of
Firefox,
and
this
is
a
piece
that
was
ported
over
from
servo.
So,
finally,
like
a
fox
coming
up.
A
So
the
conclusion
here
have
a
sense
of
accomplishment
sometime,
so
that
was
really
great
for
the
project
and
it's
okay
to
well
bake,
cakes
and
everything
and
have
a
Firefox
release
party
and
so
on
so
forth.
But
the
other
thing
is
programming.
Languages
are
extremely
complex,
also
to
the
people
producing
them
and
that
either
may
lead
to
a
moment
where
you're
completely
blocked,
because
you
don't
know
if
you
can
actually
move
things.
A
A
If
you
change
have
a
bug
in
a
programming
language,
you're
breaking
the
world
and
also
have
some
ways
to
identify
issues
early
so
having
these
large
management
groups
actually
helps
people
that,
like
management,
are
actually
good
at
catching
these
kinds
of
issues,
because
some
people
might
talk
to
them
about
that
and
like
express
their
feelings,
and
all
of
these
are
valid
and
making
sure
to
find
ways
in
how
to
deal
with
them
is
important.
Any
questions
up
to
now.
A
Okay,
then
I
just
go
on
and
we
just
have
Q&A
afterwards
so
this
year
the
future
is
unwritten.
One
of
our
solutions
for
the
safety
problem.
Yes,
we
ran
a
blogging
campaign,
so
instead
of
having
people
search
for
a
venue
where
they
could,
their
feedback
could
put
their
feedback,
and
we
call
that
a
called
over
Christmas
for
people
to
use
January
to
write
a
blog
post
about
how
they
would
imagine
the
language
to
be
like
what
would
be
your
favorite
things,
so
that
was
kind
of
focusing
all
these
kind
of
small
feelings
towards.
A
This
is
the
place
where
you
can
put
them
and
we're
going
to
read
them
all.
We
kind
of
do
a
write-up
of
them
all
we're
going
to
decide
on
these
on
this
input,
so
they
were
encouraged
to
write
down
their
wishes.
So
that
could
be
oh
here's
a
feature
list
I
want
to
have
and
one
these
are
c
merged
or
just
something
I
would
like
to
have
a
push
in
that
direction,
and
that
would
also
allow
people
to
express
things
that
are
outside
of
the
scope
of
the
RFC
process.
A
For
example,
I
would
like
someone
to
start
a
tutorial
block
class,
a
blog
podcast
for
intermediate
users,
who
totally
turned
out
that
people
were
like.
Oh
beginner's,
documentation,
that's
quite
good,
but
what?
If
I'm
already
experienced
with
c++
and
know
my
way
around
systems
programming,
and
I
would
actually
like
to
skip
all
of
this.
This
is
the
structure.
This
is
a
memory
representation.
Give
me
what's
giving
you
what's
new,
so
these
kind
of
things
and
we
got
a
hundred
of
blog
posts
or
essays.
A
You
can
find
them
all
and
that
led
to
a
community
member
coming
up
and
say:
oh,
it
would
be
cool
if
someone
would
actually
do
a
build.
A
website
where
these
are
all
archived.
So
we
dressed
up
net
is
a
project
of
a
previously
unknown
community
member
and
we
ended
up
being
a
stack.
Overflow
is
most
loved
language.
Third
time
in
a
row
why?
I
have
a
rank,
fear
where
we
generate
and
manage
both
plus
and
Buzz.
A
A
great
thing
if
you
can
pack
it
with
actual
technology.
I
have
absolutely
no
problem
of
saying
I
do
marketing
as
long
as
I
feel
good
with
what
I
market
I
know.
Marketing
in
the
tech
community
is
sometimes
considered
a
bad
word.
It
actually
works
and
I
would
actually
like
other
projects
to
be
better
at
that.
If
someone
has
any
kinds
of
questions
or
know
someone
who
has
questions
about
that
community,
a
trust
language
org
is
also
open
for
other
open-source
projects.
A
This
is
where
we
go
to
conferences
and
talk
about
these
kind
of
things,
because
we
would
actually
not
like
to
participate
in
a
language
war.
I
think
the
resurgence
of
systems
programming
is
an
incredibly
interesting
thing
and
we
are
currently
at
a
place
where
or
at
a
phase
where
any
kind
of
growth
in
that
area
benefits
all
these
languages,
like
a
lot
of
the
C++
features
that
we
currently
have
or
that
are
currently
coming
up,
are
coming
up
because
this
with
trusts
D
name
whatever
it's.
A
It's
not
just
us
it's,
because
this
interesting
new
ideas
coming
in,
but
obviously
we're
not
here
to
kill
all
C++
code
bases
in
the
world.
It's
absolutely
not
the
goal,
we're
here
to
giving
another
option,
and
if
someone
in
the
C++
committees
feels
like
oh
cool.
This
is
something
interesting:
we're
going
to
put
that
onto
C++,
yeah
I
think
everyone
wins
and
people
follow
that
buzz
and
if
they
find
something
they're
happy
it's
the
thing.
We
have
more
teams.
A
Now
we
have
17
teams
with
over
100
people,
two
of
them
just
spontaneously
formed
two
weeks
ago
at
the
audience,
one
group
of
people
that
wants
to
do
formal
verification
and
another
group
that
just
wants
to
work
on
code
generation.
So
this
is
like
the
granularity
we
have
now
we
have
a
code
generation
working
group
and
the
community
teams
split.
For
example,
we
have
Russ
bridge
which
cares
about
outreach
and
workshops.
A
We
have
the
event
team,
because
we
have
so
many
events
that
it
makes
to
actually
have
a
central
group
managing
all
the
interaction
with
Mozilla.
For
example,
we
have
a
Content
team
that
does
these,
like
this
directly
comes
out
of
that
repress
project.
Why
not
have
a
team
that?
Actually,
it
cares
about
all
the
stuff
that
people
write
and
write
and
film
and
speak
into
the
microphone
and
the
switchboard
team,
because
that
task
has
become
so
big
is
now
its
own
team
we're
more
than
twenty
people
in
the
community
management
alone.
A
Pretty
often
they
are
also
part
of
other
teams,
but
they're
taking
that
on
teaching
us,
interestingly,
remains
a
problem.
The
problem
there
is
teaching
programming
remains
a
problem.
This
also
no
one
who
can
give
you
any
kind
of
conclusive
answer
on
what
what
works?
It's
all
good,
Felix,
some
people
say:
oh
programming,
mark
works
much
better
when
it's
visual.
Why
is
there
paper,
for
that?
Is
there
study?
Is
there
something?
No
I?
Do
that
all
the
time
great?
So
it's
all
like
an
Ag
data
every
as
they
say,
that's
a
huge
problem.
A
Any
kind
of
new
programming
language
that
is
a
little
more
complex
than
JavaScript
is
always
like.
Oh
don't
use
that
as
a
first
programming
language,
because
suddenly
you
have
to
handle
memory.
On
the
other
hand,
we
have
people
that
come
to
me,
I
can
learn
are
like
I
would
really
like
to
know
how
my
processor
and
how
my
memory
works,
but
I'll
teach
them
JavaScript.
A
A
So
if
someone
is
researching
these
kinds
of
issues,
we
can
maybe
even
get
to
contact
there,
so
the
goals
for
this
year
ended
up
more
tangible,
though
we
want
to
have
a
stable
story
for
bare
metal
embedded,
and
this
is
probably
going
to
be
by
August,
which
means
you
can
develop
using
the
stable
compiler
on
a
number
of
common
devices,
cortex-m
STM,
all
of
these
kinds
of
of
common
processes.
We
want
to
promote
our
rock-solid
networking
story,
that's
what
that's
we
get
out
of
our
production
users.
A
They
use
it
because
it's
rock-solid,
so
we
want
to
promote
that
more
and
the
other
thing
is
wasn't
the
taking
the
chance
that
we're
actually
sitting
next
to
the
people
that
standardized
wasn't
and
wasn't
generating
a
lot
of
interest,
especially
around
now.
We
finally
got
a
target
that
we
can
port
between
browser,
Android
iOS
and
our
back-end
at
using
as
a
target
in
the
browser
is
very,
very
useful.
Oh.
D
A
A
A
We
want
to
have
a
conference
on
every
continent
by
2019,
that's
a
stated
goal,
and
we
want
to
make
people
aware
that
the
language
is
actually
adopted
because
that
tended
to
be
the
biggest
problem
that
was
coming
up
around
winter,
something
that
actually
the
language
has
seen
far
more
adoption
and
far
more
use
and
far
more
productive
use.
Then
a
lot
of
people
are
aware
of
the
conclusion
for
the
beginning
of
this
year
is
actually
big
work.
A
Your
organization
regularly
having
a
lean
process,
also
means
you
can
regularly
rework
it
and
change
your
approaches
along
with
it.
Don't
like
it.
Don't
change
that
just
because
you
feel
like
it
would
be
better
if
you
had
these
kinds
of
teams.
The
reason
why
the
community
team
split
is
actually
because
people
said
I'm
not
coming
to
the
meetings,
because
most
of
the
subjects
are
not
interesting
for
me.
That's
why
the
split
is
there.
A
It
really
helps
if
you
don't
have
a
too
strong
hierarchical
group
in
an
open
source
project
hierarchy
doesn't
work
because
of
the
timezone
shift,
for
example
like
if
you
got
a
hierarchy
and
the
person
in
San
Francisco
is
calling
the
shots,
maybe
somewhere
in
Europe,
can
answer,
but
definitely
in
Australia.
Are
they
out
so
that
really
helps
okay?
A
Yeah
we
actually
called
for
them.
We
we
had
a
call.
We
had
a
call
for
blog
posts
on
our
project
blog
and
promoted
that
through
our
channels
of
telling
people,
please
please
send
us
an
email
and
we
had.
We
also
please
send
us
an
email
or
a
tweet
or
something,
and
our
teams
actually
went
and
everything
that
we
got
noted.
We
just
Google
that
we
just
had
a
Google
Talk,
where
everyone
who
called
a
link
somewhere
put
it
in.
A
That
is,
finally
a
decision
of
the
relevant
teams.
So
if
you,
if
it's
a
tooling
change
its
the
tool,
Qi
a
team-
if
it's
so
there's
a
couple
of
people
that
are
allowed
to
vote
on
this,
so
there's
a
voting,
but
like
the
group
that
can
vote
on
this
is
not
open
the
thing.
So
this
comes
out
out
of
a
lot
of
the
radio
processes.
That
Mosler
has
the
reason
why
we
have.
This
is
actually
to
make
sure
that
there's
some
vote
at
some
point.
A
So
the
way
it
works
is
someone
from
that
voting
group
calls
the
time
when
the
voting
happens,
and
then
you've
got
six
weeks
of
final
commenting,
and
then
this
group
votes
votes
on
it.
People
make
sure
that
there's
ample
discussion
before
and
for
example,
what
people
do
is
right
by
the
end
of
it
a
conclusion
of
what
they
felt
like
the
discussion
arrived
so
that
people
can
reply
and
say
well,
no
I
did
I
did
not
mean
that
I
could
I.
It
was
actually
meant
the
other
way
or
something
this.
A
A
They're,
pretty
Latin
often
denied
so,
for
example,
I'm
talking
about
this
language
ergonomics.
There
was
a
knife
see
to
rebuild
the
the
module
system
which
a
lot
of
people
felt
like
it
was
going
too
far
and
that
had
to
be
tried
four
times,
and
it's
a
much
thinner
and
much
better
RFC
now
so
the
first
three
ones.
Basically,
okay.
This
is
not
like
this
is
not
going
to
need
to
make
a
lot
of
people
happy,
or
this
is
now.
A
D
A
Reasons
are
that
it
contains
a
lot
of
things
it
similar
to
C++.
It
contains
a
lot
of
metadata
about
ABI
templates
and
all
these
kind
of
things.
The
language
is
generic
and
you
can
for
a
library
you
can
opt
in
to
using
the
C
ABI.
So
if
you
would
ride
the
library
with
the
Dinah
that
generates
a
dialogue,
you
would
get
like
a
normal,
dynamic
library
or
a
normal
static
library,
and
this
one
is
stable.
A
So
rust
has
an
unsafe
sub
language
and
for
interactions
with
with
things
that
cannot
hold
the
guarantees
of
rust,
having
a
library
that
exposes
an
interfaces
in
itself,
not
unsafe,
the
unsafety
lead
is
on
the
consumer.
If
you
want
to
call
into
C
libraries,
this
is
inherently
unsafe,
just
because
the
C
language
doesn't
give
any
kind
of
guarantees,
so
you
have
to
in
D.
So
the
compiler
knows
about
okay.
This
there's
something
beyond
here
that
I
cannot
expect
to
hold
the
guarantees
that
I.
B
A
No,
no,
you
would
have
an
you,
could
write
a
header
file
for
that.
That's
header
file
generators
and
then
you
would
document
like
just
as
you,
normal
sea
API
would
document.
This
is
a
pointer
at
this
point.
It
needs
to
be
unique
or
whatever,
or
this
this
will
be
dropped
this.
We
will
do
allocate
this
not
these
kind
of
things,
but
this
is
for
the
rest,
language,
not
a
concern.
A
Okay
then
yeah
finally,
lot
quality
projects
without
a
benevolent
dictator
are
there
and
work.
There
are
just
the
silent.
In
that
sense,
we
really
have
loud
emails
sent
around,
which
tends
to
be
which
tends
to
be
a
problem
like
there's
so
many
projects
there
now
Ruby
the
same
mots
is
nice,
so
we
are.
Nice
is
a
saying
in
the
Ruby,
so
it's
really
that
you
hear
about
any
kind
of
outbursts
of
maths
he's
still
running
a
global
programming,
language,
community,
so
yeah.
A
And
finally,
thanks
to
Xavier
ovm
project,
we
would
live
without
them,
the
Ruby
Python
in
Mozilla
and
JavaScript
communities,
because
we
apply
a
lot
of
their
work.
So
a
lot
of
this
is
basically
people
that
came
from
other
projects
and
they're
like
new
project.
For
me,
I
can
build
it
like
we
can
build
it
without,
like
rearranging
the
tables,
we
can
finally
just
paint
the
room
fresh,
how
we
like
it
and
then
put
our
furniture
in
so
thank
you.