►
Description
Pascal is the lead of CLI Working Group in Rust project. He's author and contributor of many Rust crates. Pascal also is co-organizer of Rust Cologne meetup.
This is a talk on how Rust doesn't invent a lot of new stuff. Rust itself isn't a new invention, really. It borrowed (pun intended!) a lot from Cyclone and ATS. And that set the tone for the community. Don't let "Not Invented Here" rule your decisions. Instead, take something academic, or something good but unergonomic, or something just not widely known, adapt it for mainstream - and it's golden!
A
Yeah
thank
y'all
for
coming.
I
hope
you
are
still
awake
somehow
I'm
super
tired,
so
I'm,
sorry,
if
I'm
not
moving
around
a
lot
today
so
today,
I
want
to
talk
to
you
about
what
I
consider
to
be
a
rust
approach
of
getting
things
right,
but
first
things.
First,
my
name
is
Pascal
hard
life
and
countly
involved
in
the
dev
tools
team
of
the
Ross
project.
A
So
if
you
have
ideas
or
issues
with
any
tooling
around
Russ,
please
talk
to
me
also
this
year,
I've
been
managing
the
still
I
work
in
group
which
currently
is
trying
to
make
commands
and
applications
really
really
easy
to
develop
and
rust.
If
you've
tried
to
write
a
commercial
application
and
rust
and
had
some
idea
so
issues
there
as
well,
please
come
talk
to
me
too,
on
the
internet.
You
can
find
me
on
these
URLs
and
with
that,
let's
get
right
into
it.
A
So
the
Torx
title
is
how
rust
managed
to
get
things
right,
which
is
pretty
presumptuous
and
well.
You
may
be
asking
yourself
what
was
I
thinking
like
how
can
this
random
dude
on
stage
deliver
a
talk
on
how
to
actually
write
at
the
perfect
program
and
well
I'm?
Sorry
to
disappoint?
That's
not
why
I'm
here
I'm
not
going
to
give
a
very
technical
talk
at
all,
and
it's
not
going
to
contain
any
code.
A
A
Russ
is
still
pretty
young,
even
though
we
just
had
like
this
big
release
of
rust,
2018
and
it
seems
like
we
have
figured
out
what
Russ
is
supposed
to
do
and
how
good
code
is
supposed
to
look
like
I
am
pretty
sure
that
we
still
have
a
lot
to
learn
and
a
lot
to
gain
from
continuing
to
learn,
discover
new
ideas
so
to
go
even
one
step.
Further
back
I
want
to
ask
what
is
rust
and
previously
on
the
rust
website.
A
It
says
it's
systems,
programming,
language
that
runs
blazingly
fast
to
run
sec,
volts
and
current
ease
thread
safety,
and
you
probably
have
read
that
at
some
point
in
your
life
and
felt
like
cool,
really
cool
like
this
is
a
bunch
of
cool
features.
But
what
does
it
actually
do
from
me?
The
current
version
of
the
rust
website
changes
the
slogan
to
be
a
bit
indifferent,
going
into
a
different
direction.
It's
right
now
says
beneath
the
rust
logo.
It's
empowering
everyone
to
build
reliable
and
efficient
software.
A
A
What
is
another
interesting
idea
to
describe
rust
and
I
went
back
to
the
past
and
looked
at
how
the
inventor
of
rust
first
described
what
the
programming
language
was
about,
and
he
said
rust
is
technology
from
the
past,
come
to
save
the
future
from
itself,
and
you
may
be
like
what
like
what
did
great
and
even
mean
by
that:
okay.
Okay,
fine,
surprisingly
enough,
he
goes
on
in
this
email,
announcing
this
new
programming
language
and
he
said
like
well.
A
So
it's
from
patent
law
basically
like
if
you
wanted
to
invent
some
new
technology
and
had
to
prove
to
the
Patent
Office
that
this
is
actually
original
art.
You
had
to
also
look
at
prior
art,
okay,
but
luckily
enough
we
are
dealing
with
software
and,
aside
from
some
weird
patent
cases,
around
software,
we
often
have
like
access
to
cool
research,
material,
open-source
implementations
and
the
bunch
of
different
ways
to
figure
out
how
someone
else
tried
to
solve
this
problem.
A
We
are
looking
at-
and
you
may
have
heard
of
this
quote
by
Picasso,
who
said
good
artists,
copy,
great
artists,
steal
and
luckily,
like
stealing,
and
software
is
very
different
from
stealing
in
the
real
world,
because
you're
not
taking
something
away,
you're
only
making
a
copy.
After
all,
which
is
good,
because
we
can
improve
everything
and
not
just
swap
one
thing
for
another.
So
we
don't
have
to
reinvent
everything.
A
Apparently
they
sat
down
in
some
empty
room
and
like
figure
it
out
all
on
themselves
and
for
some
domain-specific
problems
like
if
you
have
a
very
specific
business
case.
This
is
a
totally
fine
approach.
It
might
even
be
the
best
approach,
because,
after
all,
your
business
should
try
to
do
some
original
stuff.
But
there
are
a
lot
of
general
concepts.
We
can
actually
try
to
improve
and
four
general
concepts
it
tries.
It
is
a
good
idea
to
to
get
rid
of
this
approach
of
not
looking
sideways.
We
can
often
times
try
to
not
say
okay.
A
No,
that's
not
what
I'm
saying
either
and
it's
supposed
to
be
talks
where
I
am
convincing
you
to
be
curious
and
try
out
weird
science
and
I
hope:
I
managed
to
at
least
feature
interest
in
some
of
it:
okay,
okay,
okay,
let's
settle
down
and
be
actual
and
look
at
concrete
issues.
For
example,
you
know
that
the
borrowed
checker
likes
this
concept
of
having
ownership
and
borrows
inside
the
type
system.
A
This
is
one
of
rusts
main
selling
points,
because
the
problem
it
tries
to
solve
is
that
we
want
to
have
high-performance
code,
but
don't
want
to
have
memory.
Safety
issues
and
most
people
are
saying,
have
only
ever
been
this
concept
of
ownership
and
borrowing
by
rust,
but
it's
actually
not
rusts
own
invention.
In
fact,
there
was
also
prior
art
for
that
you
might
have
seen
in
the
description
of
the
storks
that
I
mentioned.
A
Cyclone
and
cyclone
is
actually
an
interesting
language
like
it's
supposed
to
be
a
safe
sea
which
has
some
interesting,
alternative
pointer
types,
for
example,
pointers
that
are
proven
never
to
be
now,
and
it
arises
by
doing
region
analysis.
It's
really
interesting.
It
was
developed
at
AT&T
Labs
in
2002,
but
looking
at
your
faces,
you've
not
heard
of
it.
Why
is
that?
Okay,
another
interesting,
interesting,
weird
language
is
80s.
A
This
is
one
of
those
languages
that
is
an
alien
spy
out
like
if
you've
ever
used
a
camel.
Did
you
know
how
it
might
behave
and
the
one
thing
that
sets
this
language
apart
is
that
it
had
a
built
in
Siri
improver.
Basically,
the
type
system
was
not
very,
very
powerful,
though,
actually
being
able
to
proof
your
programs,
so
it
went
all
in
and
said.
A
You
could
look
at
when
thinking
officers
where,
where
does
the
burrow
check
from
is
f-fine
logic,
and
the
idea
is
like
in
the
50s
or
60s
people
try
to
figure
out
logic
in
the
sense
of
what
can
we
do
with
it,
but
in
the
1770s
say
they
went
a
bit
further
and
this
concept
of
linear
logic
was
first
presented.
So
just
as
a
quick
recap,
regular
programs
don't
restrict
how
many
times
you
use
a
resource.
Linear
logic
says:
ok,
you
can
use
every
resource
exactly
once.
A
It's
a
bit
hard
to
make
a
programming
language
where
you
can
use
things
only
once
so.
A
weaker
version
of
that
is
FN
logic
which
says:
ok,
it
can't
be
used
more
than
once.
You
can
still
forget
stuff
and
there's
also
relevant
logic,
just
as
a
counterpoint
which
says:
ok,
it
must
be
used
at
least
once
tells
this
symmetry
and
people
have
been
trying
to
figure
out
like
how
to
make
a
programming
language
that
uses
these
concepts
from
logic
from
like
50,
40
or
50
years
ago,
and
it
is
hard
one
paper
from
2000
presented.
A
This
functional
programming,
language
called
lambda
la
and
its
main
property
was
that
there
was
a
subset
of
it.
That
is
typed
so
that
a
let
me
quote,
polymorphic
formulas
of
into
e
in
heuristic
light
affine
logic
are
available.
So
basically,
you
can
use
FN
logic
to
express
programs
in
this
language,
but
I'm
not
even
able
to
really
pronounce
what's
the
abstract
is
about.
So
maybe
it's
not
as
approachable
as
we
want
it
to
be.
That's
basically,
the
main
point
of
the
section
like
rust.
A
It's
not
just
about
approachability,
but
it's
also
about
adapting
these
concepts
to
the
context
we
are
in,
like
we
need
to
make
this
work
in
a
pragmatic
way
that
solves
our
problems
today
we
want
to
have
memory,
safety
and
high
performance,
and
we
want
to
have
it
right
now,
rather
than
in
25
years.
So
one
of
the
main
issues
with
first
releases
of
rust
was
that
people
said
okay.
A
So
this
find
this
an
interesting
time
system,
but
I
can
basically
come
up
with
a
program
in
five
minutes,
and
the
program
is
totally
valid
and
I
can
tell
you
how
well
it
is
actually
is,
and
the
compiler
still
rejects
it.
So
the
original
implementation
of
this
borrowed
checker
system
didn't
understand
all
the
valid
programs
and
it
actually
took
us
three
years
to
finally
land.
A
The
next
big
iteration
of
these
concepts-
and
this
is
basically
the
non
lexical
lifetimes
you
may
have
heard
about
and
which
are
now
and
enabled
by
default
in
the
2018
Edition,
but
still
this
is
adapted
for
the
current
context
and
adapted
for
the
usage
patterns
that
have
evolved
in
the
last
three
years.
But
it's
not
the
end.
By
far
like
I
still
can
show
your
programs,
where
you're
trying
to
borrow
parts
of
a
struct
and
the
comparison.
A
The
main
feature
that
sets
this
program,
apart
from
other
implementations,
that
it
uses
rack
excrete
instead
of,
for
example,
compatible
racks
expressions,
and
it's
been
the
same.
Also
so
will
it
make
sense,
but
I
had
a
look,
and
it's
really
interesting
like
what
needed
to
be
done
to
make
this
highlight
of
Ross
accomplishments.
So
the
prior
art
for
the
regex
great
itself,
is
the
Pike
VM,
which
is
basically
a
description
of
how
you
use
deterministic,
finite
or
ten
items
to
run
regular
expressions
very
computer
science
scene.
A
I
have
found,
which
is
just
called
Teddy
from
Intel's
hyper
scan
project,
and
it
uses
simply
instructions
to
speed
ups
as
sub
string
matching,
even
more
so
the
author
of
the
right
leg
straight,
you
may
have
known
you
may
know
the
github
handle
burn
sushi.
He
looked
at
all
these
implementations
and
all
these
different
approaches
and
tried
to
come
up
with
a
way
to
make
them
work
and
what
he
did
was
bring
it
all
together.
A
Okay,
so
far,
we've
seen
like
two
big
examples
like
this
command
line
application
and
service
compiler,
but
you
might
also
be
wondering,
like
okay,
fine
and
I'm
going
to
talk
about
how
to
write
rip
crap
again.
No,
actually,
what
I'm,
also
trying
to
tell,
except
that
it
just
adds
on
to
the
stuff
I
want
to
tell-
is
that
you
don't
have
to
think
big.
A
You
can
just
look
at
small,
interesting
pieces
of
code
and
wonder
can
I
make
this
better
and
actually,
if
you
look
at
the
implementation
of
sword
in
the
roster
standard
library,
the
reason
why
it
is
like
it
is
today
is
because
step
yarn
levena
has
said.
Okay,
this
is
a
code,
it's
actually
like
really
short,
like
200
lines
of
code
and
I'm,
pretty
sure
I
can
do
better,
like
he
looked
at
the
sort,
implementation
and
said
yes,
I
can
do
better
and
I
talked
to
him,
and
it
was
quite
interesting.
This
was
not
the
story.
A
I
wanted
to
talk
to
him
about,
but
when
he
mentioned
it,
I
was
really
curious.
He
because
he
said
he
was
doing
it
just
out
of
curiosity.
There's
no
other
reason
as
he
was
wondering.
How
can
how
does
it
work
and
maybe
I
can
do
better
and
it's
really
really
powerful
and
what
he
looked
at
was
the
current
implementation,
different
versions
of
nor
sort
and
other
languages
and
standard
libraries.
A
Another
very
interesting
approach
to
this
is
to
look
at
the
community
side,
because
this
story
have
just
told
is
not
just
my
story,
but
it's
actually
the
story
of
Falls
JP
on
first
made
a
public
trust
trust
like
he
showed
up
and
nature's
latest
improvement
to
the
sorting
function.
Just
like
that.
It's
not
much
code,
but
it's
still
like.
If
this
is
the
first
interaction
with
the
community,
it
could
go
all
all
the
different
ways
like
he
is
changing
the
standard.
Larry
people
might
get
upset.
They
might
be
trade-offs
that
no
one
knows
about.
A
They
might
just
be
no
one's
there
to
review
it.
Actually,
it
took
just
three
days
to
get
this
into
the
standard
library,
and
this
is
super
super
important,
because
if
we
as
a
community
are
transparent
and
open
to
change
and
looking
at
other
people's
work,
we
should
also
be
open
to
looking
at
when
other
people
propose
changes
to
our
work,
and
this
is
super
good,
because
nowadays,
debian
is
super
active
in
the
community
and
basically
the
next
thing.
A
A
Okay,
now
I've
planted
three
examples
and
you
might
still
be
wondering
find
what
does
it
actually
help
me
to
now
and
what
I'm
saying
is?
You
should
try
to
find
inspiration
for
your
problems
in
other
fields
in
other
ecosystems
and
see
that
there
are
a
lot
of
people
out
there
who
are
trying
to
solve
similar
problems,
and
maybe
you
can
find
inspirations
there.
A
So
other
ecosystems
I've
been
iterating
on
step
beyond
story,
it's
for
a
while
now
and
I'm
actually
going
to
tell
it
a
bit
longer,
because
one
of
the
most
interesting
Crites
I
have
seen
in
the
last
year
was
that
cross
beam
channel
has
been
really
really
burnt
up,
like
it's
an
improvement
on
the
channels
in
the
standard
library,
which
is
basically
a
multiple
producer.
But
single
consumer
channel
system,
which
has
for
a
long
time,
had
an
unstable,
select
macro
to
to
select
over
multiple
channels,
but
it
wasn't
really
powerful
and
the
idea
was
cross.
A
Beam
channel
was
to
basically
put
a
very
good
alternative
out
there.
Cross
beam
channel
is
available
outbound
in
a
bounded
and
unbounded
way.
It's
a
multi
producer
and
multiple
consumer
channel,
and
it
has
a
very
nice
Select
macro.
So
what
this
enabled
us
to
do
is
basically
have
a
library
implementation
of
what
other
languages
have
in
their
core
language
system
and
that's
not
by
accident,
because
this
was
developed
by
taking
inspiration
directly
from
what
the
go
developers
have
been
doing
for
the
last
eight
years
or
so
at
that
point.
A
Basically,
there
was
a
very
interesting
design
document
from
2014,
which
iterates
all
the
points
that
the
go
developers
looked
at
to
come
up
with
the
design
they
chose
and
the
developers
of
crossbeam
Channel
among
others,
Geoff
Young
looked
at
this
and
could
tell
ok.
This
is
a
trade
off.
We
also
want
to
do
and
also
decide
like.
A
This
document
was
super
helpful
and
basically,
what
we
have
right
now
is
a
fully
featured
implementation
of
a
channel
system
in
a
library
just
sitting
somewhere
and
people
can
use
it
like
the
language
doesn't
really
block
you
in
a
way
that
you
say:
okay,
I
want
to
have
this,
but
now
I
need
to
get
knowledge
of
how
the
compiler
works.
To
make
it
happen.
A
You
can
try
and
implement
a
lot
of
stuff
just
integrate
somewhere,
and
this
is
so
powerful
that
let
us
talk
about
adding
this
to
the
standard
library
itself,
because
this
is
like
happening
years
after
the
standard
library,
implementation
and
a
lot
of
stuff
has
been
learned
in
that
time.
Similarly,
there
are
two
more
crates:
I
want
to
talk
about
the
first
one
is
parking
lot
and
the
other
one
is
hash
brown.
A
So
parking
lot
is
a
set
of
synchronization
primitives
as
like
music,
mutexes
and
readwrite
locks,
but
it's
implemented
in
user
space
and
it's
also
not
a
new
invention.
It's
taken
basically
directly
from
the
library
that
WebKit
uses
internally,
which
has
a
funny
name
WTF,
because
it's
a
WebKit
framework
or
what
technology
from
like
I.
Don't
know
WTF,
that's
how
I
remember
it
and
the
other
one
is
hash
brown.
A
So
there
was
his
talk
a
year
ago
with
C++
conf
from
someone
from
Google
who
presented
an
alternative
hash
table
implementation,
and
it
turns
out
this
thing
called
Swiss
table
is
super
super
efficient.
It
uses
way
less
lookups
and
way
less
instructions
for
a
key
lookup
than
any
other
implementation.
I
have
seen
at
least,
and
it
works
by
using
the
instructions
and
clever
packaging
in
memory
and
hashbrown
is
a
rust
implementation
of
exactly
this
hash
table,
and
there
are
two
PRS
open
right
now.
A
A
So
a
super-powerful
way
to
improve
our
language
and
echo
system
is
to
be
able
to
come
up
with
ways
that
we
can
just
switch
out
and
improve
continuously
over
time.
So
these
were
all
examples
taken
from
other
ecosystems,
other
languages
and
other
companies,
basically
those
one
other
source
of
inspiration.
That's
a
bit
more
difficult
to
get
into
your,
and
that
is
academia,
just
a
quick
show
of
hands.
How
many
of
you
studied
something
related
to
computer
science?
A
Okay,
that's
that's
quite
a
lot
like
60%
and
how
many
of
you
like
reading
academic
papers,
let's
still
the
good
number,
not
not
as
many
that's
still
a
still
a
good
number
and
it's
it's
you've
probably
figured
out
somehow
how
to
get
into
paper
and
how
to
read
papers
and
how
to
actually
figure
out
where
to
get
papers.
But
most
people
have
not-
which
is
quite
sad,
so
this
whole
resource
is
not
the
way
for
them
or
for
some
of
you
actually
I,
don't
know.
A
I
talked
to
someone
who
had
a
very
interesting
point
to
make.
Tyler
Neely
told
me
that
so
many
awesome
engineering
projects
are
basically
just
out
there.
That
can
be
pulled
off
by
just
taking
a
quick
look
at
where
the
current
research
is
at
in
a
particular
field,
because
often
the
implementations
are
lagging
behind
by
several
decades.
A
So
if
you
enjoy
reading
papers,
one
idea
would
be
to
just
read
more
of
those
and
try
to
implement
the
best
ideas
and
just
because
I
didn't
know
how
many
of
you
had
any
academic
background
and
I
still
really
don't.
I
wanted
to
also
point
out
where
to
find
some
interesting
papers,
because
for
me
it
was
really
really
hard
to
get
into
this
mindset.
A
Of
actually
doing
is
that
in
my
free
time
and
finding
stuff
that
was
worse,
like
spending
half
a
day,
just
trying
to
comprehend
something
so
two
interesting
resources
I
have
papers,
we
laugh,
which
is
papers,
we
love
dark
and
the
other
one
is
an
interesting
block
of
the
morning
paper.
It's
both
about
presenting
papers
that
are
somewhat
approachable,
but
still
weird
enough
that
they
are
not
like
published
in
regular
newspapers
or
on
Hacker
News,
and
just
like
my
approach
to
reading
papers
is
quite
simplistic,
actually
I
try
to
read
like
the
abstract
figure
out.
A
How,
so
can
you
act
like
a
machine
that
just
consumes
research
papers
and
splits
out
awesome
Russ
projects
yeah?
Probably
not.
This
is
not
how
people
are
actually
research
work,
but
you
can
try
to
look
at
more
sources
of
inspiration
and
try
to
look
at
it
from
a
perspective
of
how
can
I
make
this
more
practical
like
how
can
actually
apply
this
to
my
life?
A
Is
what
we're
doing
right
now,
actually
the
best
approach
or
is
someone
out
there
who
had
like
this
brilliant
idea
and
nobody
really
made
it
happen
because
I'm
pretty
sure
the
terrorists,
a
lot
of
research
that
still
just
needs
to
be
rediscovered,
and
this
is
a
quote
from
step
beyond,
as
you
can
see,
and
he
asked
another
question:
can
we
can
we
bend
the
curve
somewhere
like?
Can
we
look
at
all
the
trade-offs
that
exists
right
now,
and
can
we
try
to
tweak
them
like
just
a
little
bit?
A
This
is
is
enough,
and
this
resonates
with
me
as
someone
who
has
been
in
the
rust
community
for
four
years,
because
rust
is
all
about
like
overcoming
these
traditional
trade.
Offs,
like
you
know,
is
this
like
crazy
points
of
memory
safety
without
garbage
collection,
it's
it's
happening
and
stuff
like
abstractions
are
over
here.
This
is
the
selling
points.
Let
me
try
to
use
to
convince
people
to
use
rust,
and
this
bending
the
curve
doesn't
just
have
to
be
like
language
features.
It
can
also
be
the
implementation
of
weird
but
very
useful.
A
It
didn't
really
help
me
in
my
life
so
far,
but
it
was
interesting
and
if
I
had
been
in
this
position
ten
years
earlier,
I
might
have
been
the
guy
who
actually
sat
down
and
said
why
the
second
a
rusty
needs.
Her
hashing,
like
like
a
hashmap
implementation,
I've
seen
this
paper
I
could
sit
down
and
actually
try
to
make
this
usable
and
basically
the
current
hashmap
implementation
of
rust
is
using
Robin
Hood
hashing.
A
A
Okay,
just
one
more
story
this
about
Greene's
rights,
because
not
every
story
needs
to
have
him
happy.
Have
their
happy
end
right
in
in
2014
rust.
Had
greens
rats
like
something
like
go
routines
or
something
like
no
joyous
event
loop.
It
was
actually
using
lip
UV,
which
is
what
nose
note
used
at
the
time
too,
and
this
allowed
rust
to
have
a
single
in
2014.
It
was
actually
quite
good,
at
least
it
was
usable
and
late.
They
removed
it
like
they.
A
The
rest
team
tried
to
figure
out
how
to
make
more
stuff
work,
how
to
have
less
trade-offs,
because
you
can
implement
a
single
without
greens
rats,
and
if
you
do
so,
you
have
no
runtime
that
you
can
support
embedded
systems,
which
is
a
huge
thing
and
I'm
pretty
sure.
It's
actually
like
going
to
be
very
ok.
A
So
it's
ok
to
iterate
on
ideas.
Actually,
the
first
version
of
anything
doesn't
have
to
be
perfect.
If
you
have
the
ability
to
say
ok,
we
are
going
to
change
it
or
upgrade
it
later
on.
It's
ok!
If
the
first
version
is
complicated,
if
you
actually
recognize
that
it's
too
complicated,
it's
ok,
if
it's
weird
or
not
a
good
fit.
A
A
A
The
first
one
is
other
ecosystems
of
similar
fields
like
if
you
have
an
issue
you
want
to
solve
right
now
and
you
see
there's
a
Java
implementation.
Please
don't
say
it's
in
Java
I'm,
not
gonna.
Look
at
it.
Please
say:
okay
interesting.
They
had
probably
like
some
time
to
come
up
with
with
a
solution
and
apparently
it
works.
I'm
gonna
try
to
understand,
what's
I
meant
by
it,
and
the
second
point
was
academia
and
trying
to
see
that
there
was
a
lot
of
research
out
there.