►
From YouTube: Statemaps in Rust
Description
An internal presentation to my fellow Joyent engineers about my work reimplementing statemaps in Rust (my first real work in Rust). Repository can be found at https://github.com/joyent/statemap/tree/rust
A
So
I
wanted
to
to
share
my
my
journey
into
rust,
which
I
know
some
of
you
have
been
I've
been
watching
or
participating
in
and
motivated
a
little
bit
explain
a
little
bit
history,
the
problem
that
I
was
seeking
to
solve
and
how
I
came
to
rust
to
take
a
swing
at
it
and
it
kind
of
the
journey
was
there
and
what
my
conclusions
are
so
far
so
and
some
of
the
things
that
I
really
liked
about
it.
The.
A
That
I,
like
rust,
a
lot
that
it's
been
really
honestly.
Terrific
I'm,
actually
kind
of
hard
pressed
to
talk
about
the
most
disappointing
things
with
go.
Thank,
You,
Josh,
I've,
been
hard-pressed
to
to
really
complement.
I
was
just
want
to
think
about.
Maybe
I
think
rights
from
a
little
bit
and
come
up
with
something
good
to
give
folks
at
history.
A
A
Like
this,
one's
I
show
a
little
Harbury,
because
it's
not
it's
sorted
by
entity
by
process
ID,
but
this
is
showing
you
Postgres
activity
over
time.
This
span
covers
60
seconds,
so
it's
not
very
much
time
and
the
each
one
of
these
lines
is
and
at
so
in
this
case
it's
a
process
and
if
I
click
on
this
I
can
get
some
information
about
what
process
that
is.
This
is
the
checkpoint
we
can
see
in
this
particular
example.
A
B
A
Are
a
bunch
of
example,
scripts
that
generate
the
kind
of
output
that
that
we
can
consume,
save
Maps
consume
them
so
that
one
in
particular,
is
this
struct
here.
So
this
is
a
neat
ray
script.
That's
a
little
unfortunate
because
it
is
generating
JSON,
which
just
gets
a
little
bit
ugly
from
D,
but
this
is
generating
a
JSON
payload
or
a
JSON
output
file
that
is
then
consumed.
It
can
be
consumed
by
this
program
called
same
apps,
which
generates
the
same.
This
values,
I
know
I,
know
I,
think
I'm.
A
The
only
person
on
the
planet
that
pronounces
the
mistakes.
I
know
everyone
proud.
If
you
put
out
some
SVG's-
and
you
are
now
thinking
like,
rather
than
pronouncing
them
incorrectly
my
whole
life.
That's
not
correct.
I
didn't
pronouncement
incorrectly
and
I'm
unable
to
change
myself.
So
don't
isolate
yourself.
The
way
I
have
isolated
myself
and
keep
announcing
them
SPG's.
But
to
me,
there's
things
on
I.
A
A
A
This
actual
program
here
so
we've
got
an
entire
program
that
that
is
able
to
process
its
input
file
and
then,
if
I,
scroll
further
down,
we'll
see
that
there
are.
This
is
like
a
bunch
of
rect
badness.
These
are
the
actual
wrecks
that
correspond
to
the
state
map,
and
then
it
knows
how
to
find
zoom
in,
for
example,
it
knows
how
to
change
the
the
mapping
effectively
to
zoom
in
on
this
image
really
efficiently
and.
A
A
So
this
is
the
the
raw
file
that
generated
the
the
state
map
that
that
I
just
showed
you.
So
this
is
a
its
concatenated
JSON
and
each
the
the
D
script
that
you
saw
generates
this
and
the
problem
that
I
was
seeking
to
solve
is
in
addition
to
actually
just
making
this
thing.
Originally,
this
was
done
as
one
might
do.
A
A
A
A
B
A
Being
if
you're
wondering
how
this
works,
there
is
a
there
has
to
be
some
glue
file
that
sits
between
the
C
and
the
JavaScript
and
is
basically
getting
us
across
this
kind
of
blood-brain
barrier.
Where
we're
dealing
with
a
bunch
of
gnarly
gross
c++
to
pull.
You
see
me
using
the
preprocessor
there
and
make
it
look
a
little
more
tenable,
but
we're
basically
pulling
data
out
of
C
and
getting
it
into
JavaScript
when
you
processed-
and
this
worked
a
lot
better-
it's
worked
a
lot
better,
so
we
saw
the
I
was
just
timing.
A
The
state
map
KS
on
this
file
took
1
minute
and
26
seconds,
and
if
we
go
to,
we
go
to
run
just
state
map
code,
which
this
is
the
the
JavaScript
C
hybrid
arm
and
the
if
I
run
that
what's
the
time
that
C
that's
good,
we'll
see
that
this
is
a
lot
better,
and
this
is
actually
one
of
the
things
that's
important.
It
should
be
a
lot
better,
be
a
lot
better.
You
should
be
better
there.
We
go.
Okay,
that's
a
lot
better!
A
So
11
minutes,
11
minutes
public
minutes,
12
seconds
versus
a
minute.
26
seconds,
that's
a
huge
speed
up
it's
you
know
obviously
backer
of
nuit
10
and
allowed
for
us
to
iterate
much
more
quickly
and
was
much
better
and
use
much
less
DRAM
and
so
and
I
could
run
it
on
on
multi,
gig
input
files
and
so
on.
A
But
it
was
really
painful
to
implement
and
say
it
just
took
a
long
time
to
get
right
and
not
sure.
I
think
that
you
there
were
kind
of
the
traditional
perceptions
of
C.
Are
that
it
takes
a
long
time
to
get
right
because
of
memory
safety
issues
or
what
have
you
it's
like?
Oh,
no,
one
knows
how
to
like
malloc
and
free
malloc
and
free
is
not
really
the
problem.
It's
like
malloc
and
free
is
actually
pretty
straightforward.
I
know
how
to
write
a
program
without
Grandpa
data
corruption.
That
is
like.
That's
that's
pretty
easy.
A
The
problem
with
C
is
several
fold.
One
you
are
just.
You
are
at
subtle
level
from
a
memory
perspective
that
it's
very
hard
to
actually
compose
systems
out
of
libraries.
So
there's
not
there.
The
libraries
for
C
tend
to
be
very
framework
e.
So
if
you
first
have
a
library
to
parse
JSON
like
I,
want
to
parse
JSON
and
see
how
I
mean
truly,
there's
got
to
be
some
good
library
for
parsing,
JSON
and
C,
and
the
answer
is
like
not.
A
The
ones
that
are
very
complete
are
super
frame
working
where
it
takes
control
kind
of
calls
into
you,
and
not
very
fast,
on
a
slave
which,
like
what
the
hell
am
I
doing
this
for
it's
not
very
fast
in
my
case,
I,
want
to
it's
very
important
that
we
am
map
this
file
map
the
file
and
then
parse
the
JSON
out
of
the
memory
map,
so
that
was
just
not
really
compatible
with
a
bunch
of
JSON
parsers,
which
one
people
that
read
the
file
for
themselves.
What.
B
A
Up
using
was
something
that
was
great,
that
I
love
called
Jasmine
Jasmine
I
can
show
you
all
Jasmine
gem
jasmine
is
super
minimal
done
by
some
kind
of
nice,
nutty
Russian
dude.
Let's
see
here,
that's
the
license.
That's
Jeff
and
let's
see
so.
This
is
like
this
is
all
of
this
JSON
parser
and
it
is
what
it's
314
types
of
code.
Oh,
my
god,
it's
so
minimal.
It
is
very,
very,
very
minimal,
very,
very
bare-bones.
A
Be
like
I,
don't
have
a
free
memory,
more
of
just
the
actual
mechanics
of
using
something
that
was
so
low
level,
so
that
was
kind
of
a
pain
in
the
butt
and
then,
when
you
see
big
things,
but
is
that
now
I
want
to
actually
manipulate
this
thing
and
I
want
to
use
modern
constructs
to
do
it.
I
want
to
throw
things
into
hash
maps
and
kind
of
you
know,
flip
them
around
and
and
iterate
over
them,
and
so
on.
Where.
A
As
much
where
I
care
about
the
performance
a
great
great
deal
in
this
hot
loop,
where
we're
processing
records,
but
once
we're
done,
I,
don't
care
about
performance
as
much
because
we've
reduced
and
the
reasons
that
to
keep
a
limited
explanation
is
we
reduce
the
input
set
a
lot,
so
we've
got
an
input
set,
that's
basically
arbitrarily
bounded
arbitrary
unbounded,
rather
and
as
we're
processing
that
we're
gonna
we
are.
We
are
processing
these
state
transitions
that
form
rectangles
in
from
a
visual
sense
of
states.
A
As
we
process
those
rectangles,
we
are
going
to
coalesce
rectangles
into
into
coalesced
eight.
So,
if
I
look
at
the
show,
this
visually
so
I
look
at,
for
example,
the
state
right
here,
this
state
is
actually
a
cola.
God
only
knows
how
many
states
we
didn't
be
interesting
to
rerun
the
state
map
and
learn
how
many
states
are
in
this
one
transition
which
is
51%
off
CP.
You
do
to
sum
up,
but
god
only
knows
what
it
is
doing,
the
rest
of
the
time
and
actually,
let's
must
actually
just
to
show
that.
A
A
A
A
So
this
is
the
same
actual
data,
even
though
you
can
see
it
looks
really
different.
This
is
the
same
period
of
time,
but
this
is
what
happens
when
you
don't
call
us
away
all
those
states,
so
you
can
see
that
now,
a
bunch
of
things
are
actually
leaping
out
at
us
that
we
might
not
have
seen
earlier,
and
you
can
see
that
there's
actually
a
lot
more
going
on,
but
the
when
we
process
this
thing.
A
The
way
we
read
this
fig
from
being
200,
megabytes
or
more
is
that
we
are
constantly
coalescing
these
rectangles
away
and
we
are
creating
much
less
data.
That
represents
many
more
states
all
right,
so
that
is
kind
of
the
overview
of
the
state
map
problem,
the
problems
we'll
see
or
that
it
was
hard
to
add
new
features.
It's
hard
to
add
new
features,
because
anytime
I
wanted
to
add
something.
A
Performance
gonna
strike,
so
what
I'd
like
to
do
is
have
this
all
in
one
language
that
can
be
super
fast,
but
also
very
flexible,
and
that
kind
of
naturally
brought
out
rust.
So
rust
is
a
really
interesting
language.
This
is
not
going
to
be
necessarily
an
introduction
to
rust.
I
want
to
give
you
just
a
somewhat
of
a
whirlwind
of
some
of
the
things
that
I've
run
into
and
show
you
some
of
the
rust
that
that
I've
written
and
some
of
the
things
that
I
kind
of
discovered
along
the
way.
A
A
To
the
my
main
off
here,
so
you
can
see
this
is
Rosco
right
here
in
this
right
window.
Actually,
both
these
windows
are
rust
and
it
it
looks
a
lot
like
it's
very
C
ish
which,
to
me
the
aesthetics,
I've,
got
kind
of
a
very
see
aesthetics
to
them,
which
I
sort
they
appreciate.
One
thing
just
to
get
it
out
of
the
way
is
one
space.
A
The
I
did
not
want
to
be
a
prisoner
to
my
own
opinions
on
white
space,
so
I
wanted
to
just
adopt
whatever
the
prevailing
white
space
was
in
trust
and
the
the
prevailing
white
space
is
for
space
tabs
and
not
using
hard
tap
so
soft
tabs
with
force
base
tabs.
So
fine,
my
C
and
JavaScript
will
will
remain
hard.
Tabs
I'm,
still
a
hard
tab,
purest
respect
to
see,
but
I
will
definitely
dot.
A
The
prevailing
style
here,
which
me
ends
up
being
very
readable
and
I,
would
actually
not
want
to
do
hard
tabs
for
rust,
because
you
end
up
creating
scopes
a
lot
and
you
end
up
a
little
bit
deeper
than
you
are
and
see,
with
with
less
cognitive
load.
I
mean
I'm,
always
believe
part
of
the
reason
I
believed
in
80,
columns
of
our
tabs
for
city
or
its
base
tab
for
C
I
guess.
A
I
have
always
believed
that
if
you
are
six
or
seven
Scouts
in
NC,
it
is
definitely
time
to
refactor
in
rust.
That
ends
up
being
less
the
case,
because
you
end
up
creating
scopes.
So
it's
it's
a
little
more
reasonable
to
be
further
over
I
still
believe
in
80
columns
and
I
find
that
that
my
rust
has
ended
up
being
pretty
readable
to
my
eye.
So,
let's
see
a
couple
of
things
here
and
I
might
explain
everything,
but
some
things
that
that
are
are
interesting
and
let's
actually
go
to
where
we
open
a
file.
A
A
Okay,
so
this
is
the
actual
core
of
the
the
state
map
ingestion
loop
and
so
a
couple
of
things
that
actually
merit
attention.
One
is
this
use
of
the
word
unsafe.
This
is
the
only
unsafe,
you're
gonna
find
anywhere
in
here,
but
rust
does
allow
you
to
break
out
of
the
constraints
that
it
places
on
you
and
become
unsafe.
Should
you
so
desire?
We
are
being
unsafe
here,
because
we
are
actually
going
to
to
M
map
the
file.
So
we
are
gonna,
create
a
giant
piece
of
memory
that
rust
doesn't
know
about
so
or
rust.
A
Is
that
you
can't
deal
it
safely,
but
so
that's
the
the
unsafe.
They
don't
really
talk
about
that.
But
what
do
you
notice
is
that
we
are
so.
This
is
all
this
code
that
is
stabbing
the
file.
It's
opening
the
file,
it's
a
mapping
the
file,
and
then
it's
telling
you
you
need
utf-8
and
cranking
something
I
love
about
rust.
That
is
not
prominently
featured
is
this
code
is
all
robust
with
respect
to
error
checking,
even
though
it
really
doesn't
look
like
it.
If.
A
On
the
file,
but
what
happens
if
that
fails?
Well,
if
that
fails
the
so
when
you
open
a
file,
it
will
return.
This
file
object
that
you
can
a
file
structure
that
you
can
manipulate,
but
actually
doesn't
return
a
file
structure
when
it
actually
returns
to
you
is
a
result
and
a
result
is
one
of
these
algebraic
types.
You
can
see
the
results
up
here.
The
open,
paren
close
paren
is
the
that's
a
rust
notion
of
void.
So
instead
of
return
void,
you
you
return.
A
What
so,
what
you
get
back
is
is
one
of
these
two
things:
it's
either
an
error,
or
it's
this
underlying
payload,
and
you
can't
just
use
it
if
it's
as,
if
you
you
need
to
actually
determine
which
one
of
these
things
it
is
before
you
actually
use
it.
I'll
see
if
I
can
find
an
example
of
go
to
my
site.
A
See
if
I
can
find
an
example
of
where
we
are
there,
we
go
so
here's
an
example
of
where
we
are
on
the
from
string
radix,
which
is
saying
that
I'm
gonna
specify
the
right
exit,
specify
that
is
16
the
I'm
gonna
pull.
This
is
a
point
RGB
value
from
a
color.
That
also
does
not
return.
You
can't
just
use
that
result.
A
You
have
to
first
determine
if
it's
okay,
that
is
to
say,
if
it's,
if
it
is
not
the
error
type,
but
rather
the
okay
type,
then
I
can
actually
unwrap
it
and
actually
get
to
its
underlying
type.
So
in
that
so
this
is
all
I
mean
very
clearly
documented.
This
is
actually
one
of
the
since
I
have
invited
the
internet
to
code
review
my
rust
and
point
out
a
better
way
to
do
it.
A
This
line
is
actually
one
of
the
ones
that
there's
a
there
is
a
less
verbose
way
to
actually
do
exactly
what
this
is
doing,
which
is
probably
a
better
way
of
doing
it.
This
is
not
necessarily
a
great
way
of
doing
it,
but
this
is
it's
very
explicit
and
then
it's
showing
you
what
it's
doing
and
you
one
of
these
you'll
see
a
lot.
A
Is
these
unwraps
in
rust
and
an
unwrap
says:
hey
I
know
that
this
is
an
actual
value
and
not
an
error,
so
give
me
the
value
of
whatever
this
is
whether
it's
an
option
or
a
result,
option
types
and
result,
types,
the
ones
that
you
see
a
lot
of.
If
you
do,
if
you
call
unwrap-
and
it's
not
actually
a
thing,
if
it's
a
nun
for
an
option
or
if
it's
an
error
for
a
result,
your
program
will
die,
you
will
panic.
A
A
Operation
for
the
program
and
the
program
you
do,
we
does
it's
very
interesting
kind
of
watch
the
discussion
as
it
evolved
over
time
about
whether
a
rust
program
should
die
when
it
encounters
this
programmatic
error.
We
of
course
believe
strongly
that
this
is
a
programmatic
result.
The
program
death
and
it's
very
easy
interesting
to
see
that
the
rust
community
probably
shares
that
that
view.
A
Operator
very,
very
important
in
rust.
You
can
use
it
again
and
again
again
and
what
I'm
saying
is
I
want
to
change
my
behavior.
It's
a
switch
statement
based
on
what
type
this
is,
and
if
it's
okay
and
that's
a
file,
then
I
am
going
to
want
to
say
you
know
the
you
know
that
we
can
now
process
the
file
or
or
assign
to
a
variable
or
whatever
it's
an
error.
A
A
Doing
this,
like
all
this,
because
anytime,
you
call
something
we
are
matching
to
see
what
it
is
and
if
it's
something
that
is
legit,
you
want
to
look
at
it
and
if
it's
an
error,
we
want
to
propagate
now.
I
one
point
is
I
love
the
fact
that
this
is
the
way
to
deal
with
errors
that
you
don't
have
you
look
like
I'll
give
the
light.
I
mean
how
the
languages
deal
with
us,
so
language
like
C++
and
Java,
we'll
toss
an
exception
on
and
I,
don't
like
exceptions,
because
they
allow
you
to
write
code.
A
A
I
have
never
liked
exceptions,
I,
don't
like
them
in
JavaScript
I
to
me,
exceptions
are
the
equivalent
of
like
a
single
long
jump
in
or
a
long
jump
in
C,
and
we
don't
use
long
jump
and
see
for
a
lot
of
reasons,
so
don't
like
exceptions
so
how
to
see
deal
with
this
well
C
deals
with
this
by
we're.
Turning
me,
you're
gonna
put
how
whatever
the
he
does
he's
gonna
turn
you
a
return
value
and
you
are
gonna,
determine
if
that's
the
air
condition
or
not
the
way.
A
We've
done
that
with
that
is
generally
generally.
Zero
means
success
and
negative
one
means
failure.
Sometimes
zero
means
failure
and
one
being
success.
Sometimes
zero
means
success
and
any
negative
value
means
failure.
Sometimes
any
value
greater
than
or
equal
to
zero
means
success
and
only
negative
one
means
failure.
Sometimes
any
value
greater
than
or
equal
to
zero
means
success
and
any
negative
value
denotes
the
air
condition
that
you've
actually
encountered.
That's
for
a
common
limits,
for
example,
so.
A
It
I
mean
surprise,
surprise
it's
just
then
it
leads
to
error-prone
code
that
leads
to
code.
That
is
not
doing
the
right
thing.
We
tend
to
be
very
rigorous
by
our
convention.
We
tend
to
operate
on
handles
of
things.
So
when
you
use
one
of
our
libraries
and
if
you're
a
library
that's
attendant
as
we
would
write
it
and
hope
he
is,
you
would
write
it
and,
as
God
would
write
it,
it
is
I'm.
Gonna
have
a
mumble
create
operation
that
is
going
to
return
to
me
a
hailed
over
this
thing.
B
A
That
enforces
that
you
could
do
the
wrong
thing.
You
could
ask
the
wrong
way:
you
could.
There
are
lots
of
ways
you
can
handle
it
correctly.
Russ
really
forces
you
to
do
with
us
I,
it
says,
look
and
it
on
soda
Doh
says:
I'm
gonna
return,
two
things
to
you.
This
will
be,
and-
and
these
won't
both
be
true-
because
you've
done
work
out
to
correct
me
if
I'm
wrong,
but
the
island
can.
A
B
A
The
the
but
it's
got
this
effectively,
this
other
channel
for
returning
an
error
to
you
that
you
can
ignore
I,
mean
III.
Think
it's
somewhat
hilarious
and
sad
to
me
that
go
that
go
will
not
allow
you
to
have
an
import
which
you
are
not
using,
which
seems
to
me
to
be
a
very
like
a
total
misdemeanor
infraction
like
I'm.
A
Problem
doing
with
it's
like
wow,
you
delete
that
import.
It's
like
really
like.
You
can't
just
like
import
that
code
and
not
use
it
like
that's.
That
is
a
stop.
The
presses
I
can't
proceed,
but
not
using
the
return.
Value
from
a
function
goes
again.
It's
like
that's,
not
cool
at
all.
I
bet
sizes.
So
the
you
really
can't
do
that.
You
can't
say
well,
I'm
only
gonna
treat
them
like
this
success.
A
You
use
a
lot
options,
so
results
are
are
generally
where
you're
going
to
have
operational
errors
or
operational
issues
options
you
would
use
if
you're
effectively
saying
this
value
can
be
a
value
or
it
can
be
no
value
at
all,
I
mean
it's
it's
an
outright
type.
That
includes
none
or
some,
and
that
is
really
powerful,
because
god
there's
so
much
code
that
we
have
that
I
have.
A
That
is
this
value,
is
it
can
be
set
or
not
so
I'm
going
to
use
a
central
value
to
know
o
0
the
note
sunset
or
negative
London
sunset
or
if
all
values
are
valid
values?
For
this
thing,
I'm
going
to
have
some
other
values.
As
you
know,
this
thing
has
this
thing
by
the
way
or
I've
got
a
bit
field.
That
says
what
this
value,
that
the
valid
values
valid
and
it's
just
like
arrow
to
problematic
rust
deals
without
really
cleanly.
So
one
thing,
you'll
see
a
lot.
A
A
A
Written
a
lot
of
go
or
like
I
never
want
to
write
with
this.
You
know
this
particular
code
that
you
were
just
writing
again
and
again
and
again
and
again
again
and
that's
air
bro,
that's
error-prone.
It
means
there's
a
lot.
You
need
to
modify
if
you're
repacking
the
source
base
and
so
on
in
effects
readability.
So
there
you
don't
want
to
be
overly
loquacious
on.
A
So
what
what
Rustin,
which
I
think
is
really
beautiful,
is
they
have
this
propagation
operator
versus
this
question
mark
and
the
propagation
operator
is
saying:
hey,
look,
you're,
calling
something
that
returns
our
result
in
a
few
years.
I'll
return
a
result,
and
you
call
this
thing
with
this
propagation
operator.
With
this
question
mark
what
it's
saying
is:
hey
I'm,
just
going
to
like
deal
with
all
that
boil
plate
for
you.
If
this
thing
returns,
okay,
I'm
gonna,
unwrap
it
for
you
and
I'm
gonna
put
it
over
here.
A
A
Out
I
think
I
mean
I,
really
really
really
like
this,
because
it
allows
you
to
have
this
code.
That
is
like
totally
correct.
That
is,
that
is
not.
That
is
not
error-prone
that
is
dealing
with,
that
is,
that
is
propagating
errors
totally
properly
properly
and
yet
still
reads
very
concisely,
and
if
I
were
to
do
delete
one
of
these
question
marks,
we
would
not
compile
and
it
would
not
compile,
because
I
would
now
be
taking
a
result
and
trying
to
use
it
as
something
that's
not
a
result.
So
enough.
A
Was
expecting
you
to
use
a
file
and
I
found
a
result
instead,
so
what's
going
on
there
and
once
the
dinner
is
like
oh
crap,
I
don't
but
I
was
integrating
this
or
whatever
I
forgot.
The
question
mark
Swayze
to
see.
What's
going
on,
one
thing
with
the
compiler
I
find
that
the
compiler
generates
incredibly
useful
error
messages.
A
I
think
that,
because
they've
been
rust
has
been
so
burned
by
the
fights
that
people
have
with
the
compiler
for
good
reason
and
we'll
get
into
those
fights
in
a
second
that
the
when
they
can,
they
can
power
goes
way
out
of
its
way.
I
mean
like
this
I
love
the
fact
that
it's
like
it
underlines
things
for
you.
You.
A
One
thing
that
is
funny,
though,
is
if,
in
a
macro
you
delete
a
closed
paren.
You
can
get
the
compiler
to
its
money
on
you
and
it
will
just
generate,
like
thousands
of
errors
that
you
didn't
have
before
it
can
be
very
confusing,
but
in
general
I
find
that
the
compiler
generates
rugged
error
messages,
sorry
I
eat.
This
was
my
and
maybe
now's
a
good
time
to
talk
about
kind
of
how
I
got
in
rust
in
terms
of
like
I
wanted
to
live
in
rust.
A
A
Got
in
the
program
rust,
so
this
is
the
one
I
believe.
Yes,
the
bass,
a
systems,
development
I
think
this
book
was
great.
I
think
it
is
great.
The
I
would
definitely
recommend
this.
The
the
rust
programming
language
is
also
a
very
good
book.
That
is
the
one
that
also
just
came
out
so
just
published
in
December.
A
The
compiler
complain
clean
that
up
figure
out
what
I
done
wrong
and
begin
to
get
a
feel
for
what
was
happening
without
just
I
think
that,
with
with
other
programming
languages,
you
know
once
you've
learned
a
couple.
The
concepts
aren't
new,
so
you
just
go
kind
of
like
you
pick
up
a
new
programming
language,
I
kind
of
stack
overflow
on
your
way
into
existence.
That
is
the
wrong
thing
to
do
with
rust.
The
the
I
don't
think
the
learning
curve
for
us
is
that
steep,
but.
A
Not
a
like
I
just
like
banging
on
keyboard
curve,
and
if
you
stack
overflow
yourself,
you're
coming
out,
hurt
yourself
it.
You
really
want
to
start
from
first
principles
from
a
work
example
and
I.
Think
it's
not
that
bad
I
think
it
rust
in
in
many
ways
like
the
fear
or
the
learning
curve
is
very
healthy
because
it
forces
you
to
actually
sit
down
and
learn
it,
which
has
been
been
great
for
me
anyway,
I've
been
funded.
A
A
A
A
This
open
price,
close
price
syntax
and
it's
really
cool
because
it
it
gives
you
like
full
you
see
if
I
can
find
a
show
you
a
couple
of
things,
one
if
you
just
do
open,
brace,
close
brace
on
a
print
line,
which
is
also
turns
into
a
format
bang
on
that
will
call
effectively
the
two
string
operation.
It
executes
that
the
string
trait
on
whatever
you're
calling
and.
A
You're
gonna
get
it
won't
actually
compile.
If
you
don't
have
one
of
those
trades,
so
that's
very
useful.
The
other
thing
that
is
really
useful
is
you
can
have
a
if
I,
if
I
were
to
turn
this
into
a
colon
question.
Mark
that
says,
I
want
you
to
get
the
debug
output
for
this
structure.
Debug
is
that
is
a
trait
that
you
can
implement.
A
Think
I've
got
a
couple
examples
of
that,
but
the
you
get
a
nice
version
of
the
the
structure
which
is
great,
very,
very
helpful
for
recruiting,
so
the
macros
I
like
the
macros,
because
one
of
the
things
if
you've
been
in
any
of
my
code,
you
know
that
all
of
my
C
command
line
stuff
tends
to
have
a
fatal.
You
know
if
you're
in
a
command,
that's
got
fatal
as
a
verb
as
a
function.
A
Var,
arts,
I
love
using
the
C
preprocessor
Ross,
gives
me
a
much
more
stable
way,
a
hygienic
way
of
doing
exactly
that
so
I
I
got
my
own
I
was
able
to
do
very
quickly,
my
own
little
fatal
macro
and
my
fatal
macro
just
I,
and
this
is
like
definitely
something
I
was
pulling
off
of
the
video
Stack
Overflow.
But
what
I'm
actually
using
is
is
the
underlying
macros
to
do
this,
but
I'm
preparing
just
my
command
name
there
and
the
macro
rules
for
rust
are
its
own
world.
Rastas
got
really
powerful.
A
Macros
I
am
definitely
a
total
novice
at
them,
but
I
am
inspired
because
one
of
the
things
I
reflect
on
my
own
see.
I
use
the
preprocessor
a
lot
and,
and
there
are
so
many
ways
you
know
when
you're,
when
you're
young
and
you're
starting
out
and
say
you're
the
the
preprocessor
is
I.
It
is
a
little
like
having
unsafe
sex.
Suppose
you
are
not
parents
on
the
you
really.
A
None
of
you
are
if
you're
not
married,
please
practice
safe
sex,
but
you
will
learn
that
with
that,
when
you
were
married,
you
can
actually
you
know
any
of
these
things
and
you
want
to
actually
have
kids.
Then
then
the
whole.
This
is
a
terrible,
terrible
metaphor.
I
should
this
is
what
I
easily
learned
a
part
of
my
brain
just
woke
up?
Are
you
be
seriously
using,
but
the
anyway,
when
you
get
older,
you
understand
love.
You
move
right
along
the.
A
Ii's,
the
preprocessor
a
lot
and
I
use
it
safely,
and
it
makes
my
see
a
lot
clearer,
but
I
would
love
to
have
more
net
in
place
when
I'm
using
the
preprocessor
and
there's
nobody
way
to
get
that
with
CPP
and
they've
been
vivid,
some
things
that
add
features
to
it,
but
you
can't
reliably
use
them.
Ross
takes
us
to
a
whole
new
level.
It
allows
you
to
do
some
really
really
cool
things
like
I'm,
pretty
sure
use
the
JSON
macro.
I
don't
need
to
do
some
black
er.
B
A
Really
useful
I
didn't
use
it
here.
It's
very
useful.
The
also
rust
has
this
our
syntax,
the
our
octave
or
syntax,
or
are
actually
I.
Call
that
a
pound
son
could
even
recall
that
you
put
it
all
you
caught
write
a
hash
and
Tobin
calls
it
a
hash
tag.
So,
if
you're
reading
that
my
son,
my
my
13
year
old,
would
call
that,
oh
that's
our
hashtag
hashtag,
it's
like
that,
maybe
was
just
caught.
No
one
calls
it
NACA
Thorpe,
so
it
just
called
an
octave.
A
Fourth,
it
is
not
important,
but
that
our
pound
sign
syntax
denotes
a
raw
string
literal,
which
is
something
that
I
definitely
miss
very
badly
se
and
missing
JavaScript
as
well,
for
the
lack
of
here
docs
are
I'm
sure.
Yes,
whatever
has
your
dog's
no,
but
it
did
back
in
the
day
it
was
a
real
impediment.
A
This
is
another
example
of
macro.
This
back
bang
macro
he's
declaring
the
vector
on,
and
this
is
a
good
example
of
something
I
really
love
about
rust,
where
rust
is
very
type
safe
and
in
all
the
good
ways,
and
yet
is
very
permissive
in
all
of
the
right
ways
it
you
know,
I
would
like
to
think
of
us
as
like.
A
We
are
principled,
but
laid-back
and
I
feel
like
that's
what
process
Russ's
principle,
but
laid-back
so
Russ
is
gonna,
be
up
in
your
grill
at
the
right
time,
be
like
no,
you
can't
is
I,
don't
know
what
type
that
is,
but
rust
will
also
infer
types
where
it
can.
So
when
you
declare
something
like
with
this
black
colors
equals
I,
don't
have
to
say
what
type
it
is.
Rustic
I
will
figure
out
what
type
is
and
now.
B
A
A
A
The
way
you
know
which
member
of
tuple-
and
these
are
super
useful
for
each
that
you're
getting
some
of
that
lack
of
structure
that
isn't
actually
because
you
don't
want,
like
super
rigid
structure
all
the
time-
and
you
know
this
is
a
good
example
where
it's
like
I,
actually
don't
want
to
have
to
declare
this
classic
problem
and
see
where
in
see,
if
I
wanted.
This
construct,
I
would
be
using
the
structure
and
Happy's.
A
Nice
I
find
I
use
two
poles
all
the
time
in
rust
and
just
for
those
little
strux
that
you
need,
where
you
know,
you're
calling
to
a
function
or
from
a
function
or
what-have-you
without
having
to
like
really
be
overly
rigid
about
it.
Let's
see
so
the
and
I
won't
go
on
absolutely
forever
here,
but
there
are
much
things
if
you
actually
want
to
talk
about
talk
about
raw
string
literals.
Those
are
great
another
thing
that
in
actually
you
can
see
it
here
that
I
got
a
love
about
rust
and
I.
A
The
knives
so
disappointing
this
thing,
this
pound
sign,
Open
bracket
test
close
bracket,
denotes
that
this
code
is
conditionally
compiled
when
you
are
running
cargo
in
its
test
mode,
which
prove
cargo
is
the
package
manager
for
rust.
Cargo
was
really
nice.
I
think
you
know.
One
of
the
things
that
can
come
in
you
were
saying
is
I
got
into
rust.
I
came
here
just
to
hear
you
think
what
cargo
box
I
think
cargo
is
pretty
great.
Cargo
is
great,
it
is.
It
is
really
nice.
A
It
seems
to
actually
learned
from
all
these
package
manager
systems
that
are
coming
in
front
of
it.
It's
a
package
minister
and
a
building
system
effectively,
but
the
so
it
gives
you
that
great
power,
but
the
thing
I
would
also
say
is
that
the
you
can
just
use
rust,
see
which
is
the
compiler
I
without
using
cargo.
So
one
of
the
things
that
I
that
I
should
have
done
earlier.
I
wish
the
folks
would
make
a
little
bit
clearer.
Is
that
because
you
can't
use
rusty
on
its
own?
A
B
A
When
you
run
cargo
in
the
test
mode
and
I'm
gonna
run
the
cargo
test
right
now.
What
its
gonna
do
is
combine
compiled
things
in
all
the
test
code
is
going
to
be
compiled
in
and
then
it's
going
to
execute
the
test,
so
it
so.
This
trim
multi
end.
For
example,
it
knows
that
this
is
a
test
to
run
and
it
ran,
try
multi
and
if
I
want
to
actually
I
want
to
get
more
information
about
that.
So
I
want
to
actually
I,
don't
want
you
to
capture
the
standard
output.
A
A
Is
that
that
print
:
question
mark
output
as
a
format
modifier
we're
seeing
that
debug
output?
It
is
really
nice
to
have
your
test
code
and
I
mean
I
know,
like
I
mean,
did
you
and
I
have
been
around
the
media?
We
are,
if
you
are
running
like
the
more
a
test,
suite
I
think
inherits
the
lineage
of
see
a
test
which
comes
from
a
high
test
which
comes
to
the
fish
works
test
suite
which
comes
from
Detroit
of
Goodland
D
test,
which
is
a
stupid
program.
A
A
That's
pretty
great,
so
in
the
way
you
it
knows
which
testifying
by
the
way
is
you
give
it
a
test
module,
and
then
you,
you
drop
the
tests
in
here.
So
it
knows.
Okay,
these
are
the
tests
that
are
available.
You
do
pattern
match
on
these
things.
You
do
all
sorts
of
these
things,
give
you
all
sorts
of
things,
but
just
in
general,
it's
really
nice.
It's
very
shrink
to
fit
I
found
that
to
be
really
really
valuable.
A
So
rust,
use
with
memory
in
a
really
novel
fashion
on
rust
is
trying
to
hit
a
sweet
spot
between
explicit
memory
management
and
yet
still
giving
composability
not
having
to
have
these
kind
of
explicit
contracts
commit
or
a
post
contracts
really
between
everything
and
the
way
it
does.
This
is
with
an
idea
of
ownership
and
so
for
any
given
data.
In
rust,
there
is
effectively
an
owner
to
that
and
there
can't
be
two
owners.
A
A
I
think
it
kind
of
should
because
you're
often
lending
as
much
as
your
are
knowing
where
you
are
allowing
a
you,
are
effectively
allowing
a
function
to
to
mutate
something
and
then
you're
taking
it
back
after
it's
done.
It
is
a
very
important
concept
on
it.
It
makes
a
couple
of
things
challenging
one
of
the
things
that
it
makes
excruciating
are
data
structures
that
have
implicitly
or
explicitly
have
dadums
data
that
have
multiple
owners
and
on
doubly-linked
link.
B
A
A
A
Fundamentally,
what
we
need
to
do
is
you've
got
a
limit
on
the
number
of
rectangles,
so
we're
going
to
have.
So
if
we
have
a
new
state
come
in
we're
processing
the
next
data,
it
represents
a
new
state
transition.
We
need
to
take
some
of
these
existing
rectangles
I
know
all
these
rectangles
are
gonna,
be
in
this
thing.
I
need
to
find
two
of
them
that
are
adjacent
and
I
need
to
call
us
them
so
which
rectangles
do
I
call
us
and
how
do
I
keep
the?
A
A
Header
file
and
see
this
was
really
straightforward,
because
I
have
an
entity
and
if
he
is
like
a
process
in
that
sense-
and
it's
got,
you
know,
I'm
keeping
track
of
the
next
empathy
and
the
next
empathy
on
the
hash-table
entities.
So
a
little
bit
of
C
is
when
he
got
elected
that
stuff
yourself
and
then
it
gets,
got
a
length
list
of
rectangles
and
the
rectangles
are
here,
and
this
is
something
we
do
a
lot
in
C
this
isn't.
A
A
A
With
embedded
nodes,
I
think
just
crazy
easy
to
do
it
easy
to
do
it
reliably.
It's
fast
now,
I'm
like
I,
want
I
need
to
do
the
same
thing
in
rust.
Rust
did
not
want
to
do
this
because
there's
multiple
zones,
multiple
ownership
issues-
and
you
can
get
around
this
with
things
like
these
ref
cells
and
the
there
are
ways
to
do
things
that
are
going
to
have
multiple
owners,
but
they
are
all
gnarly
and
it
was
just
getting.
A
I
was
going
into
a
deeper
and
deeper
and
deeper
rabbit,
hole
and
I'm
like
I
need
that
I've
got
a
stop
and
what
I
need
to
do
is
I
need
to
focus
on
I'm,
trying
to
solve
a
performance
problem
that
I
don't
know
for
certain
that
I
have
and
my
goal
with
the
rust
implementation
is
not
to
outperform
the
same.
My
belief
is
that
the
C
is
going
to
be
faster,
because
the
C
is
like
it's
kind
of
speed
of
light,
so
what
it's
doing
I,
don't
think
it's
gonna
be
faster
than
the
C.
A
A
A
Days
or
longer
to
come
to
that
realization
that
I
actually
just
need
to
get
some
work.
So
how
do
you
put
the
latest
in
rust
without
actually
employment
that
wait
list
well,
I'm
sure
there
are
many
many
many
ways
to
do
it
I'm
sure
the
Intendant
can
tell
me
many
more,
but
the
way
that
I
did.
This
is
a
little
bit
funky
for
a
given
entity.
A
It
can
only
give
identity
and
it's
started.
This
start
time
of
that
state
is
unique.
There's
only
one
of
those
for
all
the
input
data
so
by
an
entity
he
can't
transition
into
States
at
the
save
me
in
a
second
all
set.
So
we
can
view
that
entity
timestamp
repair
as
a
unique
ID
that
we
can
use
to
actually
straight
things
together.
So
what
I
do-
and
you
can
see
me
do
it
here-
is
the
previous
pointer-
is
not
a
pointer.
A
A
Is
a
hash
table,
so
if
you
want
to
get
to
the
previous
one,
you're
gonna
you're,
going
to
take
this
value
and
gonna,
look
it
up
in
hash
table.
You
want
to
get
the
next
one
here.
Look
at
that!
It's
like
really
gonna
be
swell
because
we
are
instead
of
just
doing
a
dereference.
We
are
having
to
do
a
hash
lookout,
but
that's
I'm!
Thinking
about
it!
Like
you
know,
the
hash
table
exploitations
got
to
be
optimized
for
a
64-bit
value,
so
this
won't
be
so
slow,
then
alright.
A
So
then
how
do
you
deal
with
the
tree?
And
this
is
where
you
got
to
get
like
again,
if
you
need
to
like
when
rust
is
telling
you
that
it
doesn't
want
you
to
do
something,
a
certain
way.
Definitely
listen
to
it.
Am
I
okay,
the
compiler,
you
don't
want
me
to
do
it
this
way
and
I'm
like
I,
keep
trying
to
find.
A
You
keep
I,
keep
creating
new
problems
for
myself
around.
You
can't
deal
with
this
movie
because
I
moved
it
over
here
or
like
I.
You
can't
have
a
reference
to
this
mood
right
now,
because
it's
already
part
or
whatever,
like
okay
I,
need
to
like
find
a
different
way
to
do
this,
and
in
this
case,
what
it
is
like.
A
The
tree
of
these
things
is
totally
separate
from
the
rectangles
rectangles
over
here
and
then
in
the
the
state
map
has
got
this
by
wait
tree
which
keeps
track
of
these
things
by
weights
and
then,
when
I
add
a
rectangle,
if
it
says
hey,
okay,
here's
what
I
want
you
to
add
to
this
rectangle
tree
or
I.
Think
you,
if
you
subsume
two
rectangles
here's
how
I
want
you
to
modify
this
tree
of
weights?
It
ended
up
being
like
a
little.
A
A
Just
doing
some
kind
of
very
casual
profiling
friend,
it's
fun
all
that's
trying
to
rebalancing
that
tree
and
of
course
it
does,
but
it's
not
a
lot
of
pointer
casing.
There
think
a
lot
of
that
be
in
the
cache,
but
this
is
the
bee
tree
set,
is
actually
using
a
bee
tree.
Instead
of
a
set
of
an
AVL
tree
red-black
tree
you
can
make
the
argument.
That's
gonna
bet.
A
Gonna
be
curious,
listen
now.
The
one
benchmarking
I
had
done
is
with
Suri
Suri,
which
stands
for
sterilizing.
Deserializing
is
an
amazing
crate.
So
crates
are
the
rust
libraries
and
Sirte.
Does
this
really
cool
thing
where
it
basically
will
generate
code
for
you
for
your
types
on
the
fly
that
is
totally
safe?
So
what
this
code
does
this?
Let
metadata
equals.
So
this
state
I'm
saying
this
is
state
map
implemented
a
and
I
need
to
say
to
tyke,
because
Saturday
Jason
from
strain
needs
to
know
the
type.
A
So
it
knows
what
straight,
what
type
to
go
to
so
I
gotta
give
it
some
type
information.
That's
what
that
does
there
that's
pulling
the
string
out
of
the
payload
and
then
this,
like
bundle
of
magic,
will
populate
one
of
these
things
or
give
me
an
error.
So
this
has
got
a
it's
got
a
start.
That's
a
vector
array
in
the
JSON.
The
titles
of
string
post
does
not
need
to
be
there
and
decline
does
not
need
to
be
there.
That's
an
optional
string
and
then
states
is
a
is
a
JavaScript
object,
so.
B
A
It
with
alarming
speed
so
when
I
first
benchmark
this,
just
the
JSON
parsing
I
first
did
it
just
with
cargo.
Build
anima
and
I
ran
out
is
not
fast
at
all
this
morning.
Well,
on
me,
okay,
I'm
running
just
like
the
debug
build
I
should
just
run
it
with
the
like
the
release.
That
will
give
you
an
optimized
version.
Maybe
that
will
improve
things.
The
difference
between
just
building
it
and
release
is
first
of
all
it
took
instead
of
building
it
in
two
seconds
it
took
twenty
five
seconds
to
compile
it's
like
wow.
A
It
knows
that
I'm
going
to
call
this
function
and
I
know
that
this
memory
that
I
loaded
this
thing
this
function
can
not
possibly
screw
this
value,
so
I
can
leave
it
in
register
or
I,
don't
need
to
reload
it,
and
so
there
are
lots
of
ways
and
clearly
I'm
gonna,
be
curious
to
like
get
into
the
details
of
what
they're
basically
doing
some
great
authorizations.
So
they
perform
like
a
bandit
for.
B
B
B
A
A
B
A
Fact
you
can
pretty
reasonably
argue
that
I
have
gone
out
of
my
way
to
make
it
slower
and
we
are
40%
faster
than
my
C,
which
I
did
set
that
one,
and
you
didn't
mean
there
are
a
bunch
of
reasonable
inferences
from
that.
I
should
be
embarrassed
about
my
see,
I'm.
A
little
embarrassed
even
though,
like
that
C
is
a
pretty
good,
C,
I.
Think
and
I.
Don't
think
it's
leaning
a
lot
on
the
table
there.
But
on
that
was
shocking
for
smaller
state
maps.
B
A
So
lean,
there
is
no
real
runtime
to
rust.
It
is
everything
is
being
done
at
compile
them
on,
and
the
there's
nothing
behind
the
back
kind
of
managing
things,
and
you
know
one
things:
I
love
about
C
is
I,
can
feel
the
underlying
assembly,
with
rust,
I
feel
like
I
can
feel
the
underlying
C
I
feel
like
I
can
feel
like
what
the
scene
would
look
like,
underneath
us
on
and
I
instead
that
same
kind
of
intuitive
feel
to
it.
A
I've
been
amazed
actually
how
quickly
I
got
to
the
point
that
I
was
writing,
like
thirty
and
forty
lines
of
rust
at
a
time,
without
compiling
wait
for
a
new
programming,
language
is
actually
like
that
to
me,
I
thought
that
was
pretty
great
I
mean
that
it
would
normally
I
would
be
like
taking
these
baby
steps
and
compiling
being
selves
at
the
problem,
but
really
quickly.
I
found
that
I
was
writing
it
quickly,
because
I
had
a
good
intuition
for
it,
and
I
had
an
intuition
for
what
it
meant
and
what
it
wanted.
I
understood.
B
A
A
There
are
you
know
it's
very
kind
of
like
Maki
Foley,
in
terms
of
which
is
fine.
It's
good,
very
iterator.
Happy
there
are
only
there
are
things
that
you
can
almost
always
do
with
fewer
law.
It's
a
trust.
I,
definitely
question
some
of
these
things.
It's
like
I'm,
making
a
fast
or
not
I,
think
there's
gonna
be
a
lot
of
like
actually
taking
a
stopwatch
to
things
to
makes
it
to
see
if
things
are
making
it
faster
or
not.
People.
B
A
A
A
So
say
you
can't
receive
any
questions
over
here,
but
so
far
I
said
it's
been
great.
I
mean
it's
been
so
good
that
I
am
I
struggle
to
come
up
with
the
biggest
negative
and
I,
don't
know
which
software
I
won't
use
rust,
for
there
are
some
things
for
which
it
is
a
total
home
run
any
CLI
tool.
It's
a
rust
would
be
absolutely
the
first
place.
I'd
go
it's
just
it's
really
fast
intuitive
for
that.
A
Mike
has
spent
more
time
with
the
the
FFI
I
said
no
time
that
have
I
and
what
do
I,
not
that
I'm
not
on
the
wasa
done
nothing
with
with
FF
I
I
understand
that
is,
that
is
historically
a
real
strength
of
rust
and
people
have
raved
about
it.
It's
definitely
been
a
giant
pain
in
the
ass
for
us
with
node
like
an
unaccepted,
yes
about.
A
It
was
eight
years
ago
is
very
dispiriting,
more
difficult.
We
it's
so
I
love
that
I'm.
Looking
forward
to
that
hum.
Do
anything
with
that.
I
haven't
done
anything
we've
kind
of
run
time,
debugging
ability,
so
how
do
I
make
sense
of
a
raw
score
file?
How
did
it
make
sense
of
symbols
all
that
stuff?
That's
all
in
kind
of
the
TBD
bucket
from
its
disposition.
I
can
already
say
this
is
gonna,
be
easier
than
JavaScript
I
mean
given
what
we
did
with
JavaScript.
A
A
A
It's
to
the
point
where
I
would
strongly
encourage
people
to
take
a
really
serious
look
because
I
think
it's
for
me.
This
is
I.
Just
don't
know
what
would
have
to
happen
at
this
point
for
this
not
to
be
kind
of
the
next
programming
language
rather
than
I.
Don't
know
that
I'm
gonna
bring
a
mutt
seed,
particular
in
rust,
I.
Don't
really
have
any
desire
to
like
the
reimplemented
ZFS
in
rust,
for.
A
May
have
political
first
or
Gator
the,
but
adding
drivers
and
rust
doesn't
seem
to
be
that's
a
maybe
only
a
maybe
doing
a
new
COI
utility
and
rust
is
a
definite
doing.
If
we
had
to
do.
You
know
when
josh
was
doing
the
the
binder
front
in
see
the
that
would
be
a
natural
for
us
three
of
many
more
a
in
would
be
a
natural
for
us.
A
A
A
I
mean,
with
all
the
caveat,
that
I'm
still
a
noob
and
all
this
stuff
I'm
not
doing
Russ
for
very
long.
A
bunch
of
you've
done
languages
that
have
algebraic
types
much
more
than
I
have
so
I
think
that
a
bunch
of
you
will
pick
it
up
faster
or
better
than
I
did
yeah
concurrency
internees,
a
great
question
on
so
somewhat
famously
or
infamously.
Rust
originally
had
the
end
scheduling
model
with
lightweight
threads
screen
codes,
which
was
a
very
dispiriting
when
I.
A
Like
another,
they
can't
actually
learn
from
the
past,
most
interestingly
Ross
ripped
it
out
and
they
went
through
a
straight
native
model.
So
the
the
threading
model
is
a
is
a
very
c
model.
You
could
do
you
create
threads
and
those
threads
go
to
work
because
of
the
ownership
model.
It's
much
easier
to
make
things
scale,
because
there's
so
much
it's
already
not
shared
because
you're
only
you
are
running
single
dragon
code
and
rust.
You
are
almost
lining
up
the
multi-threaded
parts,
your
brain.
A
The
right
thing,
the
first
place,
all
that
said,
I
have
no
name
yet
so,
but
its
traditional
mutex
model
try.
You
can
see
commercial
synchronization
primitive
with
a
native
threat
model,
Patrick,
actually
the
intrusive
collage
in
collections.
That
did
it's
also,
if
that
didn't
pan
out
it's
more
than
I
realized
that
that
was
just
going.
A
B
A
You
know
our
CSR,
the
ref
counted
pointers.
You
know
end
it
with
our
with
ref
cells
that
are
themselves
our
seed
or
a
our
seed,
which
are
telegraphic.
My
ref
can
pointers
and
it
just
the
code
looks
god-awful
and
you
begin
to
question
life
choices.
So
that's
part
of
the
reason
why
I
kind
of
went
half
way
down
a
path
I'm,
like
god,.
B
A
Out
how
to
make
it
faster
cool
all
right,
rayon
I
did
not
check
out
rayon
at
all.
Let's
go
look
at
that.
The
yeah
and
I
think
this
is
why
I
think
we're
you
need
a
doubly-linked
list.
Maybe
it's
where
the
thingy
kind
of
even
rethink
the
approach
or
look
back
at
way.
Trust
does
so
vex
and
the
implementation
of
vector
is
the
implementation
of
B
trees.
The
implementation
of
hash
tables
all
use
unsafe
primitives.
So
basically
these
things
are
unsafe.
So
you
don't
have
to
mean
you
can
write
on.
A
A
A
And
probably
be
us
at
some
level
for
some
things,
but
and
again,
I
would
not
I
would
not
endeavor
to
rewrite
any
parts.
The
operating
system
or
really
rewrite
any
functional
software
I
actually
got
I
got
held
back
a
little
bit
by
the
fact.
I
was
rewriting
honestly,
like
I,
actually
did
better
and
was
moving
faster
when
I
stopped
trying
to
rewrite
what
I
had
and
started
getting.
The
motive
like
I
had
to
solve
the
problem
using
lost
so
for
certain
degree,
rewriting
things
and
rust
is
almost
a
recipe
for
from
war
pain.
A
A
A
A
A
plenty
more
a
in
rust
and
how
you
do
a
back
pressure,
how
you
deal
with
those
kind
of
cues
where
you
guys
work
use
effectively
and
how
you
properly,
probably
a
back
pressure.
How
you
deal
with
the
kind
of
the
operational
errors
that
those
things
have
that's
going
to
be.
How
we
deal
with
the
fact,
because
one
failure
mode
for
us
programs,
surely
will
be
that
they
grown
up
and
how
did.
A
A
B
A
What
the
state
of
the
art
in
post
mortem,
rusty
buggy
is,
if
I'm,
if
we
were
to
go
tackle
that
problem
I,
would
probably
not
do
it
as
an
MDB
diamond
I
would
do
that
as
a
rust
program.
That
is
still
are
there
for
rust
programs
that
no
excited
about
post
mortem
in
is
able
to
take
a
core
file
and
actually
process
it,
which
something
they'll
be.
Is
it
good.
A
Arnie
doesn't
exist
and
I
think
yeah
I
think
even
using
gdb
and
LD
be,
which
may
mean
some
opportunity
right
all
right.
Maybe
there
you
go
all
the
DB
is
a
bit
disappointing.
I
mean
it's
great,
a
good
part
to
Lumos,
but
it
is,
it
is
disappointing.
Ld
be
I,
think
the
first
time
I
use
LD,
be
in
court
on
puppy,
which
is
the
what
gdb
good
deal
I
want
to
cored
out
from
a
debugger
on
1gb.
A
A
A
Been
great
I've
enjoyed
it,
hopefully
I'm,
not
too
much
Hogan
I
have
been
too
annoying
in
this
whole
process
probably
happen.
I'm
sorry
that
I
know
will
will
probably
continue
as
I
need
to
do
it.
Yeah
I
think
we
should
get
West
I.
Think
getting
Russel
Ephraim
would
be
a
great
next
question
right
next
thing
to
go,
do
and
get
across
this
part
of
the
build
process
and
I
mean
it's.
Obviously
you
know
not
easy.
There's
a
challenge
there,
but
huge
thanks
to
Jonathan
got
the
modern
rust
available.
A
It
was
a
lot
of
work
to
get
it
available
on
the
platform
.,
but
getting
it
in
the
platform
would
be
a
great
next
step,
not
to
get
power
but
just
being
able,
like
add
a
add,
a
new
utility
to
the
platform
that
is
a
russ
program,
would
be
great
and
to
critic
stuff
and
clearly
that's
gonna,
be
thankless,
difficult
work,
but
I
think
it's
gonna
be
worthwhile
to
go.
Do
it?
Maybe
this
that's!
What
I'll
go
do
next.