►
From YouTube: Bay Area Rust Meetup March 2014
Description
The San Francisco Bay Area Rust meetup for March 2014. Talks about Rust: building an operating system, the region system, more TBD.
Help us caption & translate this video!
http://amara.org/v/2FhY/
A
Alright,
we
live
all
right,
hi
everybody
welcome
again
to
another
to
meet
up.
Thank
you
so
much.
We
have
a
great
lineup
of
speakers
at
here
to
present
today,
but
before
we
get
into
that
they're
just
a
couple:
administrative
things
that
I
want
to
mention.
First
off
on
Sunday,
we
are
doing
a
doc
athan.
It's
going
to
I
believe
frying,
correct
me.
If
I'm
wrong,
it's
going
to
happen
here
on
Sunday
at
12pm.
A
Do
we
meet
in
this
room
or
okay,
we'll
meet
here
at
12pm
and
for
all
of
you
out
there
on
the
internet,
we
will
have
an
IRC
channel
to
participate
and
we'll
be
working
off
of
a
etherpad
we're
going
to
meet
up
after
the
presentations,
we'll
just
kind
of
form,
a
small
group
and
chat.
How
exactly
we
want
to
find
the
docs
that
we
want
to.
We
want
to
document
after
this
and
we'll
we'll
talk
about
it
over
tomorrow
and
Saturday
on
the
IRC
channel
and
email,
so
everyone
can
participate
also
for
April.
A
What
I'm
trying
to
organize
is
it's
going
to
be
a
very
test
friendly,
meet
up
and
also
I
want
to
pull
together
a
test
athan
like
we,
we
used
to
have
a
buzzer
and
reducers
and
I'd
love
to
revive
that,
so
so
anyone
out
there
that's
working
on
something
test
related,
please
let
me
know,
and
maybe
I'll
be
able
to
get
you
into
our
schedule
so
on
to
our
presentations.
First,
we'll
have
Julia
presenting
her
amazing
OS
that
she
worked
on
without
knowing
anything
but
os's
or
rust.
A
B
C
B
B
Okay,
so
I
won't
talk
about
how
I
wrote
an
operating
system
in
rest
and
when
I
did
this
I
didn't
really
know
any
rust.
So,
like
I
started
learning
Ross,
I
think
I
spent
like
a
whole
day
on
it.
I'm
hurting
dress
before
doing
this
and
I
also
didn't
really
know
anything
about
operating
systems
at
the
time.
So
what
happened
is
I
was
at
hacker,
school
and
hacker
school.
Is
this
three-month
program
where
you
can
do
anything?
You
want
right.
B
So
when
you
have
that
opportunity
to
spend
three
months
doing
like
anything,
you
want
to
become
bitter
programming.
I
thought
the
naturals
was
supposed
to
do
things.
I
was
most
scared
of
right,
so
I
was
like
operating
systems.
What
is
it,
how
do
I
do
it,
because
I
did
a
computer
science
degree,
but
I
avoided
all
of
the
classes
where
you
do
things
like
programming.
B
Operating
system-
so
I
didn't
know
right,
I
was
like
so
I
like
it's
been
a
while
kinda
like
mucking
around
with
the
Linux
kernel
at
the
beginning
of
hacker
school
at
the
end
of
hacker
school
as
like.
Okay,
things
are
serious.
It's
almost
over
I
need
to
write
an
operating
system
like
stat,
so
Lindsey
Cooper,
who
did
some
work
on
the
rest,
was
ad
hacker
school
it's
time
and
she
was
like
and
I
was
like.
I
want
to
use
rust
or
something
but
I'm
not
doing
any
systems.
B
Programming
also
I'm,
not
wearing
operating
system
starting
today
and
she
was
like.
Do
you
realize
that
your
statements
are
contradictory?
And
maybe
you
start
your
operating
system
in
rust
and
I
was
like
okay,
cool
I'm,
so
I
started.
This
is
my
operation
is
called
puddle
because
it's
like
it's
really
fun,
but
then
also
you
get
wet
it's
like
sort
of
that
idea
and
a
lot
of
things
been
wrong
along
the
way:
okay,
so
the
first
and
most
important
staff.
What
is
two
coffees
and
go
from
the
internet
right?
B
So
there's
this
thing
called
rust
boot,
it's
a
little
tiny,
colonel
written
and
rust,
and
it
looks
like
this
right.
You
start
it
and
turns
the
screen
red
and
hangs,
and
that's
it
that's
all
it
does.
This
is
amazing.
Right,
like
this
is
a
huge
advance
over
what
I
could
already
do,
which
was
nothing
right,
so
I
had
this
and
I
was
like
sweet.
This
is
cool,
so
step
two
was
to
be
like
well,
its
paste
screen
red.
Maybe
I
can
paint
the
screen.
B
Blue
I
promise
I
did
more
than
this,
so
this
is
like
a
surprisingly
important
step
right
because,
like
it's,
like
I
actually
had
to
go,
look
at
the
code
and
feel
like
this
isn't
totally
terrifying,
and
in
particular
you
can
see
here
that
it
says,
like
clear
screen,
light
right.
So
I
change
that
to
blue
right.
There's
enum
up
here,
which
is
like
I
was
like
okay
I
have
like
I
can
build
it.
I
can
run
to
my
emulator.
I
can
change
something
I
can
program.
This
isn't
a
total
loss
right.
B
So
the
next
thing
I
want
to
talk
about
is
like:
why
can
you
write
an
operating
system
and
rust
right
like
what
would
it?
What
does
it
mean
that
you
can
write
an
operating
system
and
rust,
because
this
is
something
that
was
really
unclear
to
me?
I
may
be
clear
to
all
of
you
like
what
like
in
what
languages
you
can
write
an
operating
system,
so
you
can't
really
write
an
offer.
I
exist
in
Python.
B
That's
on
your
computer,
it
like
when
it
does
things
like,
let's
say
like
print
to
the
screen.
It
does
that
through
your
Colonel
right,
like
their
system
calls,
the
system
calls
go
through
your
kernel
and
you
can
trade
a
kernel
on
top
of
the
colonel,
because
you
don't
have
a
kernel
right,
which
is
like
sort
of
obvious
of
you
know
that
kernel
of
programming,
but
if
you
don't
you're,
like
oh
yeah,
so
this
is
like
huge
moment
of
enlightenment.
For
me,
where
I
was
like
I,
don't
have
a
curl
whoa
like.
C
B
Don't
know
put
my
mind
right
and
if
you
try
to
do
things
like
if
you're
writing
and
see-
and
you
try
to
use
like
this
like
standard
library
things
right,
if
you
do
like
include
standard
I/o
printf,
suddenly
it's
like
wait.
What
is
printf
printf
calls
like
the
right
system
call,
but
there
are
no
system
calls.
Oh
no
right.
B
B
Doesn't
rust
use
things
that
might
require
using
system
calls,
but
you
can
say
rust,
take
away
all
the
things
right
and
I
think
this
is
called
running
Russian
like
freestanding
mode,
so
I'm,
one
of
the
things
in
my
kernel
is
it
says,
like
no
STD
here.
That
means
like
I've
got
this
I,
don't
need
any
stupid,
colonel
I'm,
doing
like
I'm
in
charge,
I
get
to
do
everything
which
is
fun,
but
it
also
means
that
you
lose
a
lot
right,
which
is
a
bit
terrifying.
B
So,
let's
talk
a
bit
about
like
when
you're
writing
a
kernel
on
the
things
that
you
don't
have,
so
you
have
some
hardware
underneath
you
right,
you
do
not
have
like
you
can't
allocate
memory
without
writing
your
own
malloc
function
right.
One
thing
that
really
surprised
me
that
I
didn't
think
it
was.
B
You
don't
have
like
a
slate
function
like
if
you
want
to
like
wait
like
what
I
ended
up
doing
was
I
wrote
these
like
four
lives,
which
would
just
like
iterate,
80
million
times
like
use
up
cycle,
so
that
it
would
take
time
because
I
was
like
I
there's,
no
there's
no
sleep.
That's
not
the
thing
I
would
need
to
do
that
myself.
B
I
see
how
it
is
right,
like
digital
processes,
there's
no
drivers
like
you
can't
like
type
on
your
keyboard
and
have
it
work,
because
that
would
mean
that
you
have
a
keyboard
driver
which
you
don't
have
yet
because
you
all
like
the
only
thing
you
have
a
screen,
that's
red
right
like
that's
it
I'm,
like
you,
don't
have
a
file
system
like
at
all.
Right
like
you,
would
also
need
like
an
ide
driver
or
something
for
your
hard
drive
like,
and
then
you
would
need
a
file
system
on
top
of
it
like
that.
B
That's
like
a
whole
can
of
worms
processes,
there's
no
like
separation
of
privileges
between
different
processes,
even
if
you
did
hit,
perhaps
processes
right,
like
everything,
is
all
in
the
same
place
anyway.
So
you've
lost
everything,
it's
kind
of
like
you're
like
a
little
child,
and
you
don't
have
anything
like
the
stuff,
except
like
some
assembly
and
like
you're
like
okay.
What
do
I
do
so
I
was
like
what
do
I
do.
Maybe
I
can
write
some
text
to
the
screen
right
like
this
is
what
we
do.
B
We
write
hello
world
and
this
seemed
approachable.
This
was
kind
of
approachable,
so
you
can
see
you
may
not
be
able
to
see,
but
it's
basically
what
you
do
is
this
the
address
of
the
vga
buffer,
which,
if
you
go
up
here,
is
like
0
like
be
8,000.
So
that's
fine
right,
like
there's
a
thing
and
every
character
is
two
bytes,
so
you
seem
to
figure
out
what
the
right
bites
are
and
put
them
in
the
right
place.
That's
kind
of
like
indexing
into
an
array
right.
B
This
is
something
that
we
can
kind
of
do
if
we
don't
see
so
like
from
up
for
like
firma
operating
systems
perspective,
this
was
totally
fine
and
we
r
us
prospective.
This
was
like
a
total
disaster,
because,
like
I
would
try
to
do
things.
I
would
be
like
oh
I
want
to
convert
my
string
to
an
array
of
bytes
so
that
I
can
iterate
over
it
like
I
want
to
iterate
over
a
string.
I'm
like
this
look,
I
want
to
iterate
over
a
string
was
like
this.
Like
really
long.
B
Conversation
IRC,
like
I,
have
like
a
lot
of
discussions.
People
in
the
rest,
IRC
channel
over,
like
how
do
I
do
this
because
a
normal
rest
it
would
it
be
fine
and
they're,
like
methods
and
stuff
that
you
could
call.
You
can
just
be
like
a
sierra
de
as
bites,
but
instead
I
was
like
and
I'm
using
free,
citing
rust
and
I.
B
Don't
know
rust
sweet,
but
the
person
who
writes
that
so
because
you've
lost
your
standard
library
right,
like
you,
took
it
out,
I'm
Sanada
can
no
longer
iterate
because
your
standard
library
is
gone.
So
that's
kind
of
terrible.
So
there's
this
library
called
rust
court.
That
gives
you
your
standard
library
back,
which
is
fine
and
it
would
probably
more
fun
if
I
actually
knew
rust.
B
E
B
Was
an
amazing
experience
right
and
this
code
in
the
end
looks
kind
of
simple:
it's
like
let
bike
lights
equals
thing
for
the
in
iterate
over
bytes.
That
took
me
like
an
hour
to
write
or
like
more
I,
don't
know.
I
was
extremely
confusing
and
I
needed
a
lot
of
help,
but
people
were
very
helpful
and
then
I
did
it
and
it
was
fine
and
then
the
result
of
that
was
that
I
could
print
stuff
to
my
screen.
That
was
ride.
B
Right
and
I
could
like
have
different
background
colors
and
foreground
colors,
and
it
was
like
super
fancy
like
the
80s
or
something
I
don't
know
so.
I
was
super
happy,
so
the
next
thing
I
wanted
to
do
was
I
was
like
well.
If
I
can
print
to
my
screen,
I
would
like
to
be
able
to
type
on
my
keyboard.
Right
like
these
are
like
little
tiny
baby
steps.
I
was
going
to
have
a
demo
here,
except
my
computer
froze
the
demo
is
really
boring.
F
B
B
So
this
is
where
I
was
trying
to
go
right
and
like
this
was
like
terrible
like
it
was
a
disaster.
It
was
so
hard,
so
I
want
to
kind
of
explain
what
was
hard
about
it.
A
little
bit,
unlike
some
of
the
things
I
went
through
to
make
you
try
to
feel
like
bad
for
me,
but
it
was
but
a
bit
of
it.
It
was
pretty
fun.
So
what
happened?
This
is
a
long
list
of
things
so
to
get
interrupts
working.
B
B
The
appropriate
entry
in
that
table
like
it's
like
interrupt
one
right,
so
go,
look,
look
up,
entry,
one
and
Bella
piece
it
like
an
address
of
code
there
and
we'll
jump
to
that
code,
and
let
me
go
run
the
code
and
the
code
will
be
like
okay,
I'm
done
and
then
we'll
be
done
right,
which
sounds
simple
in
principle.
Right
and
there's
like
you
need
to
do
some
like
global
descriptor
table
and
there's
an
interrupter
scripture
table,
and
this
is
an
instruction
to
load
the
intra
krypter
table.
B
So
you
would
think
that
you
would
make
this
table.
You
load
it
you'd
like
press
keys
and
then
they
would
display
and
your
handlers
would
run.
This
is
like
not
the
case.
This
is
not
how
it
worked
for
me.
So
the
first
thing
is
I
like
tried
to
make
a
table
and
I
try
to
do
and
just
like
nothing
worked
like
I
would
presque
using
just
nothing.
What
happened.
I
feel
like
that.
B
Didn't
work
so
that
I,
try
other
stuff
and
I'd
press
some
keys
and
nothing
would
happen
and
I
would
press
like
try
more
stuff
and
I
thought.
Like
reference,
implementations,
I
had
like
some
C
code,
nothing
worked
so
at
some
point.
I
realized
that
interrupts
were
turned
off
and
I
need
to
turn
them
on
right,
as
I
turned
in
droves
on,
and
then
it
crashed
right,
like
the
whole
thing
would
just
crash.
Every
time
investigate.
I
was
like
sweet
like
this
is
a
huge
improvement.
B
B
B
Idea
like
trying
to
like
do
only
one
thing
at
a
time,
so
that
your
program
is
more
likely
to
work.
That
sounds
like
programming
like
good
practices,
that
I
know
so.
I
did
that
and
I
was
like
sweet
and
then
I
set
up
my
interrupt
descriptor
table
so
that
it
was
not
broken
and
I
could
trigger
an
inter
up
manually
and
then
I
was
like
ok,
so
I
turned
interrupts
back
on
and
still
doesn't
work.
I,
don't
like
friends.
B
So
then
I
read
the
article
again
and
apparently
the
word
for
this
is
I'm
receiving
exe
nine
instead
of
irq
one
when
striking
a
key
and
what
that
means
is
apparently
x86
just
doesn't
work.
So,
like
you
press
a
key
and
you
expect
to
get
interrupt
one,
but
instead
what
it
does.
Is
it
just
crashes
like
that's
like
a
the
normal
behavior?
B
That's
just
how
x86
works
apparently.
So
what
you
need
to
do
is
you
need
to
bring
up
the
programmable
interrupt
controller
so
that
interrupt
one
is
actually
mapped
to
interrupt
33
so
that
it
doesn't
crash,
because
it
can't
tell
the
difference
between
one
and
like
it.
I
should
just
explode
now
and
like
I,
don't
know
how
this
is
like
a
thing,
but
that's
like
x86
I
guess,
like
I
think
this
is
just
what
hardware
people
deal
with
all
the
time,
but
I
didn't
know.
B
Maybe
your
hardware,
people
I
you
did
know
but
I
had
no
idea
right.
So
then
I
do
it.
I,
like
remap
my
p.I.c
and
I'm,
like
okay,
I'm,
awesome,
it's
going
to
work
and
it
didn't
work.
But
this
time
it
didn't
work
just
because,
like
I
forgot
that
I
remapped
it
and
I'd
like
left
it
at
one,
instead
of
changing
it
to
33,
but
that
took
me
like
two
days.
C
B
Usual
right,
I'm
in
Iran
and
I,
was
like.
Oh,
my
god.
I
can
get
an
interrupt
handler
to
run
so
that
at
this
point
it's
like
I
can
press
a
key
and
it'll
always
print
J
right,
which
is
amazing
right,
like
I
press
a
key,
and
it
does
things
which
is
what
I
was
looking
for
and
so
that
that
took
like
six
days
right
and
I
was
like
okay.
Now,
the
next
thing
I
have
to
do
is
I
have
to
get
it
to
like
print
the
actual
thing
that
I
pressed.
B
So
this
thought
seems
like
it
might
not
be
too
hard
right,
like
okay,
so
I
read
some
code
to
do
this.
The
code
I
wrote
involves
an
array
I'm.
So
the
way
I'm
interrupts
work.
The
way.
The
way
that
keyboards
work
is
the
keyboard.
The
the
hardware
will
like
tell
you
which
scan
code
you
press
so
like
on
your
keyboard,
will
be
like
123456789
right.
B
E
B
B
I
would
compile
it
and
it
would
stop
working
again
and
then,
like
maybe
I,
linked
it
differently,
and
then
it
would
start
working
so
I
was
like
I
was
some
kind
of
linger
problem
right
and
it
was
so
I
read
like
10
articles
about
linkers.
So
there's
this
like
really
awesome,
like
20
part
series
about
health
anchors
work,
uh-huh,
so
I
started.
Reading
it
and
I
was
like
maybe
I'll
learn
what
my
problem
is.
B
If
I
just
read
like
everything,
I
can
about
lingers
right,
there's
been
like
a
day
bring
reading
about,
and
you
don't
have
to
read
this
blog
post
right
now,
because
it's
like
a
million
words
but
I
just
want
to
kind
of
give
you
a
sense
of
like
all
the
things
I
wrote
down
like
this
is
a
summary
of
everything.
I've
learned
about
linkers
and
it
was
a
lot
and
it
didn't
help
at
all.
Oh.
B
Guy,
at
the
end
of
it,
I
had
no
idea
how
to
solve
a
problem.
Still
I
was
like
I
looked
at
it,
I,
understood
much
better,
how,
like
my
binary,
was
structured
and
how
binary
formats
worked,
because
I
have
like
this
like
'I'll,
f
thing,
and
I
can
like
a
look
at
it
and
I
could
find
my
string
in
my
binder.
My
array
in
my
banner
and
I
was
like
the
array.
Is
there?
I
can
see
it
with
my
eyes.
B
But
it
didn't
work
and,
like
none
of
my
knowledge,
was
something
I
could
apply.
So
someone
in
this
blog
post
suggested
that
I
use
gdb
right.
This
was
a
good
idea,
so
I
was
like
I'll
use
a
debugger
right.
He
was
like
you
should
you
can
do
like
remote
debugging,
where
you
like,
attach
your
emulator
to
GDB,
and
then
you
can
like
do
bug
your
operating
system.
While
it's
running,
which
is
amazing,
right
I
was
like
that
sounds
like
exactly
what
I
want.
So
it
took
me
like
a
long
time
to
figure
this
out.
B
It's
looking
like
probably
a
couple
of
days
and
like
I,
asked
people
anyway,
but
like
no
one
could
really
help
me
except
the
internet,
so
I
blogged
really
loudly
about
all
the
stuff
right
and
then
people
in
the
comments
tell
me
how
to
use
qmu
with
gdb
and
I'd,
be
like
I
love.
You
you're
my
favorite
right.
B
Nobody
like
I
just
didn't
know
what
to
do.
Okay
right,
so
I
got
GTV
right
and
I
was
like
what
and
then
I
found
my
way,
and
it
was
all
zeros
like
I
found
its
address
and
it
was
actually
all
zeros
and
I
was
like
oh
I'm
getting
zeros
because
it's
all,
but
why
is
it
all
zeros?
And
that
was
really
sad.
So
I
read
a
blog
post
where
you
go
and
the
blog
post
is
called
so
big
is
a
racing
I
program.
B
G
G
B
Only
look
living
12k
of
your
binary,
so,
like
you
ever
have
at
the
beginning,
I
was
like
step
1,
copies
and
code
I'm,
so
step.
Two
was
not
read
that
code
all
right,
so
that
was
kind
of
like
true,
so
that
this
is
my
commit
fixing
the
problem
right,
you'll
notice
that
there's
a
typo
where
I'm
like
oh
I,
should
load
more
of
it
and
it
was
less
than
24
K,
so
I,
just
a
lost
load.
B
24
k
I,
like
it's
weird,
because,
like
the
kind
of
problem
that
I'm
used
to
having
is
not
like
I
have
a
program
and
accidentally
have
to
got
loft
off,
but
then
it
worked
fine,
except
for
like
there's
other
things
in
that
part
of
the
program.
It
wasn't
just
that
array
and
I,
don't
really
understand
why
it
works.
B
Still
hey
like
there
was
other
stuff
happening
there,
and
you
would
think
that
having
a
loader
that
just
like
is
like
a
guillotine
would
be
a
problem
more
like
a
bigger
problem,
but
apparently
not
apparently
that's
fine.
Apparently
that's
what
writing
operating
systems
is
like.
So
that
was
the
worst
thing
that
happened,
but
it
was
actually
really
good
right,
like
I
mean,
if
you
think
about
it
like
objectively
and
not
from
the
point
of
like
how
sad
I
was
like
I
did
read,
12
articles
about
linkers
and
that
was
like
it
was.
B
There
are
really
good
articles
and
I
wasn't
gonna
read
them
if
I
wasn't
upset,
because
I
thought
I
had
linger
problem
and
it
was
a
good
luck.
Debugging
exercise,
I'm
do
I,
told
someone
in
an
interview
about
this
problem.
I
was
like
how
like
how'd,
you
figure
out.
It
was
like.
I
was
like
someone
on
Twitter
told
me,
and
they
were
like
really
not
impressed,
but
like
also
I
do
you
really
want
to
work
for
them.
So.
C
B
Was
okay
because
I
thought
it
was
pretty
impressive
that
I
got
someone
on
Twitter
to
fix
my
problem
over
Twitter
anyway,
we
can
talk
later
about
who
was
right
so
right,
so
we
talked
about
everything
we
lost
right
like
we
lost
memory,
allocation
watch,
lil
asleep
we
lost
threading.
So
far,
the
only
thing
we've
gained
back
is
a
keyboard
driver
right
wherever
you
can
type
so
it's
like.
B
Maybe
we
could
gain
back
another
thing:
okay,
so
I
assume
that
you
know
rust,
probably
probably
better
than
me
right,
like
let's
feed,
let's
be
real
close.
Basically
writing
C
code
except
writing
in
a
rust,
like
I,
didn't
actually
allocate
memory
I,
just
like
implemented
memory,
allocation
for
cakes
and
like
I
understand
the
whole
point
of
rest
is
like
something
to
do
with
memory.
B
So
if
you're
not
allocating
memory
in
the
first
place
like
what
are
you
doing
anyway,
so
there's
a
statement
right,
which
is
like
Alec
a
tattoo
and
put
it
on
the
heap
and
like
X,
is
like
a
pointer
to
it
right.
A
node
pointer.
So
I
said
that
we
don't
have
memory
allocation
right
and
then
so.
This
statement
doesn't
work
like
it
won't
compile,
if
you
don't
have
that
right.
So
how
does
that
work?
So
it
turns
out
that
you
can
kind
of
like
swap
out
rushed
features.
B
I
need
a
like.
Let's
just
get
rid
of
all
the
features,
and
then
you
can
write
you
can
bring
them
back.
So
this
is
that
part
of
the
breast
core,
which
adds
back
some
things.
Dude
memory
allocation
right
and
it's
like
well
I'm,
like
I'll,
bring
back
like
the
exchange
Malik.
Where
is
this
exchange
Malik
Wright,
and
what
this
does
is
it
requires
that
you
have
a
malloc
function,
which
is
like
written
using
the
C
API
application,
binary
interface
because
rushed
functions
and
Steve
Owens
are
apparently
different
anyway.
B
So
if
you
have
a
malloc
function,
somehow
this
was
like.
Okay,
if
you
have
a
Malik
I
will
let
you
allocate
memory
right
like
if
you
write
me
a
malloc
function,
then
we
can
do
this
right
and
then
this
statement
can
work
if
you
write,
so
it's
like
kind
of
like
contract
right
sounds
like.
If
you
implement
the
it
like
appropriate,
like
threading
functions,
then
we
can
do
things
like
the
rust
threatening
things
right.
So
I
was
like
this
is
awesome.
B
I'm
gonna
implement
Malik
I'm,
so
I
did
I'm,
not
gonna,
go
through
it
because
really
boring.
It's
also
really
bad.
So
in
particular
like
it
was
impossible
to
free
memory.
Cuz
I
was
like
I'm,
not
gonna
write
a
real
Malik
I
just
want
to
do
it
for
fun
and
like
I'm.
Only
doing
it
today,
anyway,
right
and
also
like
Mike,
like
Michael,
was
under
24
k.
Right.
It
wasn't
doing
anything
and
I
have
like
four
gigabytes
of
memory
on
my
computer
I'm
like
I'm.
Definitely
not
gonna
need
to
free
right.
B
Why
would
I
want
that?
So
I
didn't
implement
three
I
only
implemented
Malik,
but
another
thing
you
can
do
is
you
can
implement
a
malloc
function?
Where'd
I
have
this
that
always
just
returns
the
same
thing
right.
You
could
have
led
to
malloc
function
that
has
a
fixed
address
and
just
always
returns
that
address.
This
is
amazing
because
it
means
that
you
can
write
code
like
a
equal,
something
right,
B
equals
something
and
like
allocate
a
whole
bunch
different
things
and
they're
always
going
to
be
all
the
same
right.
B
Infinite
are
you
could
have
ended
and
in
the
number-
and
you
always
used
same
out
of
memory,
some
fantastic
memory,
saving
technique
and
it
like
really
worked
right.
I
was
like
a
cool
look
to
and
like
B
equals
like
or
equals
a
and
B
equals
B
and
I
printed
a
and
B,
and
they
were
the
same
they're
always
the
same
and,
of
course
they're.
All
is
the
same.
I'm
suppr
exactly
like
intrinsic
about
like
rust.
B
B
Time
is
it:
how
are
we
for
time?
Can
I
talk
about
something
else?
Yeah
I
could
talk
about
running
programs.
Running
programs
is
really
fun.
It
turns
out
that
you
can.
This
is
something
that's
like
feasible
for
you
to
do
so.
I
tried
to
write
a
program.
I
got
like
half
way
there
and
then
I
stopped
in
particular.
I
tried
to
run
a
program
that
didn't
do
anything.
G
B
Is
like
surprisingly,
hard
so
the
way
I
ran
a
program
if
you
feel
like
this
is
sort
of
fun
thing
right
and
but
normally,
when
you
run
programs,
you
think
of
it
having
that
model
file
system
and
one
of
the
many
things
that
we
don't
have
is
a
file
system
right.
So
what
I
did
was.
I
just
had
like
a
little
program
that
I
embedded
inside
my
kernel
somewhere
and
I
just
knew
what
address
it
was
that
and
I
was
like
okay.
B
This
is
a
memory
somewhere,
I
know
where
it
is,
and
I'm
gonna
try
to
run
it
right
and
it
turns
out
that
doesn't
just
work.
Well,
you
can't
just
jump
to
the
beginning
and
have
it
work,
which
is
sad.
I
was
hoping
that
I
was
just
going
to
be
able
to
do
that.
But
then
what
I
learned
is
that
binary
formats,
art
formats
or
file
formats
right,
like
we
know
about
like
JSON
or
like
what's
another
file
format,
that
we
all
understand.
B
Yeah
yeah,
like
XML
right,
like
it's
texting,
you
kind
of
know
what
it
is,
but
when
I
thought
about
binary
I
was
like
binaries
are
a
magic
format
made
of
magic.
That
I
can't
understand
right
and
like
binaries.
Are
this
impenetrable
thing
and
it
turns
out
that
I
mean?
Obviously
that's
not
true,
but
it
turns
out
in
real
life.
B
It's
not
true
like
if
you
have
like
an
LF
file,
so
it
so
yep
is
like
the
binary
format
for
Linux,
which
is
all
I
know,
but
because
I
kind
of
like
was
like
I
know
about
things
on
my
computer
and
I
have
a
linux
computer.
So
there
are
some
like
magic
bites
at
the
middle
and
then
there's
like
facts
about
the
file,
and
there
are
utilities
that
help
you
read
it.
B
So
there's
a
utility
hold
like
reedy
LF,
which
lets
you
look
at
it
and
like
shows
you
all
the
different
parts
of
it
and
all
the
different
like
sections
and
like
like
segments
and
in
particular
you
can
figure
out
fairly
easily,
where
there's
a
part
called
start,
and
that's
the
part
that
you
need
to
jump
to.
So
what
I?
B
Basically,
all
I
need
to
do
was
like
make
an
appropriate
for
program
which
I
had
no
idea
how
to
do,
because,
normally,
when
you
compile
a
program,
it
has
all
kinds
of
stuff
in
it
that,
like
the
GCC
ads,
but
so
the
only
way
I
ever
figure.
This
out
is
that
is
that
Graydon,
who
I
understand,
is
fairly
important
in
this
community.
Sent
me
an
email,
because
I
really
really
long,
blog
post
be
like
I,
don't
understand
and
he
was
like
here.
Here's
all
the
information
that
you
might
ever
want
and
I.
B
I,
don't
even
know
you
thank
you,
that's
the
best
that
it
was
really
nice.
He
was
very
nice
about
it,
I'm
chicken,
so
he
gave
me
a
program
which
was
very
key,
which
was
like
very
small
and
had
almost
nothing
in
it.
So
and
then
you
can
like
it.
You
can
actually
take
like
a
binary
and
like
we'd
like
like
look
at
like
the
bites,
unlike
understand
everything
that
it
does,
and
that
was
a
pretty
big
revelation
for
me
anyway.
So
so
like
this,
this
was
a
super
cool
project.
B
B
Can
we
do
that
again
like
this?
Is
how
much
people
helps
me
right,
like
I'm
sure
some
of
you
are
here,
in
which
case
I
want
to
thank
you
because
it
was
like,
like
I,
have
no
idea
what
I
was
doing
right
like
it
was
a
total
disaster
and
I
also
didn't
arrest
and
the
cool
thing
about
writing
an
operating
system
in
rust,
as
if
you're
writing
an
operating
system
and
see
tons
of
people
have
done
that
before.
B
So
it's
really
hard
to
get
help
because
you'll
be
like
I,
don't
understand
this
thing
about
in
line
assembly
and
if
you
go
to
like
there's
knows
to
get
IRC
talent,
I
know
of
but
I
feel
like
about
whatever
you
like,
maybe
you're,
stupid
or
something
right,
but
in
the
rest
is
a
channel.
Do
like
I
would
ask
like
really
like
beginner
questions
about
strings
and
rust,
because
they're
kind
of
confusing,
but
then
I
also
just
like
sneak
in
operating
systems.
Questions
and
people
would
just
like
enter
those
two
and
everyone
was
super.
B
Helpful
and
I
got
all
kinds
of
help
that
I
don't
know
how
I
would
have
gotten
otherwise
yeah
and
everyone
was
super
friendly.
Here
are
some
of
the
people
help
me.
They
were
like
delightful
I.
It
was
like
not
a
possibility
like
this
is
like
one
of
the
first
questions.
I
asked
I'm
a
p8
apparently
got
answered
in
0
seconds
right.
E
B
B
Oh
I
was
wrong
like
but
I've
learned
about
like
binary
formats
and
linkers
cuz,
apparently
already
million
articles
and
I
learned
about
assembly
and
how,
like
the
boot
process,
works,
I'm
like
the
different
June
like
protected
mode
and
real
mode
and
like
interrupt
handlers
and
how
starting
a
program
works
like
kind
of
from
scratch
like
the
whole
thing,
I'm
and
Malik,
and
it
was
like
kind
of
like
a
ridiculous
experience
and
thank
you.
That's
all.
E
B
B
Never
like
I'm
being
serious
that
said
it
compiles
using
a
very
particular
version
of
breast
I'm,
probably
nightly
build
from
like
circa
December
17th,
and
you
also
need
to
do
some
weird
things
with
rustic
or
but
you
need
to
have
a
particular
version
and
also
like
hubs
like
monkey
patches
to
it.
If
you
were
interested
in
compiling
it,
I
could
probably
talk
to
you
about
it.
I,
don't
think
that
the
code
is
fundamentally
super
interesting,
like
the
interesting
thing
to
me,
is
like
what
I
learned
to
the
code
is
kind
of
crappy.
B
Other
people
have
done
much
like
more
technically
interesting
work.
I
think,
if
you
want
to
learn
about
the
code,
it
would
probably
better
treat
my
blog
posts,
which
have
like
the
concepts
involved
like
the
actual
code.
I
don't
recommend
in
any
way
yeah,
but
if
you
want
to
make
it
compile
like
please.
I
H
B
Like
it
was
super
fun
and
I
kind
of
thought,
like
we're
a
little
bit
about
trying
to
get
a
job
doing
it,
because
I
was
job
hunting
afterwards
I'm,
I
ended
up
getting
a
job,
doing
like
machine
learning
and
data
analysis,
which
was
like
much
higher
level.
I
got
a
lot
of
appreciation
for
what's
involved
and
I
did
think
was
really
fun
and
it's
something
I
would
maybe
consider
doing
like
when
I
get
bored
whatever
doing
now.
Yeah.
G
B
Like
that,
like
the
people
who
do
wrestle
what
I'm
rusty
like
it
was
really
confusing
that
wasn't
like
this
is
the
worst.
No,
so
it's
really
interesting
it
changes
every
day
as
far
as
I
understand
I'm.
So
it
was
like
really
frustrating
because
of
that
cuz
I
feel
like
I
wrote
this
code
and
they'd
be
like
that
was
yesterday
like
and
like
I
thought,
I
knew
things,
and
then
they
were
never
true.
B
So,
like
it's
hard,
it's
hard
to
think
that
rest,
partly
because
it's
so
unstable.
So
if
you're
not
paying
attention
to
it
like
day
to
day
and
I
was
only
doing
that
for
three
weeks
and
now,
like
all
of
my
net
knowledge,
is
like
three
months
old
on
I.
Just
imagine
that,
like
all
of
this
code
that
I
wrote
you're
like
what
language
is
that.
B
B
K
All
right,
hi,
so
I'm,
Patrick,
Walton,
pc
walton
on
IRC.
I
work
here
at
mozilla
on
rust
and
servo,
and
today
I'm
going
to
talk
about
it's
just
going
to
be
a
really
quick
overview
of
servo,
parallel
layouts.
So
for
those
who
don't
know,
servo
is
our
web
browser
that
we're
writing
in
rust.
It
is
it
well
to
browser
engine,
it's
not
a
browser
itself.
K
It's
a
research
browser!
It's
not
designed
to
be
it's
not
something!
That's
a
products,
and
it's
designed
for
testing
and
experimenting
with
different
with
different
approaches
to
render
the
web,
and
so
this
is.
It
is
almost
entirely
written
in
rust.
Well,
it
depends
what
you
mean
by
almost
entirely
so
the
layout
all
of
the
layout,
all
of
the
rendering
all
of
the
the
graphics.
It's
all
written
r,
us,
the
all
the
CSS.
K
C
K
Last
I
checked
rusty
was
like
80,000,
but
that
was
like
six
months
ago
or
something
so
it
may
be
more
now
and,
of
course,
that
doesn't
count
live
standard
which
is
fairly
big,
live
syntax,
the
entire
distributions
200k
that
says
person
so
yeah.
This
is
getting
to
be,
you
know,
kind
of
a
real
project
and
so
yeah.
So
what
I'm?
K
K
Remember
a
colleague
of
mine,
actually
Luke
Wagner,
actually
did
an
experiment
where
he
turned
off
the
JIT
and
browse
for
a
week
and
didn't
notice
a
difference,
and
so
when
it's
it's
actually
JavaScript
performance
has
got
a
lot
of
attention
because
it's
really
easy
to
measure
and
I'm
not
saying
it's
not
important.
It's
extremely
important
for
a
lot
of
new
things
that
people
are
doing,
but
when
it
comes
to
when
it
comes
to
your
day-to-day
browsing
experience,
we're
looking
that
rendering
is
really
keen
is
really
king.
So
we've
started
the
ends.
K
I
think
there's
a
lot
of
opportunity
here,
because
browsers
are
very
browsers
were
designed
in
an
era
of
single
threaded.
You
know
event
loops,
that
block
everything,
and
you
know
at
first
that
was
great
because
the
web
was
small
and
there
wasn't
a
whole
lot.
You
need
to
do
and
then
you
know
CSS
to
happen
and
then
css3
happens
and
then
stuff
that
isn't
even
in
css3
happened
and
then
suddenly
browsers
became
like
six
million
lines
of
code
and
they're
all
on
this
single
threaded
event:
loop
blocking
everything
model.
So
in
servo
we
thought
okay.
K
Well,
one
of
the
first
things
we're
going
to
do
is
to
split
up
everything
into
multiple
tasks:
multiple
threads,
so
basically
everything
that
we
could
possibly
get
away
from
the
main
event
loop.
We
got
away
from
so
basically
nothing
buds,
yeah.
Another
way
to
say
this
is
nothing
runs
on
the
JavaScript
thread,
except
your
JavaScript,
more
or
less,
and
everything
else
is
done
in
a
background
thread.
And
then
we
thought
well,
that's
great,
that's
great!
For
responsiveness!
It
means
that
you
know
when
layout
is
hung.
You
can
still
browse
the
page.
K
You
can
still
rerender
stuff,
that's
great,
but
what?
If
we
went
further
and
said
like-
and
it
also
means
that
we
have
like
I
frames
in
the
separate
thread
and
that's
really
great,
but
it
means
that
your
ads
won't.
You
know,
make
your
the
rest
of
your
page,
slow,
you're,
like
buttons,
you
know,
you're,
hundreds
of
like
buttons
on
TechCrunch,
won't
make
the
rest
of
the
page
slow,
that's
great.
But
what?
If
we
made
layout?
What?
K
If
we
took
advantage
of
your
course
that
were
in
your
system
to
make
layout
faster
and
just
make
the
whole
thing
faster,
and
so
one
of
the
nice
things
about-
and
we
there's
actually
some
research-
that's
been
going
on
in
academia
on
exactly
how
to
do.
This
is
actually
how
to
make
CSS
faster
by
using
multiple
course.
So
we
implement,
we
weren't
sure
how
this
would
really
work.
We
really
started
working
on
this
I'd
say
about
six
months
ago
or
really.
Actually,
this
code
is
only
a
few
months
old.
K
K
K
Instead,
I'd
like
to
focus
on
kind
of
the
general
rust
on
the
general
thing
that
we
use
in
rust-
and
I
would
actually
like
to
which
is
right
here
on
the
screen
and
I'd
actually
like
to
option
distance
of
a
rest
android
library
soon.
So
this
is
something
so
what
you're
looking
at
here,
something
called
the
work,
queue
and
a
work,
queue
and
rusts.
As
you
may
know,
when
you
do
multiple
threading,
you
have
tasks,
tasks
are
great.
They
can
communicate
with
message
passing
they
can
do.
You
know
they
can
block
on
Io.
K
K
But
in
some
cases
the
overhead
of
tasks
is
just
too
high
and
the
reason
that's
the
overhead
of
spawning
tasks
can
be
too
high
is
that
they
have
stacks
and
they
can
block,
because
and
what
that
basically
means
is
that
when
there
are
points
in
which
tasks
can
stop
execution,
they
can
block
like,
for
example,
is
waiting
on
a
network
request
or
sending
a
message
to
another
task.
Waiting
on
that.
K
In
that
case,
you
have
to
basically
suspend
what
the
task
is
doing
and
switch
to
another
another
task,
and
because
of
that,
you
have
to
allocate
space
for
the
task
stack.
You
have
to
allocate
space
for
each
task
for
each
task
stack
manually
before
you
start
the
task
and
that
is
actually
and
that
overhead
is
very
high
for
some
cases
when
you're
doing
parallel
layout,
/
/
a
document
you
may
have
you
know
100,000
nodes
that
you're
going
to
that.
You
need
to
paralyze.
You
know
in
10
milliseconds.
K
So
if
you
know
100
100,000
note
10
milliseconds
/,
a
hundred
thousand
that
gives
you,
like
you
know,
point
oh
one,
milliseconds
per
Dom
node
at
that
point.
Allocating
a
stack
is
so
expensive
that
by
the
time
you've
done
that
you
could
have
already
done
all
the
computation
needed
for
that
node.
So
you
need
something
much
much
cheaper
and
that's
what
this
work
you
is.
The
work
queue
is
a
super
cheap
way
for
you
to
and
Q
units
of
work
and
here's
the
unit
of
work.
K
It
is
parameter,
it's
parameterised,
/,
really
terribly
names,
type
parameters,
quad
and
wood.
Quad
is
for
data
that
the
work
queue
has
and
what
is
for
the
work
unit,
data
and
that's
all
you
get
and
you
get
a
function
and
that
function
has
to
execute
and
has
to
fully
execute.
It
has
to
do
everything
it
has
to
a
work.
Unit
is
kind
of
like
a
task
except
you
are
not
allowed
to
do.
K
I
owe
or
at
least
receive
on
Io
you're
not
allowed
to
send
or
receive
messages,
and
you
aren't
allowed
to
access
any
data
really
other
than
the
queue
data
or
the
work
data
it's
very
restricted
or
restrictive.
But
it
turns
out
that
that's
enough,
if
you're
going
to
have,
if
you're
going
to
paralyze
over
nodes
and
the
the
end
result
of
this,
is
that
actually
creating
these
things
and
then
queuing?
These
things
is
ridiculously
cheap.
K
K
We
enforce
them
so
the
rust
language,
so
the
rust
language
doesn't
know
anything
about
work
queues,
but
we
can.
We
use
the
rest
type
system
to
enforce
that
this
is
all
safe.
So
what
at
so?
What
we
actually
do
here
is
because
work
queue,
work
unit,
the
because
the
work
he
was
so
similar
to
the
task
scheduler.
We
actually
use
a
lot
of
the
guts
of
the
task
scheduler
in
the
work
you,
so
you
notice
that
we
have
this
thing:
the
standard
sink
deck.
K
K
The
the
core
of
the
scheduling
algorithm
is
in
rust,
actually
lives
in
this
library
called
standard
sink
deck
and
all
I
did
was
take
it
and
we
use
it
for
something
lighter
weight,
so
we
so
this
is
where
the
fact
that
the
surest
schedule
is
written
in
rust
is
really
really
helpful,
because
I
could
just
take
little
bits
of
it
and
that
I
didn't
want
to
use
the
whole
thing.
I
just
took
a
little
bits
of
it
and
then
read
it
and
then
wrote
my
own
scheduling
algorithm.
K
So
basically
how
you
use
this
thing
is:
if
you're
doing
your
own
parallel
data,
for
example,
say:
you're,
writing
a
game
and
you
might
have
like
you
know,
hundred
thousand
actors
in
your
game.
You
might
want
them
to
all
work
in
parallel
the
work,
the
work-
you
might
be
really
nice
for
you.
So
what
you
do
is
you
make
one
of
these
things?
K
And
one
important
thing
is
that
work
units
actually
receive
a
worker
proxy
reference
and
what
a
worker
proxy
reference
is.
Is
that
it's
an
object
where
you
can
actually
in
queue
worker
work
units
themselves
can
actually
push
new
units
of
work
on?
This
is
really
useful
in
layout,
because
you
have,
when
you
have
a
tree,
you,
you
start
out,
processing
the
parent.
You
started
processing
a
node,
and
then
you
push
all
of
its
children
on
as
work
units,
and
you
kind
of
fan
out
the
work
that
way
so
yeah.
K
This
is
basically
the
so
this
is
the
core
of
the
parallel
layout
algorithm
in
servo
and
now
for
a
fun
little
demo.
Hopefully
this
will
work.
I
can
show.
This
is
my
bill
from
today
and
show
wikipedia
rendering
up
off
the
screen.
This
is
actually
server,
rendering
rendering
Wikipedia
you
can
see
some
scroll
around
you
can.
There
are
some.
Obviously
there
are
some
bugs,
but
it's
basically
correct
we're
getting
we're
getting
farther
and
farther
and
yeah
so,
and
this
can
all
be
rendered
in
parallel,
oh
and
yeah.
K
I
F
K
J
K
Because
you
can't
be
as
lightweight
as
long
as
the
task
can
block
you're
already
like
that's
already
too
much
and
rust
tasks
are
really
lightweight
and
that's
great
I
mean
you
can
spawn
them
a
lot
faster
than
OS
threads
and
that
makes
them
really
nice
for
like
web
servers
for
web
servers.
You
may
want
to,
for
example,
spawn
a
new
new
task
for
every
incoming
connection.
K
That's
totally
what
they're
designed
for,
but
you
know
in
some
cases
that's
too
much
power,
the
the
ability
to
block
and
wait
and
suspend
your
state
and
then
come
back
to
do
it
to
come
back
to
it
later.
It's
like
what
makes
it
work
for
web
servers
like
you
can't
implement
a
web
server
without
doing
without
having
that.
K
D
K
What
I
don't
actually
enforce
that
they
don't
do
any
blocking
out
if
they
do
it'll
starve
other
work
units
yeah.
So
don't
do
that,
but
we
do
enforce.
We
do
enforce
memory
safety,
though,
like
they
can't
go
and
do
evil
things
like
race
on
each
other
and
that's
really
important
for
layout,
because
CSS
is
really
really
complicated
and
light.
K
I
think
what
Brendan
Eich
said
when,
like
the
when
this
project
started
like
trying
to
do
all
of
CSS
without
having
in
a
model
that
has
data
races
is
like
juggling
chainsaws
like,
especially
if
it's
not
even
memory
safe,
so,
like
I,
I,
really
think
the
only
reason
like
it
becomes
so
much
more
practical
to
implement
CSS.
If
the
language
yells
at
you,
whenever
you
tried
to
do
something
that
you
shouldn't
have
done.
Mm-Hmm.
F
K
Api
for
the
DOM
is
not
so
bad
because
basically
the
Dom
runs
in
a
separate
thread
from
layout.
The
tricky
thing
is
that
some
parts
of
CSS
are
really
hard
to
do
in
parallel.
Like
floats
not
talking
about
floating
point
I'm
talking
about
like
float,
left
float
right.
Those
those
are
really
hard
and
I
go
into
more
detail
on
my
blog
about
this,
but
they
are
really
yeah,
but
yeah
floats.
Our
floats
are
really
bad
for
parallelism,
clearing
closest,
really
good.
K
There
are
some
other
things
that
are
really
kind
of
weird,
like
absolute
tioning
in
some
cases,
but
one
of
the
things
we
found
is
that
a
lot
of
web
most
websites
are
actually
pretty
parallelizable.
The
I've
done.
There's
some
experiments
in
the
Alexa
top
50
and
found
that
a
lot
of
them
actually
are.
Most
of
them
are
parallelizable.
K
K
C
K
Yeah,
so
that's
a
really
good
question,
so
I've
done
I'm,
you
know
I've
done
a
lot
of
benchmarking
as
we
go
through
I.
Do
I
do
a
lot
of
benchmarking
against
existing
engines,
it's
very
hard
to
say
where
we
are
it's
very
hard
to
give
one
number
to
that
because,
like
you
know,
some
things
are
done.
Some
things
there
are
some
things
aren't
some
things
are
just
like
stub
implemented.
K
If
you
look
at
the
parts
that
we've
actually
optimized,
where
we're
really
good
in
many
cases
like
the
the
core
layout,
the
core
layout
in
most
cases
is
faster,
even
when
the
existing
engines,
even
when
you
limit
it
to
one
core
and
I,
don't
know
exactly
what
and
if
you
do
multi-core.
Obviously
it
becomes
faster,
still
and
I.
Don't
have
I,
don't
know
exactly
why.
That
is
some
of
that.
K
Maybe
just
some
of
that
may
be
just
the
rust
language
doesn't
use
virtual,
doesn't
like
virtual
methods
as
much
so
we
tend
not
to
write
virtual
methods
everywhere,
which
are
usually
slow.
Existing
engines
and
c
plus
I
mean
C++.
You
don't
have
to
write
virtual
methods,
but
it's
so
like
the
language
favors
it
so
much
that
people
use
virtual
methods,
a
lot
which
actually
leads
the
performance
issues.
I
think
that's
part
of
it.
Another
part
of
it
is
just
you
know.
K
So
you
know
you
never
know
whether
you
know
I
I
don't
want
to
sit
up
here
and,
like
quote
numbers
because
you
know
they
may
be
wrong
when
we
go
to
implement
more
of
CSS,
but
I
do
feel
pretty
good
about
it.
Selector
matching
is
a
selector
matching
is
also
an
area
that
we're
pretty
competitive
in,
in
most
cases
against
against
other
browser
engines.
The
I
mean
it's
selector
matching
also
paralyzes
very
well.
K
L
L
Right
so
my
name
is
Alex
I,
like
Patrick
I
work
here
on
Mozilla
on
rust
and
I'm
kind
of
working,
mostly
on
the
run
time
nowadays
and
kind
of
things
related
to
the
run
time,
and
today
I'm
going
to
talk
to
you
about
debugging
and
rust.
This
is
a
not
related
to
currently
bugging
I'm.
Sorry
about
that.
With
this,
this
is
more
more.
You
use
your
land,
debugging
kind
of
like
some
tools
that
I
that
I've
seen
you
can
use
kind
of
what
you
can
do
it.
L
Rust
is
a
compiled
language,
which
means
that
it's
kind
of
hard,
sometimes
it's
a
little
difficult
to
do
things
at
runtime
when
you
kind
of
you
have
some
state
and
you
don't
want
to
have
to
go
through
effort
or
recompiling
the
binary
and
you
kind
of
want
to
use
it
as
is,
but
you
still
want
to
instrument
it
at
runtime
and
typically
for
things
like
C
and
C++.
The
best
use
case
for
this
is
gb
or
elwood
V.
L
L
It's
as
easy
as
just
running
at
all
an
lod
be,
and
we
have
this
desk
g
flag
that
I
passed
as
our
debug
info
flag,
it's
the
same
as
GCC
and
clang
and
such,
but
it
basically
says
image
some
lots
of
debug
information.
So
I
can
get
some
nice
pretty
output
here,
which
you'll
see
so
the
first
thing
we're
going
to
do
is
we're
going
to
break
on
the
main
function
and
we're
going
to
kind
of
inspect
the
state
of
the
world
as
it
is
there.
L
So
when
we
run
it,
the
first
thing
we
hit
is
actually
the
sea
main
function.
You'll
see
up
here
that
it
broke
on
two
locations.
So
we're
going
to
continue
past
that
and
then
here
we
are
in
our
own
main
function,
which,
if
you
look
at
the
the
file
itself,
you'll
see
that
the
exact
source,
even
the
line
numbers,
are
all
in
lines
straight
in
right
there,
and
we
could
even
do
things
like
print
the
value
of
x
and
realize,
wait
a
minute
that
statement
hasn't
actually
run
yet
so
we'll
run
a
few
instructions.
L
Then
we
can
say:
let's
take
a
look
at
value
of
x.
Now
X
is
4
and
we
can
do
lots
of
fun
stuff.
After
this,
such
as
we
can
say,
let's
set
X,
2,
10
and
then
X
is
now
10.
We
can
print
X,
see
that
it's
10
and
Wade
want
to
run
the
whole
program.
We
just
altered
the
one
time
of
the
program
to
say,
for
fact,
or
instead
of
saying
calculate
for
factorial
was
it
calculates
10
factorial,
and
if
we
run
it
again,
we
can
see
that
it
actually
runs
and
prints
4
factorial.
L
So
this
is
kind
of
just
a
whirlwind.
What
you
can
do
like
what
you
would
expect
out
of
a
debugger
and
C
and
C++
you
can
pretty
much.
The
specs
might
expect
the
same
thing
out
of
rust.
Now
our
debug
info
is
really
good.
Today,
it's
it's
getting
even
better.
Every
day
we
have
a
contractor
working
on
it
right
now,
which
is
and
doing
lots
of
good
work
on
that.
L
So
some
other
stuff
you
can
do
with
lotv,
which
is
really
nice,
is
let's
say
we
have
this
a
big
function
where
we
just
kind
of
main
call
something
just
call
something
else.
We
just
kind
of
have
a
stack
trace.
What
you
want
to
kind
of
look
at
so
we'll
compile
a
program.
Will
click?
Ok
and
let's
say
we
want
to
break
on
on
the
function
foo,
which
is
here
at
the
top
of
the
stack
where
a
mains
just
calling
bar
and
bar
is
calling
foo.
So
what
does
break
on
foo
will
run?
L
The
function
will
see
that
we're
right
there
sitting
on
the
Foo
function.
We
can
kind
of
just
take
a
look
at
the
back
trees
and
the
great
thing
about
this
is
we
have
both
the
function
names
or
so.
This
is
the
the
binary
that
it
comes
from
the
name
of
the
function,
and
this
is
even
saying
the
file
that
it
was
found
in
and
the
line
that
it
was
found
on.
L
So
that's
kind
of
an
example
of
how
you
can
use
ldb
or
GTB
GTB
is
pretty
much
the
same
way
with
with
different
commands,
but
you
could
everything
you
would
expect
to
from
that
and
see
in
C++.
You
can
kind
of
get
the
same
thing
in
rust.
So,
let's,
like
it's,
take
a
look
at
another
one,
which
is
a
fun
bug
that
I
found
a
while
ago,
which
was
came
up
on
the
issue
tracker.
So
we
have
this
innocuous
program
where
all
it
does
is
a
bunch
of
times.
L
Let's
just
walk
around
this
directory,
where
walk
directories,
just
kind
of
recursively
go
through
and
give
me
paths
and
will
process
it,
and
currently
our
process
function
is:
let's
just
drop
it
and
I
worried
about
it.
So
we
run
it
and
it
works
just
fine
and
it's
it
actually
exits.
It
takes
a
little
bit
to
run,
but
we
get
some
reports.
Some
people
saying
that
it's
actually
leaking
memory.
L
So
we're
going
to
run
this
function
type
in
my
password,
and
we
can
see
that
this
is
a
graph
of
allocations
as
they're
going
on,
we
can
see
really
easily
there's,
probably
a
memory
leak
somewhere
in
this
program.
So
when
we
come
down
here,
we
can
say,
like
oh
ok,
looks
like
Libya
v's
doing
some
UV
FS
work,
which
you
probably
can't
read.
But
oh,
it
basically
means
that
we
found
a
memory
leak,
but
it's
not
in
rust
at
all.
This
is
actually
in
rust,
using
C
libraries.
L
So
we're
kind
of
we're
not
only
debugging
rest
right
now,
but
we're
actually
debugging
across
the
boundary
of
ruston,
see
and
we're
actually
debugging
other
code.
So
you
can
I
I.
This
is
when
I.
Let's
say
we
upstream
the
fix
to
Libby
V,
and
now
it's
all
compiler.
We
once
we've
recompiled
everything
we
can
take
another
look
at
the
memory
graph,
and
this
time
we
can
see
it's
a
nice
flat
line
where
we're
not
spiking
and
it
turns
out
when
this
finishes
we
don't
actually
have
any
leaks.
L
So
this
is
kind
of
an
example
of
this
is
a
native
program
which
has
0
alterations
to
want
run
with
rust
and
just
natively
can
figure
out
everything
and
it
can
just
work
help
you
find
bugs
find
memory.
Leaks,
OSX
has
other
things
like
time,
profilers
and
lots
of
other
fun
tools
in
there,
but
rust
code
and
binaries
kind
of
works
seamlessly
with
all
these
tools,
just
because
it's
a
native
code
generated
by
el
avión.
L
So
let's
take
a
look
at
another
one
which
is
added
very
recently,
actually
oops.
So
if
you
take
a
look
at
this
file,
it
looks
pretty
innocuous.
It's
kind
of
just
an
example
of
some
rust
code.
I
pulled
this
off
the
issue
tracker
because
it
has
some
fun
semantics
when
you
try
to
compile
it,
it
crashes.
Now
this
isn't
a
very
useful
error
message.
It
says:
I
call
option
unwrap
on
a
non
Valley.
Well,
that
could
be
anywhere
in
the
end
in
the
code
base.
If
you.
L
L
Print
out
back
traces
at
runtime,
so
what
I
just
did
is
I
set
an
environment
variable
saying
that
I
want
you
to
print
a
back
trace
when
you
fail,
and
now
we
can
say
we
going
to
have
to
use
LED,
be
we
don't
even
have
to
use
gdb.
We
have
native
support
now
on
the
center
library
to
print
back
traces
on
failure
well
on
task
failure.
So
here
we
can
see
that
this
unwrapped
function
was
probably
called
from.
L
This
check
match
is
useful,
specialized
on
quite
know
what
that
is,
but
that's
an
excellent
place
to
start.
So
we
you
don't.
This
is
generally
available
for
all
binaries.
So
if
we
take
a
look
at
this
example
right
here,
it's
just
a
couple
of
stacks
of
functions,
which
I
eventually
call
call
the
fail
function,
and
if
we
compile
it,
don't
even
need
a
debug
info
and
we
run
it
it'll
fail.
But
if
we
set
the
environment
variable,
we
get
a
nice
batteries
and
we
can
see
that
we
have
our
main
function.
L
Our
part,
our
bass,
function,
R
Bar
function
and
our
Foo
function.
Now
this
doesn't
quite
stand
up
to
optimizations.
If
you
it,
the
back
traces
are
all
done
at
runtime
with
lip
unwind
and
we're
special
things
in
windows.
So
if
you
do
the
same
thing
with
optimized
code,
it
actually
just
fails
right
on
the
main
function,
because
everything
was
in
line.
L
L
Let's
take
a
look
at
this,
so
we
have
another
bug
in
the
RUS
compiler,
which
looks
pretty
innocuous,
but
this
looks
like
a
trait
inheriting
from
itself,
which
sounds
like
a
stack
overflow
bug,
and
if
you
do
it,
you
do
indeed
get
a
stack
overflow,
and
this
is
just
also
showing.
So
if
you
want
to
debug
this
back
traces
are
kind
of
tough
to
print
on
Stack
Overflow,
because
you
have
lots
of
things
going
on,
but
this
is
another
case
where
you
can
just
use
L,
TV
and
figure
it
all
out.
L
It's
a
little
bit
more
difficult
though
so
this
is
something
the
I
just
ran
it
in
ella
debe
and
it
just
died.
So
let's
take
a
look
at
the
bass.
Tration
see
we
can
see,
but
it
turns
out.
We
don't
see
a
whole
lot.
We
see
this
Russ
stack,
exhausted
function
right
here,
but
that's
not
really
helping
us
a
whole
lot.
L
We
can
diagnose
the
stack
overflow
with
ella
debe,
just
kind
of
like
you
would
normally
see,
and
you
can
probably
pretty
easily
see
that
here
we
have
this
AST
column,
AST
path
and
then
up
here
we
see
probably
the
same
thing
as
we
as
we
go
further
down.
You
can
probably
quickly
find
the
cycle
and
quickly
debug
problems
like
this,
not
necessarily
in
the
rest
compiler,
but
in
kind
of
generic
roast
code
itself.
So
the
last
thing
I
want
to
show
you
that
valgrind
also
works
really
well
for
russ
code.
L
So
generally
russ
doesn't
have
memory,
many
memory
leaks
because
it
has
own
memory,
manage
memory
and
a
little.
It's
all
automatically
done
for
you,
but
a
lot
of
times,
you're
interfacing
with
a
c
library
and
you're,
not
necessarily
certain,
if
you're
using
the
c
library
correctly.
So
let's
take
a
look
at
this
little
test
application.
I
wrote.
We
have
some
library
next
to
us
which
just
has
an
initial,
is
e
initialization
function
and
then
you
can
print
some
stuff
inside
of
it
and
then
later
on,
you
want
to
free
any
resources
associated
with
that
object.
L
So-
and
this
is
just
some
small,
a
small
little
demo
thing
and
the
program
itself
looks
like
let's
initialize
it.
If
it
succeeded,
then
let's
print
it
and
let's
free
it
and
if
it
didn't
succeed,
then
we'll
just
print
out
that
nothing
actually
happened.
So
if
we
compile
this
and
then
run
the
program,
we
can
see.
Initialization
failed.
Well,
that's
expected!
Well,
it's!
It's
probably
pretty
normal
for
c4c
functions
to
fail
occasionally,
but
we
get
some
reports
that
this
is
actually
leaking
memory
and
we're
not
really
quite
sure
why.
L
So
we
can
actually
just
run
valgrind
on
it.
It
natively
and
if
you
take
a
look
at
it,
you'll
on
OS
X,
you
get
some
weird
false
positives
like
this
is
stuff
from
objective-c
initialization,
so
we're
just
going
to
suppress
these
errors.
This
is
a
special
Valgard
thing
which
you
can
say
like
don't
print
information
about
these
errors.
So
here
we
see
we
get
a
few
warnings
at
the
beginning.
That's
about
it
and
the
real
important
part
is:
we've
lost,
4
bytes
in
one
block.
L
This
means
that
we
have
a
memory
leak
of
4
bytes
in
our
program
and
if
you
take
a
look
at
the
rest
code,
doesn't
actually
look
like
there's
a
lot
going
on
here.
This
is
the
only
part
we're
actually
doing
things,
and
maybe
this
initialization
function
is
a
allocating
memory,
but
it
turns
out
that
if
you
take
a
look
at
the
c
library,
we
see
that
the
initialization
function
always
malik's
memory.
It
has
this
nice
little
comment,
saying
that
you
have
to
call
free
food,
no
matter
what
weather
initialization
succeeds
or
fails.
L
So
this
is
an
example
of
a
bug
which
I've
actually
run
to
run
into
many
many
times,
which
is
basically
you
can
in
writing
safe
c
bindings.
You
often
run
into
many
bugs
and
you
might
actually
use
a
c
library
incorrectly.
So
we
can
come
over
here
and
modify
this
function.
Take
this
free
statement
and
put
it
at
the
end,
just
because
it
said
that
I
should
always
run
the
fee
function,
so
we
can
recompile.
We
can
run
another
Val
grime
and
we
see
we
have.
We
have
lost
no
memory.
L
We
ended
up
reading
all
the
memory,
so
this
is
kind
of
basically
showing
that
Val
grind
as
a
tool
is
not
necessarily
like
the
usefulness
is
kind
of
degraded
from
C,
because
you
get
safety
by
default,
but
whenever
you're
interfacing
with
unsafe
libraries
are
unsafe
code,
this
is
a
fantastic
tool
still
and
it
works
just
perfectly
with
raw
all
rust
code,
because
they're
all
just
rust,
binaries
and
everything.
This
is
also
great
for
finding
data
races.
L
E
M
L
Maybe
it's
not
that
one,
but
yes,
I
I,
actually
not
entirely
certain.
Why
that
is
we
use
some
wees
live
online
to
base
like
to
do
the
unwinding,
which
kind
of
it
and
turn
uses
dwarf
info,
and
that's
something
that
I
think
I'll
have
to
look
into
try
and
fix,
because
I'm
not
entirely
certain.
Why
that's
happening.
L
Sure
so
the
question
was
whether
we
do
anything
special
foreclosures
in
terms
of
symbols
or
like
printing
out
the
back
traces
yeah.
So
we
closures
close
like
every
closure,
is
essentially
just
a
function
pointer
in
a
data
pointer
and
the
data
planner
is
kind
of
automatically
manage
for
you
like
it's
automatically
generated
at
compile
time,
so
the
the
function
pointer
actually
does
have
a
symbol
associated
with
it
and
it's
a
descriptive
symbol.
Let's
see,
I'll
show
you.
L
So
this
is
an
example
of
a
closure
symbol
which
needs
needs
a
little
bit
of
improvement
right
now.
But
what
that
should
look
like
is
RT
kollam,
kollam
task,
colon
colon
blah
blah
blah
Cohen
Cohen
closure,
so
they
don't
have
fantastic
names.
This
is
definitely
a
place
where,
where
we
can
improve
and
like
this
actually
ended
just
this
morning,
so
it's
quite
a
quite
new,
but
we
control
this
D
mangling.
So
the
symbols
actually
look
like
this
in
the
object
file.
L
They
have
this
ZN
and
these
numbers
inside
of
them
and
this
ease
at
the
end
so
we're
the
ones
that
control
how
we
translate
that
to
a
name.
So
we
can
definitely
add
some
nice,
some
nice
sugar
to
it.
The
the
general
idea,
though,
is
take
the
outer
function.
What
it's
in,
like
that
symbol
and
just
panicle
enclosure
and
then
some
sort
of
numbers
on
the
side
to
disambiguate
them.
J
L
L
L
So
the
question-
the
point
I
guess
was,
if
I
run
with
leak,
check,
equals
full-on
valgrind
it'll
actually
give
me
the
back
trace
of
where
the
leak
came
from
and
then
I
ran
it
with
the
the
correct
version.
Actually
so
didn't
help.
So
this
one
was
the
buggy
version
and
you
can
see
that
the
leak
actually
originated
from
this
in
it
foo
function,
which
was
exactly
where
it
was
supposed
to
come
from,
which
is
where
in
it
of
Mount
memory
and
it
didn't
for
you
or
then
I
forgot
to
free.
It.
A
All
right
thanks
everybody
for
a
great
talk.
This
was
really
fun
so
for
anyone
who
wants
to
talk
about
the
the
doc
goes
on
that's
happening
on
sunday.
If
you
want
just
meet
up
here
and
we
can
start
figuring
out
what
we
want
to
do
on
sunday,
but
for
the
rest
of
you
feel
free
to
hang
out
for
a
little
bit
and
mingle,
and
thanks
for
coming
have
a
good
night.