►
From YouTube: RustConf 2019 - From Electron, to Wasm, to Rust (Aaand Back to Electron) by Iryna Shestak
Description
RustConf 2019 - From Electron, to Wasm, to Rust (Aaand Back to Electron) by Iryna Shestak
So you heard you can run WebAssembly in the browser, but what does this look like IRL? Seeking the much talked about performance benefits of running WASM in the browser, Compass (GUI for MongoDB) took the great leap forward and rewrote part of the application – a schema parser responsible for document analysis – in Rust. As it turns out, the rumours are true, I repeat the rumours are true: offloading parts of your application to Rust makes it fast, and in some of our cases, heaps fast.
In this talk I will cover converting a part of an codebase from JavaScript to Rust, bringing it to Electron, adding WASM to an existing React app, and deploying this whole lot to production. As Compass still talks to MongoDB via Node.js, I will also cover how we used Rust to improve performance without losing data integrity. This talk is about a success story, but also about a bunch of smol mishaps, fun woopses and lil' dead ends we encountered and how we managed to overcome along the way.
A
This
talk
is
about
something
I've
built
and
I
was
able
to
put
into
an
electron
aka
the
browser,
application
and
I've
been
able
to
put
it
to
production
and
the
stories
about
how
I
did
it
and
all
the
things
that
did
not
go
so
well
and
all
the
things
that
went
really
well
and
all
the
things
in
between
so
I
hope.
You're
gonna
enjoy
this
little
story
all
right.
So
this
is
the
application
I
work
on.
It's
called
compass,
it's
a
GUI
for
MongoDB.
A
It
lets
you
kind
of
look
into
your
collections
into
your
documents
and
aggregate
a
few
things
and
do
everything
in
between.
So
you
don't
have
to
use
the
shell.
This
particular
tab
is
the
tab
that
has
a
back-end
that
analyzes
a
schema
and
that's
the
tab
that
Ivy
wrote
in
rest
and
compiled
down
to
azimuth
and
the
performance
improvements
that
I
got
out
of.
A
Hi,
I'm,
marina,
I,
write
JavaScript
and
the
rest
I
guess
now
at
MongoDB.
I
started
writing
rest
about
eight
months
ago
and
I've
been
writing
JavaScript
before
then
yeah.
So
you
might
also
know
me
from
my
jeans.
My
works
include
my
works
include
the
the
JavaScript
event
boobs
scene,
that
I've
recently
done
for
queer
jeaious
in
Berlin
I've
also
done
a
treat
scene
for
Russ
fest
in
Rome.
I've
also
made
a
rest
acing
zine
for
this
conference.
A
A
I
currently
live
in
Berlin,
though
a
little
bit
further
away,
so
I'm
I've,
been
here,
I've,
been
in
Portland
for
about
six
days
and
I'm,
still
very
jet-lagged,
but
that's
another
story.
I
also
have
two
cats,
this
one's,
oh,
you
might
have
seen
her
already
she's,
very
good
she's,
a
really
good
cat,
that's
jeshu
and
the
other
cats
naughty
and
she's,
also
like
a
really
good
cat
that
goes
for
walks.
That's
naughty,
the
two
of
them
together
yeah.
A
So
that
was
a
brief
interlude
and
now
we're
back
to
rest
and
awesome
if
that
was
a
good
interlude,
so
it
kind
of
like
another
brief
thing
before
the
stock.
This
stuff
comes
from
a
point
of
view
of
a
JavaScript
developer.
Writing
rest.
I
will
focus
mostly
on
wasum
I'll.
Do
like
a
little
bit
of
a
rest
thing,
but
you're
a
bus
developer,
so
I
I
I'm,
not
gonna
like
teach
you,
but
for
us
cuz
I
be
talking
down
so
yeah,
so
this
is
kind
of
the
thing
of
a
taco.
A
We've
got
a
bit
of
an
agenda
that
we'll
go
through,
so
this
not
a
class
but
a
little
bit
of
a
class.
So
we'll
talk
a
little
bit
about
how
scheme
analysis
happens
and
compass
aka.
The
application
I
work
on
I
will
go
through
a
little
bit
of
that
and
how
that
happens
and
kind
of
what
are
the
requirements
of
how
the
rest
portion
of
things
will
progress,
we'll
talk
about?
A
Maybe
they
did
we'll
talk
about
all
the
three
whether
or
not
they
got
the
bull
of
tonkatsu
or
not.
So
we'll
start
with
this
schema
analysis
in
compass
as
I
showed
you,
the
tap
kind
of
looks
like
this
and
what
it
does
is
it
helps
us
look
into
a
collection.
It
queries
some
documents
from
the
collection.
It
doesn't
do
the
whole
thing,
but
it
queries
some
of
them
and
analyzes
them
to
basically
help
users
to
detect
outliers
in
their
applications.
A
A
A
There's
a
bunch
of
it's
only
about
21
of
them,
so,
as
you
can
tell
from
here,
so
it's
not
too
many,
so
pretty
small
schema,
but
what
the
schema
tab
does
is.
It
looks
into
it
and
then
analyzes
it
there's
a
bunch
of
different
information
that
you
can
get
because
the
sample
is
so
small.
We
don't
we
don't.
A
We
just
go
through
the
entire
collection,
that's
under
a
thousand
documents,
and
then
we
can
tell
what
the
data
kind
of
looks
like
so
in
this
particular
field
house,
No
Mas,
so
the
house
number
it
comes
in
two
different
kind
of
types.
So
there
is
an
integer
32
type
and
a
double
type
which
probably
shouldn't
be
there,
but
I
don't
know
who
inserted
it
for
the
purpose
of
a
demo,
but
they
did.
A
You
can
kind
of
look
into
and
see
what
the
data
looks
like.
There's
also
map
you
can
work
with,
but
again
kind
of
gives
you
an
overview
of
what
your
data
is
like
and
then
you
can
work
with
it
pretty
well
and
kind
of
give
you
some
insights
as
to
what
to
do
with
it
later.
You
can
also
analyze
based
on
particular
aspects
of
that,
so
we
kind
of
just
selected
a
document.
That's
in
this
postal
code
range
code,
size
postal
code,
there's
only
one
and
it's
mr.
Susan,
that's
a
good
one.
A
A
So
it
kind
of
works
like
that,
but
the
portion
that
does
the
schema
looks
into
two
different
things.
It
works
with
a
collection
sample
that
samples
the
collection
and
looks
for
a
bit
thousand
documents,
and
then
there
is
a
schema,
parser
and
MongoDB
schema
is
that
parser
and
what
it
does?
Is
it
analyzes
the
database
kind
of
works
like
that,
so
first
you
sample,
and
then
you
pass
it
on
to
the
parser
and
get
all
that
accumulated
data
about
the
thing
in
JavaScript.
A
First,
we
get
a
connect
to
the
MongoDB
client.
Then
we
sample,
and
then
we
pipe
it's
a
stream
in
JavaScript
and
parse
it,
and
we
get
it
a
little
bit
of
accumulated
data
back.
That
we'll
have
to
then
replicate
it
in
rust,
and
what
this
data
looks
like
is
that
it's
a
accumulation
of
all
the
fields
and
the
information
about
them.
So,
for
example,
we
get
like
a
little
count
saying
how
many
fields
we
got
in
that
particular
field
type,
which
is
website,
and
then
we
can
get
like
a
total
count.
A
A
The
reason
why
we're
writing
it
in
rust
is
because
we
can
only
function
with
about
a
thousand
documents
at
a
time
and
as
soon
as
we
want
to
increase,
or
we
want
to
give
a
better
view
of
the
collections
to
people
who
use
this
thing,
it
gets
further
slow.
So,
if
we're
looking
for
something
a
little
bit
more
and
we
want
to
do
like
a
progressive
collection
scan
or
we
want
to
again
just
sample
more
than
a
thousand
documents,
it
gets
really
really
slow.
A
So
the
example
for
this
is,
if
you
want
to
parse
a
pretty
nested
set
of
documents,
a
pretty
nest
collection.
10,000
documents
takes
a
really
long
period
of
time,
and
so
we
want
to
optimize
somehow
and
we
want
to
not
like
get
a
bunch
of
JIRA
tickets,
saying
the
thing
is
slow,
so
there's
a
bunch
of
different
ways
that,
like
we
can
go
about
optimizing
it.
A
A
Maybe
that
could
do
that
for
you,
but
I
guess
at
that
point
would
just
rather
be
writing.
Rust
and
I
mean
there's
a
bunch
of
like
Dark
Arts
with
the
v8
one
can
perform
and
also
get
a
bunch
of
speed
up.
But
again
you
don't
particularly
need
to
do
the
Dark,
Arts
and
a
bunch
of
really
smart
people
actually
we're
at
this
parser
and
it's
already
very
well
written.
So
what
else
can
we
do?
A
And
you
know
a
good
mother,
there's
a
metal
more
attractive,
the
webassembly,
and
so
we
kind
of
thought
about
this
and
a
lot
of
different.
You
know
there's
blogs
about
how
good
it
is
and
what
there's
blogs
about
how
fast
it
is,
and
all
these
things
that
are
kind
of
interesting
about
it.
So
we
thought
that
maybe
we
can
also
do
the
wazoo
and
write
the
parser
in
wasum
and
actually
speed
it
up
that
way.
It
gets
us
an
opportunity
to
be
able
to
kind
of
explore
a
new
domain.
A
It
gets
as
an
opportunity
to
speed
something
up
that
without
does
about
performing
the
dark
arts
and
just
trying
something
else
out.
So
what's
wazza-wazoo
is
a
low-level
assembly
language
that
compiles
down
to
something
else
it
compiles
down
from
something
else
in
the
case
that
we've
chosen
it's
rest,
it
looks
if
you
look
into
the
network
tab.
It
looks
like
this
rather
actually
pretty
good
art.
A
A
But
if
we
look
down
into
like
even
a
larger
sample,
it
speeds
up
even
more,
which
is
pretty
darn
fast,
and
so
we
like
to
delay
and
the
essential
thing
that
it
lets
us
do
is
be
able
to
have
native
code
in
the
browser
and
obviously
does
the
job
that
it's
meant
to
do,
and
we
did
not
have
to
kind
of
go
out
of
our
way
to
make
it
fast.
It
just
kind
of
came
with
the
rust
thing,
which
is
cool
right.
A
A
A
However
many
documents
it
needs,
it'll
talk
to
the
database.
The
database
will
return
a
bunch
of
documents
that
we've
sampled
and
then
we'll
want
to
talk
to
the
rest
and
the
rest
will
then
compile
them
to
the
wisdom
and
the
wisdom
will
then
talk
to
compass
and
then
compass
will
talk
to
the
wasum
and
there
was
and
will
talk
to
us.
A
It's
a
lot
of
communication
going
on
it's
a
very
like
very
chemi,
communicative
set
of
tools
that
we've
ended
up
here
and
so
the
rest
TL
DR
is
actually
just
here
as
a
little
brief
story
of
the
number
of
things
that
did
not
work
out
as
a
person,
who's,
never
written
a
rest
like
language.
It's
a
story
of
quite
a
few
errors
and
there's
like
a
lot
of
them
like
so
many
of
them,
and
there
was
a
lot
of
existential
googling
along
the
way
as
well.
A
But
it
turned
out:
well,
it's
a
happy
story
and
I
think
one
of
the
reasons
why
it's
a
happy
story
is
because
rust
came
with
a
bunch
of
help
that
you
don't
usually
just
come
built-in
in
in
JavaScript
and
there's
quite
a
few
characters
that
are
just
there
and
they're
there
and
happy
to
help
you
alright,
so
how
this
works,
we'll
skip
the
bottom
part
for
a
moment.
Combis
wants
to
talk
to
rest.
A
Russ
wants
to
talk
to
compass,
and
all
we
wanted
to
do
is
Russ
needs
to
accept
a
bunch
of
documents
that
come
through
needs
to
parse.
The
documents
accumulate
the
information
and
send
the
camila
cumulative
info
back
and
to
kind
of
get
this
to
work.
The
first
thing
that
I
thought
I
would
do
is
just
start
with
a
string,
because
string
is
the
easiest
thing
to
understand
and
that's
the
type
that's
so
easy
to
work
with.
So
we
started
off
with
just
writing
a
string
and
returning
a
string
and
I
think
that
worked
rather
well.
A
The
compiler
was
really
happy
I
liked
it
a
lot.
There
is
some
art
in
between
that
I
received
BAM,
but
overall
good,
good,
good
story,
so
we
were
accepting
a
string,
but
the
one
thing
we
then
kind
of
thought
of
is
that
well
we're
working
with
a
MongoDB
set
of
documents,
which
means
we
were
working
was
something
called
beefs
on
my
name.
You
know
beasts
on,
oh
good,
okay,
I,
wasn't
sure
I
just
in
case,
but
if
in
case
you
don't
know,
we
want
to
do
the
same
thing.
A
It
just
has
to
be
in
beasts
on
and
I
like
this
definition
in
case
you've.
Lots
of
you
know
basically
same
thing
as
JSON
comes
with
the
way
to
pronounce
it
this
definition,
but
it
comes
with
same
as
JSON
just
has
a
few
different
types
that
would
have
to
handle
differently
like
decimal,
128
or
minimax
keys
or
bin
data,
and
things
like
that.
So
just
have
to
work
with
that,
but
fortunately
there's
already
a
crate
that
Zoey
II
to
have
written
for
us
that
we
just
used
and
it
worked
really
nicely.
A
The
only
thing
you
have
to
do
is
we
still
accept
a
string
for
now,
but
just
convert
it
into
a
piece
on
document
and
then
able
to
extract
all
the
appropriate
information.
That's
not
just
a
string
out
of
that
and
then
work
with
it,
which
is
really
cool.
So
then
that
gets
us
to
like
the
number
situation
is
like
another
struggle
of
a
JavaScript
developer
in
rust.
This
is
the
only
number
type
available
in
JavaScript.
It's
very
good.
This
is
the
number
types
available
in
rustic.
A
So
as
a
JavaScript
developer,
when
you
get
into
this,
it's
influenced
a
bit
confusing.
So
picking
a
number
type
was
a
bit
of
a
challenge
for
a
JavaScript
developer.
Invest
I
only
have
we
needed
like
two
fields,
but
I
spend
like
a
lot
of
time
debating
on
what
numbers
to
choose
and
to
the
point
where,
like
I
made
a
flow
chart,
what
number
should
I
choose
to
be
able
to
do
this
properly
and
so
I
have
all
these
numbers
that
you
know
I
had
to
choose
from
I
actually
just
went
with
Hugh,
sighs.
A
Cool
and
then
the
next
set
of
things
that
was
like
errors.
How
do
you
date?
Errors
can
I
just
do
a
type
errand
and
be
okay
with
it,
and
then
I
I
was
reading
a
bunch
of
stuff,
and
everybody
said
you
have
to
do
this
and
it
seems
like
a
lot,
and
so
I
was
kind
of
thought
about
this
and
then
I
found
a
crate
and
the
crate
was
really
good.
So,
instead
of
having
to
write
all
of
that,
I
just
did
this,
and
that
was
great
I
kind
of
liked.
A
This
part
of
rest
that
was
good,
so
yeah
it
just
converted.
Everything
from
family
error,
I
could
use
the
question
mark
operator
and
Rob
has
to
be
there.
I,
don't
ask
questions
it's
just
in
that
particular
way.
It
has
to
be
I,
don't
know
it
just
wouldn't
compile
otherwise
and
obviously
like
I.
Don't
have
to
tell
you
the
data,
ownership
and
rust
is
is
good
and
bad
at
the
same
time,
and
sometimes
you've
got
a
fight
with
the
Boro
checker,
quite
a
bit
like
here
or
for
some
reason.
A
This
is
the
only
strange
shot
I
had,
but
I
had
so
many
problems
with
this
and
the
one
conclusion
I
kind
of
came
up
with
at
the
end
of
this
all
is
that
it's
just
always
right,
don't
fight
with
it,
but
the
TL
TL
DR
that
I've
kind
of
got
to
at
this
point,
and
at
the
stage
of
kind
of
writing
this
code
is
that
it
helps
rust,
helps
you
write
performant
code
and
you
don't
have
to
kind
of
do
anything
special.
You
don't
have
to
do
anything
out
of
the
ordinary.
A
You
don't
have
to
do
any
magic
and
you
kind
of
just
end
up
with
clean
code
right
off
the
bat
cool.
So
this
particular
portion
of
my
work
is
available
at
MongoDB
rest
among
the
DB
schema
parser,
and
this
is
chemo
for
so
that
lets
you
do
this
stuff,
but
that's
the
rest
set
of
things.
Let's
talk
about
the
allows
them
a
little
bit.
I
can't
either
juicy
part.
A
A
One
of
them
is
from
me
it's
faster
than
JavaScript
is
the
way
I've
defined
it,
but
to
kind
of
like
the
nice
conglomerated
definition
I
liked
is
it's
a
low-level
assembly
like
language
with
a
compact,
binary
format
that
provides
languages
with
the
compilation
target,
so
they
can
run
on
the
web
and
kind
of
the
main
part
of
that
is
that
it's
a
compilation
target
and
that's
the
cool
thing,
so
you
can
kind
of
get
waz
them
from
other
different
languages.
You
don't
have
to
write
the
rest.
I
just
chose
to
write,
rust.
A
I
know
the
go.
Logo
is
no
longer
that
I
just
really
like
the
go
first,
so
I
kept
it
go
through
right,
so
we
wrote
rust,
can
compile
from
it
from
anything
else.
Just
compiled
on
tourism
and
wasum
is
what
we
talk
to.
We
don't
talk
to
us
directly
right,
so
a
compilation
targets.
So
how
do
we
get
to
the
compilation
target?
Well,
there's.
Luckily
our
really
convenient
tools
it
lets
you
do
that
it's
called
the
Y's
and
bindin
and
that's
what
we
did
as
well.
A
All
we
have
to
do
is
just
unate
ate
with
wasn't
binding
and
because
we
want,
you
know
the
JavaScript
co-workers
to
be
happy.
We
just
kind
of
use
the
GS,
a
custom
names,
so
the
new
or
the
right
JSON,
without
the
underscore,
because
it's
confusing
when
you're
in
JavaScript
land.
So
it's
good
when
you
start
off,
writing
wasum,
you
kind
of
just
end
up
with
three
different
things
you
can
use.
A
You
can
use
the
error,
you
can
use
the
value
and
you
can
use
like
a
borrowed
string
so
that
those
are
the
kind
of
things
that
ended
up
in
the
beginning,
and
it's
really
good
thing,
because
I
started
off
with
a
string
to
make
the
compiler
happy,
which
is
really
good.
So,
although
I
had
to
do
is
just
keep
what
I
had
and
return
a.j
s
value
or
return
a
string
and
that
worked
sort
of
let's
compile
and
see
what
happens,
spoiler,
alert,
I
guess
a
little
bit.
A
It
didn't
compile
right
away
and
is
kind
of
interesting.
This
error
that
came
through
and
what
it
was
telling
me
is
the
error
that
I
was
using
was
not
working,
which
means
the
faily
error
solution.
I
have
tried
to
use
because
I
thought
I
was
being
really
clever,
did
not
actually
work,
and
before
you
tell
me,
you
should
have
used
the
box.
The
box
also
doesn't
work
so
an
interesting
way
of
actually
handling.
This
is
that
I
had
a
specific
wrapper
that
worked
in
rust
and
a
specific
wrapper
that
worked
in
JavaScript.
A
So
all
I
did
was
I
rubbed.
My
rust
methods
in
Maya
'sm
exported
methods
and
matched
on
the
result
type
and
whenever
I
got
an
error,
I
just
stringify
it
into
J's
FAL
you
and
that
worked,
and
that
works
really
well
can
do
the
same
here.
Thankfully,
we're
also
not
the
only
people
who
were
struggling
with
this
there's
an
open
PR
on
this
issue
as
well,
so
you
can
check
it
out
and
follow
it
there
as
well
cool
so
start
off
with
a
string
kind
of
worked
for
us.
It's
good.
A
We've
got
a
compass
talking
to
the
database,
receiving
documents
talking
to
Oz
and
wasn't
talking
to
rust.
But
what
we're
kind
of
need
to
think
about
is
the
fact
that
we're
getting
beasts
on
documents
coming
through
from
the
database
we're
strong
of
fiying
them
and
then
sending
them
to
us
and
then
what
happens
when
the
new
stringify
is
you
actually
lose
a
bunch
of
data
integrity,
because
what
be
son
does
is
that
specifies
when
something
is
decimal
128?
A
A
Otherwise?
So
what
the
idea
came
is
that
okay,
so
we
have
the
node
driver
returning
raw
beasts
on
what,
if
we
just
send
that
Rob,
instead
of
like
serializing
on
JavaScript
side
of
things
deserializing
on
the
rest
set
of
things.
So
we
can
skip
all
that
serializing
and
deserializing
steps
and
just
pass
around
robbie.
So
that
was
cool
idea,
and
but
that
requires
us
to
send
the
Veck.
Basically
like
you
need
a
vac
of
sorts.
A
A
You
have
a
bunch
of
ROM
bindings
to
JavaScript
API
that
you
can
use
and
rest
and
a
bunch
of
them
are
there's
like
a
very
long
list,
but
some
of
them
were
include
object
and
function,
and
you
and
8ra
and
date
and
iterators,
and
things
like
that.
But
what
we're
interested
in
because
we're
starting
off
with
a
raw
buffer
which
is
technically
a
vector
which
is
technically
a
U
and
eight
array?
What
can
you
use
a?
U
nth
iterate
for
that.
A
So
what
we
do
is
we
accepted
you
and
eight
array,
and
then
we
do
some
magic
in
between
and
then
we
just
basically
decode
Abbyson
document
that
comes
up
with
the
correct
type
of
data
information.
A.K.A
decimal
128
comes
in
as
a
decimal
128
in
its
proper
glory
of
decimal
128
in
precision
and
we
don't
lose
any
data
and
basically
what
it
does
is.
A
Basically,
what
you're
able
to
do
is-
and
you
just
take
the
data
that
comes
in
from
JavaScript
heap
and
then
converted
to
the
Oise
ohm
linear
memory
and
then
just
use
it
as
part
of
la's
in
linear
memory
inside
your
rest
code
and
the
man
took
it
between
is
actually
kind
of
interesting,
so
I'm
gonna
go
back
to
the
magic
in-between.
I
I
said
before.
A
You
got
to
force
it
to
be
a
mutable
slice
to
be
able
to
get
it
through
to
whatever
code
you're
trying
to
do
a
little
bit
of
magic,
cool,
so
error
handling.
I
kind
of
said
that
we
would
work,
would
like
a
string
and
we
just
return
a
string.
That's
a
j
s
value,
but
you
can
be
a
little
bit
more
granular
with
it.
Also,
with
a
j
s
is
great
and
what
we
can
do
is
we
can
specify
the
types
of
errors.
A
So
we
can
do
a
type
error
and
we
can
create
it
and
format
it
and
get
it
to
that
particular
state
and
there's
like
a
bunch
of
different
ones.
You
could
do
a
type
eval
range,
syntax
reference,
all
the
types
of
javascript
things
you
want.
You
can
get
them
so
then,
like
the
next
thing
is
like:
how
do
you
debug
wisdom
in
your
rest
or
in
your
javascript,
and
that's
kind
of
word
gets
interesting.
A
So
the
number
one
thing
is
like
a
runtime
error
that
you
get
and
then
what
that
comes
to
is.
Let's
hope
this
just
works.
Yes,
it
does
so
what
you
get
is
you
get
this
kind
of
error,
but
you
could
point
to
the
part
of
your
J's
bindings
and
what
that
does
is
it
takes
you
to
where
that
J
has
binding
is
causing
the
error,
and
you
can
get
it
through
that,
so
it
gets
a
little
bit
of
tracking
that
you
can
follow
through.
A
You
can
also
get
another
whoops,
and
this
one
will
come
through
as
an
error
that
you
would
throw
this
one
through,
because
I
threw
it
on
the
JavaScript
side
of
things,
because
I
wanted
to
throw
it,
and
you
have
scrip
side
of
things
and
again
you
can
kind
of
follow
that
through
as
well.
It
starts
off
with
a
wasn't
bind
generator,
and
you
can
follow
that
as
well,
which
does
not
give
you
a
very
useful
information.
There
was
unnamed.
A
A
A
A
A
You
should
probably
leave
unimplemented
code
in
your
code,
like
you
should
probably
implemented,
but
it
took
a
little
bit
of
time
to
get
through
to
that
and
obviously
like
only
having
three
API
methods
exposed
it's
kind
of
hard
to
debug,
and
so
this
is
entirely
a
little
bit
unrelated
I
wrote
this
pretty
printer
called
FEM,
it's
for
the
lock
rate
and
it
pretty
prints
your
log
stuff
for
you
and
unrelated
to
Azzam.
I
got
a
was
in
PR.
A
That
makes
it
work
in
wasum
and
so
I
kind
of
put
it
into
my
code
to
see
what
it
would
do
once
I
got
that
plasm
PR
in
and
I
actually
got
of
line
numbers,
and
there
was
like
line
numbers
everywhere.
So
I
can
see
who
are
like
a
bunch
of
my
code
that
I
was
logging
was
coming
through
in
a
particular
verse
side
of
things
and
I
was
really
cool.
A
A
A
So
let's
look
at
the
JavaScript,
this
one's
a
really
short
section,
so
we'll
just
quickly
go
through
it,
because
it's
once
we
get
to
JavaScript
it's
nice,
so
we
get
to
JavaScript
and
we
use
something
called
web
and
pack.
How
many
of
you
have
heard
of
wasn't
pack
cool
sweet,
so
it
makes
it
really
easy.
So
you
can
just
npm
install
the
whole
thing
and
it
just
works.
The
one
caveat
with
it
is
it
got
it
load
async
and
it
has
to
come
from
like
a
little
bit
of
a
process.
A
But
thankfully,
if
you
load
a
sync,
it
sort
of
works
except
the
one
whoops
and
it's
the
web
pack
and
after
a
bunch
of
like
research
and
struggling
with
it
like
a
lot
of
struggling
with
it,
you
get
to
the
point
where
you
just
have
to
install
a
very
specific
version
of
web
pack
and
then
it
just
works
and
then
to
load
it
async.
You
just
need
like
a
dynamic
import
and
Babel
and
but
I'm
cool.
So
we
had
to
adjust
kind
of
leave.
This
flow
a
little
bit
for
electron.
A
We
skip
the
middle
step
and
we
just
require
it
async
and
it
looks
like
this
you
import
and
then
you
do
a
promise
on
the
wads
of
module
and
then
you
use
it
as
is,
and
the
last
part
of
thing
is
yeah
actually
using
it.
So
the
API
is
has
three
points.
One
is
just
for
using
the
new
kind
of
instantiating
the
module
and
then
every
time
there
is
data
that
comes
through.
A
We
write
it
to
the
parser
and
obviously
the
rest
side
of
things
stores
it
inside
the
schema
parser
and
then
once
we're
done,
we
call
either
a
to
JSON
or
to
object
to
be
able
to
get
all
of
that
data
accumulated
and
then
words
really
darn
fast
cool,
so
the
TLDR,
the
TLDR,
is
that
I
did
not
have
to
do
anything
fancy
to
be
able
to
get
really
fast
code
running
in
the
browser.
I
just
kind
of
came
with
it.
It
came
with
the
rough
side
of
things.
A
Rust
compiles
down
to
of
assembly
and
web
assembly
is
really
cool.
You
don't
have
to.
As
Nick
has
stated,
you
don't
have
to
get
a
bunch
of
speed
without
doing
the
dark
arts
and
thrustin
wasum
are
there
to
be
able
to
do
that,
for
you,
I
I,
wanted
I
didn't
want
to
say
that
it
was
hard.
It
was
a
hard
like
six
months
and
it
took
me
to
like
build
out
the
whole
thing,
but
it
was
actually
like
a
lot
of
fun
to
be
able
to
do
it
right.