►
From YouTube: Rust Release Party
Description
The release party for Rust 1.0.
Help us caption & translate this video!
http://amara.org/v/2Fhi/
A
A
D
E
A
C
Who
are
loyal
to
C++,
they
C
C++
is
strengths
and
they
see
no
other
language.
That
really
has
those
strengths,
but
they
also
see
a
lot
of
the
downsides
of
C++
and
I.
Think
rust
is
one
of
the
first
really
serious
languages
that
keeps
those
strengths,
but
this
is
a
lot
of
downsides.
It
brings
something.
H
E
H
C
E
E
C
G
H
D
D
E
I
A
J
Hello,
everybody
welcome
again
to
the
one
point
o
event:
I
think
we've
all
been
working
pretty
hard
on
this
release,
especially
those
of
us
kind
of
it,
the
more
than
the
core
team,
and
definitely
all
the
people
here.
Who've
been
contributing
and
everything
else
and
we
were
hoping
to
start
off
this
event
with
something
a
little
lighter
weight,
I'm
going
to
kind
of
bring
us
back.
J
J
Yeah
fancy
new
design
just
for
this
event,
so
the
first
question:
oh,
that's,
the
wrong
way.
First
question:
this
way:
what
language
was
the
first
rust
compiler
written
in?
Was
it
a
haskell
bo
camel
or
see
turbo
pascal
and
I'm
gonna
call
on
you?
Yes
bo
kim?
Oh
that's
right!
So
you
can
you
give
your
name
to
Brian
here.
J
J
J
All
right,
which
RFC
receive
the
most
comments
of
all
time,
was
it
the
highly
controversial
topic
of
restricting
/?
U
xx
to
the
ASCII
subset,
hopefully
delineate
it
here
or
I,
oh
and
operating
system
reform
or
renaming
in
turn,
you
into
anything
else,
yeah
I,
think
you
raised
your
hand
first.
No,
it
was
not
see
good
guess,
though,
all
right
reem,
yes,
it
was
be
with
400.
E
J
J
J
I
was
hoping
that
would
take
longer
so
yeah
efference
crust
was
the
way
you
defined
a
function
that
was
callable
from
see
a
rust
function,
call
bull
from
see
it
was
a
seat
or
rust
function,
either
our
most
inspired
or
least
inspired
choice,
sure
which
so
the
next
the
hardest
of
all
which
of
the
following
is
an
actual
rust
acronym.
You
may
know
we
have
a
predilection
for
acronyms.
Is
it
pojo
spin,
a
or
m
hat
wama
0.
K
J
I
J
I
I
J
L
J
J
J
So
brief
introductions,
this
is
aaron
turin,
Patrick,
Walton,
Alex,
Crichton,
Brian,
Anderson
and
yehuda
katz,
and
we've
also
got
before
we
go
on.
We
just
want
to
point
out:
we've
officially
launched
the
new
governance
model
with
the
sub
teams,
so
in
fact
the
core
team
is
only
a
part
of
the
West
leadership.
There
are
also
all
these
other
fine
people
here
on
the
language,
design,
teams
and
the
library,
team,
compiler,
tooling,
and
infrastructure
and
moderation.
So
a
big
thank
you
to
all
these
people
who
are
making
rest
function.
A
J
J
D
All
right,
hi
everyone,
so
I'm
going
to
talk
just
a
little
bit
about
servo.
For
those
who
don't
know
servo
is
our
browser
project
browser
engine
project
written
in
rust?
It's
been
moving
right
along
and
we've
been
making
a
lot
of
progress.
Lately
here
is:
oh
great.
This
is
actually
rendered
in
servo
exciting.
So
this
is
the
this
weekend.
Servo
blog,
I
highly
recommend
following
it.
D
If
you're
interested
in
what
we're
working
on
the
we
getting
a
lot
of
contributions,
in
fact,
more
contributions
yesterday
that
fit
on
a
github
page,
which
was
great,
I
just
counted
the
number
of
lines
in
servo,
counting
all
of
the
sub
modules,
but
not
counting
any
generated
code.
It
was
of
rust
code,
461
thousand
lines
of
rust
code,
so
that's
quite
a
bit
and
that's
not
all
just
serve.
Oh
there's
hyper
openssl
bindings,
all
of
that
stuff
that
we
couldn't
have
done
without
you
so
there's
lots
ago,
but
here
are
some
additions.
D
D
We
actually
did
land
a
fixed
for
space
jam.
That
was
the
background
tag
of
HTML
and
we
also
landed
some
other
things
that
are
used
by
sites
that
are
really
old
and
haven't
adopted
CSS.
Yet,
like
hacker
news,
hacker
news
actually
depends
on
quirks
mode
in
some
ways
that
I
can
talk
about
over
more
drinks
than
I've
had,
and
so
this
is
what
hacker
news
looks
like
now,
and
we've
also
done
work
to
make
reddit
look
really
nice.
D
I
D
M
M
So
let's
take
a
look
at
a
simple
server.
You
have
a
simple
cargo
tamil
example.
Excuse
me
this
is
going
to
be
technical
on
code.
I
hope
everyone
here
is
cool
with
that
and
we
had
hyper
as
a
dependency.
You
got
your
main
file
doing
some
simple
stuff
in
pulling
in
Hyper's
request
response
so
forth.
That's
interesting
part
that
we're
going
to
look
at
there
is
the
handler
in
this
case
it's
a
function
that
handles
requests
and
responses
and
we're
going
to
do
a
simple
routing
right.
M
So
first
we're
going
to
say:
if
we
don't
know
this
route,
it's
not
found,
let's
add
a
an
index
room
right
/,
so
we
had
get.
If
all
that
junk
/,
then
we
can
ahead,
go
ahead
and
send
will
arrest
and
if
we
add
another,
get
/
x,
we
stand
by
its
kind
of
straightforward.
This
is
what
our
program
starts.
To
look
like,
and
eventually
you
start
saying:
hey
I
want
to
add:
10
20
30
routes
starts
to
suck.
M
You
want
a
router,
that's
why
we
use
routers,
of
course,
and
so
we
could
use
a
framework
right.
You
could
use
iron
or
nickel
or
another
one
that
I
forgetting,
but
the
question
might
be
well.
How
did
they
do
this
in
the
first
place?
And
maybe
you
don't
want
everything
that
a
framer
gives
you
you
just
want
to
add
some
routes,
so
we're
going
to
show
how
you
might
do
that
I'm
going
to
have
a
new
crate,
hyper
router.
M
Of
course
it
depends
on
hyper
as
well
I'm
pulling
hyper
and
we're
going
to
be
have
using
a
hashmap
right
of
method,
strings
and
callbacks,
which
is
just
a
closure
in
this
case,
create
a
new
one,
new
hashmap
right.
So
here's
where
it
gets
interesting
and
I
had
to
be
funny
with
the
line
wrapping.
So
it
looks
kind
of
crazy.
M
M
So
the
first
part
here
is
we're
going
to
be
matching
first
on
you
our
eyes
and
here's
some
info
that
you'd
really
only
interested
if
you're,
making
a
proxies
or
more
complicated
handling
options
and
so
forth.
You're,
probably
only
interested
in
the
path
part,
so
we're
only
going
to
care
oops
if
the
URI
is
a
path.
M
So
we
have
our
router.
We
get
to
pull
it
in
as
a
dependency
and
that
handler
function
that
we
had
we're
going
to
change
it
slightly
right.
So,
instead
of
passing
a
function,
we're
going
to
actually
create
a
handler
and
pass
that
into
the
function
under
the
HP
server,
and
so
here
was
the
original
handler
that
we
had
and
we'll
go
ahead
and
change
it.
We
pull
in
the
router
and
we're
changing
handler
to
instead
return
the
router
and
it
has
no
routes
at
the
moment.
M
M
What's
wrong,
you
don't
like
post
all
right,
easy
router
to
put
delete
whatever
you
want,
and
so
this
was
our
original
function
where
our
original
library,
this
is
what
it
changed
to,
and
I
went
ahead
and
highlighted
the
slightly
more
interesting
bits
to
to
see
how
the
router
might
look
in
a
full
crate
and
that's
it
I
think.
That's
all
the
time
I
have
because
I'm
talking
too
much.
K
H
N
Right
so
I'm
gonna
talk
about
dependent
types.
This
is
a
sort
of
has
a
fearsome
reputation
as
like
what
you
use
when
hospitals
type
system.
Is
it
hardcore
enough,
but
I'm
going
to
try
to
argue
that
it's
actually
both
simple
conceptually
and
would
be
a
really
nice
thing
to
have
and
run
some
day.
So
this
is
a
far
future
thing,
but
well,
let's
see
what
we
can
do
so
what
does
it
actually
mean
to
have
dependent
types?
N
It
means
that
types
are
first
class
values,
and
it
means
that
when
you
have
a
function
argument,
the
type
of
an
argument
can
depend
on
the
values
that
came
before
it.
So
this
function
foo
it
takes
a
type
T,
it
takes
a
length
n
and
then
it
takes
a
vector
in
the
type
of
that
vector
includes
the
type
and
the
length,
the
type
of
the
element
and
the
length
of
the
vector.
So
this
is
this
is
pretty
different
from
rust
as
it
exists
today
so
reasons
we
might
want
this.
N
It
simplifies
the
language
a
lot,
because
we
no
longer
have
this
distinction
between
type
parameters,
value
parameters.
It's
it's
all
one
level
and,
as
we'll
see
later
in
this
talk,
not
only
is
it
simpler,
but
you
can
use
this
to
prove
correctness
of
your
programs.
Almost
any
property
you
want,
and
that
means
you
can
even
get
rid
of
runtime
checks
and,
as
a
nice
bonus,
rust
syntax
for
calling
with
both
type
and
value
arguments
is
really
ugly.
So
we
get
rid
of
that
because
types
are
values
and
that's
just
wonderful.
N
So
one
way
to
do
this,
that's
pretty
popular
in
industry
compared
to
the
others,
is
refinement
types,
and
this
is
basically
where
we
can
attach
a
boolean
condition
to
a
type
saying
so
here
this
I,
we
say
I
is
a
you
sides,
but
only
subject
to
the
constraint
that
I
is
less
than
the
length
of
this
slice.
So
this
is
a
little
syntactic
sugar
I've
imagined
where
you
could
say
that
essentially
this
this,
where
clause
attaches
to
the
type
of
the
variable
I
and
the
where
syntax
is
already
part
of
rust.
N
So
that
fits
really
nicely-
and
this
is
just
like
really
easy-
to
read-
I-
think
to
take
a
more
complicated
example.
Here's
a
function
that
defines
the
type
of
all
numbers
between
low
and
high.
So
it's
a
function
that
takes
two
integers
returns
type
and
we're
going
to
I
introduce
a
new
key
word
here
called
those
which
is
the
introducer.
So
in
traditional
maths
in
taxes
to
be
like,
you
know,
x1,
I,
sighs
where
with
a
bar
and
then
the
condition
but
I
think
feeds
a
little
nicer.
N
And
then
we
can
say
that
a
binary
tree
has
a
left
subtree
in
the
right
subtree
and
each
of
them
is
in
the
appropriate
range.
So
once
we
have
this
tree
type
in
the
language,
once
we've
written
this
tree
type,
then
we
know
that
every
tree
like
this
is
going
to
be
in
search
order
and
the
the
compiler
will
yell
at
us.
If
we
ever
break
that
in
bearing
it.
So
that's
pretty
fancy
and
I
it's
not
quite
for
free.
N
This
is
an
undecidable
type
system
in
the
general
case
and
so
most
systems
that
go
full
on.
With
this
end,
up
asking
and
off-the-shelf
theorem
prover
like
xiii,
there's
been
a
lot
of
progress
in
these
systems
in
the
past
15
ish
years,
and
so
they
can
often
tell
you.
Yes,
that
implication
is
true.
No,
that
is
impossible,
but
sometimes
they
don't
know,
and
so
one
solution,
then
is
you
could
check
at
runtime?
N
You
can
imagine
and
rust
we
might
even
say
check
at
runtime
in
debug
builds,
don't
check
out
all
release
builds,
so
that
gives
you
a
language
where
basically
debug
builds,
have
a
refinement
type
system.
Release
builds,
have
an
ordinary
type
system.
That
is
erasure
of
those
refinement,
types
and
that'd
be
really
cool
and
there's
some
one
example
of
this.
N
My
TLS
is
a
ssl/tls
stack,
written
in
f-sharp
with
refinement
types
and
they've
formalized
all
other
security
properties,
and
they
even
found
a
bug
in
the
ssl
protocol
in
doing
so,
which
is
the
triple
handshake
renegotiation
bug.
So
this
is
comparatively
a
pretty
well
tested
approach,
that's
being
used
for
real
stuff,
the
other
thing,
and
maybe
what
more
people
think
of
when
they
say
dependent
types
is
the
classical
type
theory
approach
where
we
basically
programs
are
proofs,
which
is
this
curry,
howard
correspondence.
That
is
just
amazing.
N
N
N
You
can
write
this
today
in
rust
if
you
just
remove
everything
after
the
colon
on
each
line,
but
adopting
that
form
lets
us
do
some
more
powerful
things,
so
this
vector
type
now,
rather
than
defining
a
vector
in
terms
of
like
a
property
on
the
index,
we
define
it
inductively,
so
a
vector
is
either
empty.
In
which
case
is
length,
is
0
or
it
is
an
element
tacked
onto
another
vector
in
which
case
is
length,
is
the
successor
of
the
length
of
that
vector.
N
So
just
by
saying
this,
he
knew
has
this
type,
this
enum
Chris
director
is
this
type.
We
build
the
knowledge
of
the
length
of
the
vector
into
the
type
itself,
what's
a
little
more
remarkable
about.
That
is
that
this
can
actually
encompass
the
whole
refinements
arbitrary
boolean,
predicates
stew,
so
we
can
start
with
an
enum.
We
could
say
that
the
the
type
of
proofs
that
a
is
equal
to
B
has
only
one
inhabitant,
which
is
the
proof
that
a
is
equal
to
a,
and
this
is
pretty
mind-bending.
It's
like
how
is
this
even
useful?
N
This
enum
only
has
one
value
named:
reffel,
there's
no
fields,
even
so
at
the
value
level.
It's
trivial
at
the
type
level
is
extremely
interesting,
because
merely
pattern
matching
on
this
word
rifle
is
going
to
cause
the
type
system
to
perform
unification
between
a
and
B
and
I
really
don't
have
time
to
go
into
it.
But
essentially
this
is
really
cool
and
you
can
then
just
write
out
a
refinement
of
t
on
some
predicate
p
is
a
value
t
together
with
a
proof
that
the
predicate
returns.
N
True,
that's
all
that's
saying,
and
it's
kind
of
amazing,
that
you
can
just
write
that
and
use
it
in
real
programming
languages.
So
probably
the
most
popular
language
for
this
now
is,
and
it
is
based
heavily
on
these
proof
tactics
so
fundamentally,
you're.
Writing
your
programs.
You're.
Writing
your
proofs.
Ask
programs
they're
like
big,
complicated
pattern,
matches
and
stuff,
and
so
people
generally
need
help
with
that.
N
So
whether
it's
editors
are
proof
tactics,
that's
usually
part
of
a
system
and
what
people
often
do
is
they'll,
write
software
in
and
then
translate
it
to
haskell
or
o
camel
or
scheme.
We
actually
have
someone
working
on
translation
for
rust.
It's
certainly
a
better
target
than
any
other
systems.
Language
out
there,
so
yeah
dependent
eyes
for
rust.
I
mean
it
would
be
great.
N
It
sounds
like
a
fantasy
right
now,
but
I
you
know,
given
what
we've
accomplished
in
the
past,
you
know
decade,
ish
like
what
will
rust
look
like
in
another
decade
and
what
will
the
language
that
spawns?
Look
like
so
yeah
I
have
some
links.
I
don't
have
time
to
like
go
through
them,
but
you
can
look
this
up
on
my
website,
which
is
k,
McAllister
github
do
and
you
can
click
through
to
some
of
these
papers
and
stuff.
N
So
this
is
a
great
textbook
that
goes
through
a
lot
of
programming,
language
foundations
and
all
the
exercises
are
formalized
in
so
every
exercise
in
the
textbook
is
basically
like
an
interactive
puzzle
game
with
the
computer,
we're
like
you're
casting
spells
in
trying
to
like
use
the
next
tactic,
and
it's
like
telling
you
what
you
have
left
to
do.
So
it's
really
a
really
engaging
self-study
experience.
That
book
is
awesome.
These
are
all
good
too.
Here
are
some
more
specific.
N
A
L
Hi
everyone
yeah
thanks
for
having
me
I'm,
Paige,
Peterson
I,
do
communications
and
I
kind
of
work
on
made
safes
website
redoing
it
right
now,
but
I.
The
company
itself
is
based
in
Scotland
so
and
I'm.
The
only
one
in
the
u.s.,
so
I'm
kind
of
doing
communications
for
reaching
out
to
various
communities
and
whatnot.
So
I
wanted
to
kind
of
give
a
really
brief
intro
of
what
the
technology
that
we're
building
so
we're
trying
to
essentially
build
a
platform
for
decentralizing,
storage
and
communications.
L
It
can
be
seen
as
sort
of
an
alternative
internet
internet
of
sorts
that
removes
dependence
on
servers.
So,
instead
of
saving
data
and
using
servers
for
communication
routing,
you
are
instead
using
individuals,
nodes
posted
by
users
of
the
network
themselves.
So
it's
it's
kind
of
this
large
project
that
has
been
in
the
works
for
over
almost
a
decade,
now
doing
a
lot
of
research
and
development
at
the
early
stages
and
kind
of
coming
into
feeling
more
comfortable
with
building
the
different
libraries
and
whatnot,
and
so
we've
been
doing
a
lot
of
outreach
to
different
communities.
L
But
this
is
a
really
exciting
community
for
us
to
reach
out
to.
We
did
originally
right.
The
the
core
libraries
in
C++
and
earlier
this
year
decided
to
make
the
full
switch
over
to
rest.
We
completely
deleted
our
C++
libraries.
You
can't
find
them
anymore.
As
far
as
I
know,
there
is
a
lot
of
other
things
we
did
when
we
switched
over,
so
they
wouldn't
really
have
been
compatible
anyway,
but
yeah.
L
So
I'm
not
going
to
go
into
the
technology,
stuff
I
think
we're
gonna
plan
to
do
a
longer
talk
at
a
future
rest
meet
up,
so
I
can
talk
a
little
bit
more
about
the
technology,
but
just
to
show
kind
of
the
stack
so
we're
building
literally
everything
on
top
of
IP.
We
have
our
own
crust.
That
is,
it's
called.
It
stands
for
connections
and
rust.
L
So
it's
going
to
be
this
layer
for
just
kind
of
going
out
and
all
of
these
different
layers
are
actually
are
going
to
be
their
own
libraries
or
are
their
own
library.
So
you
can
right
now
go
into
just
search
made
safe
and
you
can
see
the
different
things
that
we've
built
you
can
you
can
even
download
some
of
these
and
start
work
with
them
like
the
self
encryption
tool?
It'll.
L
Essentially
it's
part
of
the
network,
but
it
will
essentially
take
any
file
that
you
want
to
encrypt
it
chops
it
up
into
chunks
and
encrypts
those
chunks
and
creates
a
data
map
that
data
map
will
be
secured
on
the
network.
But
that's
just
one
component
and
you
can
begin
to
start
playing
with
all
of
these
things.
We
aren't
completely
kind
of
migrated
over
we're,
still
figuring
out
a
bunch
of
things,
we're
still
honestly
building
out
the
network
as
well.
L
This
was
in
context
like
just
one
of
the
developers
was
having
a
little
problems
with
doing
a
lot
doing
some
of
the
testing
with
rust
and
and
he
and
he
was
wanting
to
like
see
if
there
was
a
way
to
modify
the
testing
he
was
like
they
will
run
in
parallel.
So
we
need
to
work
with
that.
We
cannot
short-circuit
alter
the
system
of
test
build,
so
we
need
to
just
work
harder
to
test.
Otherwise
we
go
back
to
the
land
of
spaghetti
and
complexity
where
nobody
knows
what's
happening
and
we're
not
going
back
there.
L
So
this
is
I
think
just
I.
Think,
generally,
Resta's
are
a
really
exciting
thing
for
a
platform
like
made
safe
because
we're
working
with
a
lot
of
different
components
and
additionally,
in
addition
to
you,
know
our
our
interest
in
building
a
decentralized
internet,
it
kind
of
maps
onto
our
interest
in
in
the
development
process.
So
we
want
outside
developers
to
partake
as
much
as
possible.
We
want.
L
We
we've
already
had
a
few
contributors
from
the
rest
community
kind
of
help
clean
up
some
code
and
whatnot,
but
the
biggest
thing
for
us
is
not
to
be
the
sole
owners
of
this
of
this
potentially
alternate
internet.
So
we
want,
you
know
outside
developers
to
participate
and
rest
is,
or
we
think,
a
really
great
Avenue
for
that
in
terms
of
making
it
more
accessible
compared
to
C++,
yeah
and
I.
Guess
some
just
just
to
note
that
we're
also
all
of
our
code
is
a
GPL
3.
L
So
if
that,
if
that
excites,
you
then
we're
definitely
interested
in
that
we're
also
having
some
internal
debates
about
whether
to
stick
with
that
or
not.
But
it
is.
We
do
generally
want
to
make
this
and
use
rest
to
build
like
this
alternate
internet
that
is
focused
on
privacy
and
security
and
then
I
guess.
Finally,
if
you
want
any
t-shirts
or
stickers,
there's
some
t-shirts
and
stickers
over
there.
A
B
So
back
in
2013,
we
were
involved
in
some
of
the
heavy
lifting
behind
signal.
Ios
and
signal.
Os
is
an
end-to-end
encrypted
voice
and
text
messaging
platforms,
frites
available
on
iOS
there's
a
java
implementation
available
for
Android,
and
it's
pretty
good
I
really
would
recommend
everybody
here,
use
it
it's
one
of
the
really
interesting
things
about
privacy
and
encryption
is
that
the
more
people
use
it
the
more
herd
immunity
everyone
has.
B
So
this
work
finished
up
for
us
in
late
2014,
but
more
recently,
whisper
systems
has
launched
the
axolotl
ratchet
and
it's
a
modern
protocol
for
asynchronous
communication
with
some
interesting
privacy
and
security
guarantees.
So
it's
got
forward
and
future
secrecy,
and
what
that
means
is
that,
if
there's
a
key
compromised
in
a
moment
of
time,
only
the
messages
that
are
using
that
key
will
be
potentially
breakable
historical
messages.
The
key
to
those
are
gone
and
future
messages
are
going
to
be
ratcheted
on
that
existing
key.
B
So
the
key
you
have
is
actually
not
enough
to
read
future
messages.
It's
really
interesting
protocol
there's
some
people
who
are
pushing
to
have
it
used
to
you
know,
be
really
ambitious
and
replace.
Gpg
is
the
gold
standard
for
kind
of
general
purpose
communication.
We
really
want
to
see
it
used
more
places,
and
so,
when
we
came
to
this,
when
the
protocol
launched,
we
thought
to
ourselves.
Okay,
we
want
to
help
build
this
and
make
it
a
general-purpose
library.
B
But
you
know
writing
security.
Software
and
see
is
really
scary.
You
know
you
can
write
it.
You
can
get
lots
of
eyes
on
it.
You
can
think
you've
done
a
great
job
and
then
you
know
something
comes
up.
You
know
and
we're
great
programmers,
but
we're
not
super
hero.
Programmers,
like
the
you
know,
libre
SSL
guys,
so
I
don't
think
we're
going
to
do
it
right,
but.
B
Rust
makes
this
possible
for
normal
human
beings
to
solve
some
of
the
significant
security.
Some
of
the
problems
that
have
faced
security
applications
over
the
past
decades,
right
off
the
bat,
the
bound
checking
herbs,
the
read
after
free
errors,
the
buffer
overflow
errors,
all
the
classic
errors
gone,
which
is
pretty
awesome
but
as
bonus
points
rust
makes
it
pretty
easy
to
do
some
like
basic,
compile
time
checking
of
your
protocol.
You
get
strong
typing
and
your
crypto
primitives,
so
you
can
be
sure
that
a
public
key
is
never
mixed
up
for
the
private
key.
B
That
cipher
text
and
plain
text
are,
you
know,
never
crossing
paths
when
they
shouldn't
be.
You
get
yet
enforced,
match
coverage.
So
if
an
error
is
thrown
from
some
part
of
your
program,
the
compiler
like
demands
that
you
handle
that
properly,
which
is
you
know
great
for
the
first
implementation,
but
which
is
even
better
as
the
libraries
maintained
developed,
extended
you're
not
going
to
have
another
committer
come
on
board.
Make
a
change,
have
an
error
that
previously
was
handled
no
longer
be
handled.
That's
really!
That's
really
interesting.
B
A
bunch
of
other
kind
of
littler
things,
especially
when
using
block
ciphers
having
fixed
length
arrays
as
compile
time
guaranteed
super
useful.
All
of
the
code
for
this
is
a
up
on
github
I'm
not
going
to
do
any
code.
Examples
right
now,
but
I'd
actually
be
happy
to
go
over
that
on
github
with
anybody
who's
interested
this
evening.
One
thing
that
would
be
really
useful
is
you
know
we
are
learning
rust
as
we
go
I
think
as
many
people
are
we're
particularly
interested.
B
If
folks
have
comments
on
what
we
could
have
done
more
idiomatically,
we
kind
of
came
to
it
with
a
lot
of
experience
in
c-sharp,
a
lot
of
experience
in
C,
C++
I'd.
Imagine
we
did
a
lot
of
things
in
ways
that
rusts
could
do
better
and
we'd
love
to
hear
some
feedback
about
that.
So
yeah
we're
pretty
excited
about
rust.
We
think
this
is
like
going
to
be
the
tool
that's
going
to
make
interesting
things
for
the
next.
You
know
five
or
ten
years
I'd
love
to
hear
from
folks
here.
B
Why
aren't
using
rust
for
your
next?
You
know
systems
or
networking
product
I'd
love
to
hear
that
I'd
love
to
hear
what
those
obstacles
are
and
I'd
like
to
figure
it
up
to
some
way.
We
can
help
tear
those
down
yeah
come
chat
with
us
I'll
be
around
my
business
partner,
Rachel's
here
we'd
love
to
hear
about
problems
with
the
language
ways.
We
could
help
with
the
ecosystem
ideas
for
products
interesting
stuff,
thanks
guys.
O
Everybody,
we're
really
excited
to
tell
you
about
how
we
use
rust
in
production
today
at
journal
com
terminal
come
first,
so
we
have
tens
of
thousands
of
users
and
followers
using
our
really
fast,
really
easy
to
use
cloud.
We
can
launch
a
full
virtual
machine
in
seconds
one
cool
feature:
we
have
that
other
clouds
don't
have
is
we
can
take
a
running
machine
and
snapshot
its
full
RAM
and
disk
stays.
So
you
can
start
it
up.
Wait,
hold
services
running
really
quickly
and
people
really
really
love
our
cloud
for
data
science.
O
They
start
up
like
10,
100,000,
notes,
part
clusters
and
they
all
have
to
talk
to
each
other
really
securely
and
really
quickly,
and
that's
what
the
talks
about
our
old
generation
networking
system
was
based
on
a
bunch
of
C
code
and
basically
had
to
manage
a
large
number
of
machines,
always
migrating
moving
around
on
our
physical
host
and
they're,
always
starting
stopping
pausing.
Just
a
lot
of
moving
parts
to
manage.
O
We
had
a
very
simple
system
that
it
was
just
difficult
to
extend
and
difficult
to
get
more
junior
engineers
to
work
on
without
potentially
causing
something
some
instability
and
it
was
all
closed
source.
So
I'm
moving
over
to
rust
and
open
sourcing,
everything
and
hoping
that
people
can
contribute
and
use
it
more
and
I
think
we'll
have
something:
that's
extremely
extensible
and
something
that
a
lot
of
other
people
can
can
build
on.
So
why
aren't
we
using
go
or
Python
or
Java,
or
something
that
is
didn't
reach
one
point
out
today
so.
O
We're
systems
company
we're,
but
writing
really
really
fast
systems
like
people
don't
want
to
compromise
on
the
speed.
The
GC
is
gonna
pause.
We're
not
gonna
get
the
memory.
Let
we
want,
like.
Basically,
these
DC
language,
I'm
really
going
to
work.
Also
we're
not
going
to
put
Java
in
the
kernel
c
and
c++
were
a
lot
better.
O
So
why
are
we
using
rust
instead?
Well,
it
means
we
can
take
these
junior
engineers
who
are
used
to
go
in
Python
and
NGC
languages
and
like
get
them
to
be
productive
really
quickly
and
the
senior
engineers
who
have
a
lot
of
experience
about
making
sure
to
be
careful
about
memory
management
like
they
don't
have
to
spend
their
whole
time
when
reviewing
code.
Like
oh,
did
you
think
about
this?
Do
you
think
about
this?
I
can
just
felt
like
the
engineers
can
just
focus
on
high
level.
Is
this
algorithm
crack?
O
This
is
the
right
data
structure
and
the
compiler
Thank
You
Russ
compiler
developers
does
that
for
me
and
it
stays
an
enormous
amount
of
time,
we're
startup.
We
need
to
move
fast
and
when
the
compiler
is
teaching
people,
how
to
think
that's
really
great
and
also
I
mean
the
rest.
Community
is
really
great,
really
really
genius
and
really
nice,
ok,
so
the
what
are
some
downsides?
O
Language
has
been
changing
quickly,
a
lot
less
now
that
we're
one
point
out:
it's
really
great,
but
it's
also
forced
us
to
have
a
lot
of
automated
tests,
which
are
valuable
in
and
of
themselves.
There
is
a
lot
of
library
support.
We
had
to
wrap
a
lot
of
C
libraries
ourselves
and
create
them,
but
that's
great.
We
get
to
contribute
to
the
open
source.
Community
respondent
is
a
really
cool
program
to
automatically
generate
these,
and
the
last
point
is:
there
is
a
steep
learning
curve.
That's
absolutely
potentially
a
downside.
O
The
way
we
look
at
it
is
it's
a
training
tool
for
thinking.
So
again
like,
if
someone
isn't
really
a
top
modern
see
postbus
developer
and
they
have
only
used
GC
languages
like
they
need
to
learn
all
those
skills,
all
those
little
gotchas
and
the
rest
compiler
again
teaches
our
our
engineers,
like
here's,
how
you
can
think
about
it,
and
thus
we
get
to
get
a
lot
more
productive
team,
a
lot
more
quickly.
O
Okay,
so
one
of
the
things
we
built
is
a
something
that
watches
every
packet:
that's
leaving
our
cluster
and
in
Lesson
half
a
second
can
detect
and
stop
like
poor
scanners
of
using
our
system
to
launch
attacks.
We
have
a/c
version
of
this.
The
rust
version
runs
an
equally
fast.
Thank
you.
Zero
cost
abstractions
and
we
saturate
a
link.
So
there's
no
slowdown
that
you
might
get
in
other
languages.
P
So
the
way
we
do
this,
we
need
to
make
a
lot
of
system
calls
so
and
we
had
some
help
and
we
wrote
an
abstraction
over
netfilter
queue,
which
is
itself
an
abstract
over
the
net
link.
Librarian
see
and
we
also
wrap
some
kernel
calls
and
those
fo
5s
are
pretty
easy
to
do
and
they
are
on
creates
debt
I
owe
now,
and
we
also
started
to
re-implement
an
optimized
to
level
LRU
cache
in
pure
rust.
So
it's
a
work
in
progress.
We'd
love
it.
P
If
anyone
would
love
to
look
at
it
also
in
crates
I,
oh
and
our
firewall
is
in
production
and
working
right
now
moving
forward.
We
would
also
like
any
packets
that
go
between
our
terminals
to
be
filtered
explicitly
if
they
are
not
allowed
to
go
between
those
terminals,
and
we
want
to
do
that
by
storing
them
in
a
cache
and
looking
up
those
that
were
not
sure
of
their
permissions
using
a
source
of
truth
in
Redis.
We
hope
this
will
eventually
be
faster
than
IP
tables
in
the
colonel.
P
So
the
way
that
we're
doing
this
is
we're
using
mio,
which
is
great.
I
recommend
it
if
you
haven't
looked
at
it
and
we
also
adapted
the
thread
pool
to
keep
open
rytas
connections,
so
it's
published
as
write
a
spool,
and
that
way
we
have
open
rytas
connections
and
we
avoid
the
overhead
of
reopening
those
connections
every
time
you
make
a
query
so
once
this
is,
you
know
operational
and
good,
it
will
be
open
source
as
well.
The
best
part
of
this
is
that
the
easy
thing
here
was
the
multi
threading.
P
The
hard
thing
was
the
logic
which
is
great.
It's
great
that
there's
a
language
that
lets
us
do
that
moving
forward,
we'd
love
it.
If
someone
would
talk
to
us
about
binary
size
and
still
much
larger
than
our
C
counterpart,
even
though
it
does
about
the
same
thing.
We
also
would
really
like
to
move
this
into
the
kernel
and
get
it
a
lot
faster.
There's
examples
out
there
for
it,
it
looks
really
cool.
We
have
a
lot
of
work
to
do.
We'd,
love
to
talk
to
you,
guys
we're
hiring
too
and
stay
in
touch.
A
K
K
No,
it's
huge
there,
you
go
everybody.
My
name
is
Sam
ward
I
just
wanted
to
quickly
show
you
the
state
of
3d
programming
and
rust,
it's
a
very,
very
exciting
opportunity
to
do
open-source
programming
for
3d
and
basically
just
wanted
to
expound
on
that
a
little
bit.
Who
here
has
actually
written
a
game
programming
like
in
any
programming
language
before
here
in
a
3d
game.
So
there
are
a
few
people.
K
Rust
has
an
amazing
amazing
potential
to
become
the
next
open
source,
3d
programming,
language
there's,
actually
a
lot
of
activity
in
the
community
already,
even
though
we're
just
announcing
one
point
out
today,
there
are
full
engines
that
have
already
been
written
in
rust.
For
example,
piston
is
the
most
popular
one,
I
believe
I,
don't
have
slides
I'm
just
going
to
show
you
a
couple
open
source
projects
that
are
out
there
right
now
and
try
and
get
you
excited
about
it.
K
Basically,
even
if
you're
new
to
game
programming,
then
rust
is
creating
opportunities
for
people
to
learn
how
to
do
it
very
quickly
and
essentially
in
the
future.
I
think
it'll
be
possible
to
make
entirely
like
triple
a
quality
games
entirely
and
rust,
and
the
reason
for
that
is
it's
easy
to
write
safe
code
Z
the
right
fast
code
because
of
zero
cost
abstractions
and
the
interlocking
capacity
of
generic
code
will
make
it
possible
sort
of
like
mix
and
match
different
components
of
the
3d
stack
into
a
game
or
a
3d
thing
of
some
kind.
K
K
K
You
can
start
using
engine
right
away
or
you
could
take
a
look
at
some
other
temps
for
engines
and
mix-and-match,
some
components
that
are
available
right
now
to
try
and
make
your
own,
which
sounds
like
her
aquiline
effort,
say
Herculean
effort,
but
it's
actually
becoming
quite
possible.
Do
by
yourself.
For
example,
I'm
very
smart
man
named
Sebastian
creuset
has
written
these
n
libraries
and
physics
and
algebra
and
collide,
which
for
the
most
part,
take
care
of
collision
detection,
linear
algebra,
and
he
also
lists
of
rendering
stuff
out
there.
K
But
they
are
components
which
is
very
interesting.
You
can
mix
and
match
them
to
make
your
own
engine.
For
example,
you
could
write
an
entity
component
system
that
just
kind
of
takes
in
this
physics,
library,
where
it
grabs
this
rendering
library
mixes
them
together,
write
your
own
entity
component
system
on
top
of
that
and
boom.
You
have
a
fully
featured
three
engine
already
by
yourself.
K
A
lot
of
this
was
possible
because
of
servo
actually
server
uses
OpenGL,
and
so
they
wrote
the
findings
that
are
currently
used
in
most
of
this,
although
there
are
other
bindings
available,
there
is
a
gluten
which
is
a
pure
best
alternative
to
glfw,
which
is
common,
C++.
Finding
and
other
interesting
things
exist
like
glass
bowl,
which
is
a
I
believe,
a
macro
system
for
shaders.
K
So
you
can
actually
have
shaders
in
your
in
your
program
also
entirely
within
rest,
which
is
very
cool,
so
yeah
I
hope
that
got
you
a
little
bit
interested
or
excited
about
3d
programming
and
Russ.
It's
a
huge
opportunity,
I
believe
that
we
could
have
this
ecosystem
that's
better
than
any
other
three
ecosystem.
That's
out
there
right
now
and
I'm
very
excited
about
it.
So
I
was
hoping
to
spread
the
excitement
a
little
bit
and
get
you
interested
go
on.
K
A
F
F
It
was
a
very
national
experience
back
there
and
the
language
itself
was
a
very
different
language,
and
so
my
idea
for
a
talk,
which
kind
of
give
a
demonstration
of
how
different
it
was
in
five
minutes
and
I
came
up
with
this
list
of
things
and
it's
a
very
long
list,
and
each
of
these
could
all,
on
their
own,
be
a
letting
talk
about
rust
and
there
is
actually
crust
in
here.
So
it
can.
F
It
evolve
over
the
past
four
years
or
more
so,
as
you
may
know,
the
language
itself,
which
came
from
briefly
a
school
man
graydon,
was
watching
hi
Graydon
and
he
started
about
two
thousand
six
on
his
own
time,
but
eventually
it
was
in
10
or
so
Mozilla
started,
picking
it
up
and
actually
paying
him
I
think,
Patrick
and
Brian
as
well
to
start
actually
working
on
in
full
term,
and
it
was
a
very
different
language
back
then.
But
I
want
to
emphasize
how
the
polls
are
really
what
drove
this
language.
It
wasn't
really.
F
F
So
hopefully,
Brian
wrote
a
while
back
a
tool
that
lets
you
actually
explore
the
test
suite
from
rust
kind
of
meh
stepping
through
time
and
seeing
how
things
have
changed
over
time
and
you
can
just
to
play
and
watch
it
go
and
its
many
of
these
tests
only
one
actually
makes
sense
in
modern
rust,
which
is
why
they're
x
fail
today
and
then
one
goes
2012
13
or
so.
But
if
you
look
at
these
kind
of
fits
just
none
of
those
things
on
my
list
that
I
showed
you
before
are
actually
mentioned
at
all.
F
I'm
gonna
show
you
this
next
slide
right
here.
So
this
here
is
rust
code
circle
at
about
2010
middle
of
2010.
As
you
can
see
here
we
have
a
notion
of
purity.
We
have
this
function.
Does
I?
Oh?
It
was
not
pure
by
default.
We
have
generics
with
square
bracket
syntax.
We
have
types
coming
before
the
names.
We
have
first-class
channels
in
the
language.
We
have
a
kind
of
a
go
like
channel
receiving
operator.
We
have
logging
the
flog
levels
controlled
by
environment
variables.
F
In
the
language
itself,
we
have
type
state
which
is
kind
of
a
really
wacky
feature.
That
is
really
cool,
but
people
are
sad,
that's
gone
nowadays
sometimes
and
we
have
more
I'll,
even
though
this
does
then
remember
canadia,
we
even
guess
it's
a
good
channel
send.
Okay,
probably
so.
This
is
like
an
actual
test
case.
This
is
from
and
how
I
oppose
like
pretty
much.
None
of
this
isn't
the
language
anymore.
F
F
We
can
watch
so
I
Oh
becomes
in
pure,
then
we
exhale
it
cuz.
It
failed.
We
ever
actually
probably
turned
it
back
on,
but
and
then
o
FN
main
and
then,
when
the
check
post,
assert
and
various
things
continue
happening,
and
you
can
just
play
this
tool.
I
can
give
you
the
address
play
with
it's
called
archaea
and
it
was
not
dated
make
it
last
in
like
2013
I
think
so
isn't
quite
go
to
the
modern
day,
but
it's
a
really
fascinating
way.
F
To
look
at
these
things
like
to
show
you
some
more
too
so
this
next
one
here
is.
We
actually
has
anyone
heard
of
iterative
before
wouldn't
I
didn't
know
this
until
they
actually
went.
The
talk
together
is
that
we
use
to
have
iterators
in
the
language
is
a
first-class
feature,
and
apparently
at
some
point
we
lost
on
this.
This
inner
function
here
is,
has
a
yield
construct
called
put,
and
then
we
had
a
4h
construct
and
no
one
knew
about.
F
This
cuz
number,
how
much
of
a
pain
in
the
butt
it
was
to
remove
in
the
language
after
a
while,
and
this
isn't
a
denigrate
anyone's
efforts
from
back
thanks,
this
kind
of
just
emphasize
how
is
very
experimental
and
how
we've
focused
the
language
so
much
over
the
past
few
years,
and
we
can
give.
We
can
becca
just
write
a
book
tylee
on
just
the
evolution
of
things
and
I'm
sure
if
you're
a
language
designer
or
aspiring
one.
F
You
would
definitely
benefit
from
reading
it
and
here's
some
more
right
here,
for
example,
so
he
used
to
make
tuples
with
this
tube
keyword
and
then
we
had
to
pull
indexing.
This
is
back
in
thousand
eleven.
This
is
before
my
time
definitely,
and
if
you
have
used
for
us
in
the
past
year,
remember
we
didn't
used
to
have
to
pull
indexing.
We
actually
remove
this
feature,
which
is
because
I'm
going
to
show
you
here
the
neck,
be
an
actual
next
evolution
of
this
piece
of
code.
F
F
Cascading
sequence
of
events
where
language
click
in
like
because
of
six
months
becomes
entirely
recognizable
and,
as
you
can
see
here,
so
I
can
be
the
FN
they
still
there.
But
we
have
like
the
assert.
We
grew
a
macro
system
so
sure
it
didn't
need
to
be
a
language
feature
or
a
key
words.
And
now
it's
a
macro.
We
have
log
again.
Log
also
thinks
it's
log
at
macropores.
Now
it's
like
a
crate
somewhere,
I,
don't
even
know
anymore.
F
It
used
to
be
a
macro,
I
lost,
track,
mm-hmm
right,
and
so
it's
really
fascinating
to
see
how
rust
is
just
adds,
features
and
removes
them,
and
then
also
can
always
just
go
back
and
add
features
back
in
so,
for
example,
here
we
have
a
couple
of
partial
application
which
used
to
be
and
playing
the
like.
It
says
so
it's
we're
doing
right.
It's
partially
applying
this
right,
I
had
to
guess
so.
Yes,
it
is,
is
how
this
is
the
old
closure
type
syntax
which
for
the
at
was
after
the
FN
force
grammar
reasons.
F
If
I
remember,
and
we
all
really
hated,
it
know
what
it
was:
FN
n,
it's
really
order
than
that.
You've,
no
idea
and
I'm
kind
of
just
I
know
it's
kind
of
just
we
have
I
could
laugh
at
it
now,
but
it's
it's
in
the
moment.
You
look
at
all
this
stuff
and
it's
kind
of
like
you're
really
caught
up
in
it.
You're
saying
hey.
This
is
a
really
great
great
idea
and
some
people
are
kind
of
like
well.
How
do
we
know
that,
like
now
1
point?
F
0
is
the
right
time
to
stop
evolving,
and
you
know
language
is
fine.
It's
good
enough
and
the
answer
is:
we've
tried
pretty
much
everything
we're
out
of
features
so
now's
the
time.
So
if
you
want
to
check
out
archaea
and
I
can
ignore
this
abdom
is
the
word
auto.
Is
here,
I,
don't
know
ways
for
I
would
just
baffled.
Why?
What
is
this
and
to
finish
off
an
wanted
to
show
you
the
progression
of
whole
world
from
the
gang
of
time?
It's
not
super
long.
F
We
had
to
log
and
then
I'm
grumpy,
then
we're
the
old
macro
syntax
with
hash
debug,
not
sure
why
we
had
debug
and
then
new
actress
in
tax
came
a
function
and
then
become
a
function
that
was
imported
by
default
in
the
mission
became
an
actual
macro
again
so
and
that's
pretty
much
it
so.
Thank
you.
Everyone.