►
Description
To learn more about critical open source JavaScript projects like Appium, Dojo, jQuery, Node.js, and webpack, and 27 more checkout The OpenJS Foundation: https://openjsf.org/
Powering Up NodeJS Performance by Rust and WebAssembly - Shivay Lamba, Meilisearch
JW Grand Ballroom 1
Speakers: Shivay Lamba
In the post Moore’s Law era, due to limitations of the hardware, we need to squeeze more performance from the existing hardware. That means that the native code provides the best performance. However, the prevalence of native code on the server-side presents challenges to application safety and manageability. The rise and advent of Rust and WebAssembly offers new ways for developers to write high performance yet safe Node.js applications. In this talk, I will cover the basics of Rust and WebAssembly, as well showcase how to go about their integration with Node.js. You will learn how and when to design a hybrid web application. How can you code the high performance functions in Rust in a Web Assembly virtual machine and finally how to tie everything together in a Node.js JavaScript application.
A
First
of
all
welcome
everyone
to
my
talk.
I
know
it's
one
of
the
final
talks
for
today
and
it's
really
good
to
see
so
many
number
of
folks
today
joining
for
my
talk,
I'm
shivai
and,
of
course,
I'll
be
giving
a
brief
introduction
about
what
I'm
going
to
what
I'm
going
to
be
speaking
about
as
well,
and
so
it's
going
to
be
fun
because
it's
fun
topic
and
a
lot
of
new
concepts
for
a
lot
of
javascript
folks.
A
A
A
very
quick
introduction
about
myself,
I'm
shiva!
I'm
a
developer
advocate
at
melee
search.
It's
an
open
source,
rust
based
search
engine
that
can
be
used
to
create
very
quick,
full
text,
search
searches
that
you
can
include
in
any
kind
of
an
application,
and
I'm
also
contributed
at
layer
5,
which
is
an
incubated
project
under
cncf,
and
you
can
also
follow
me
on
twitter
or
at
hardware
in
case.
You
want
to
connect
with
me,
but
yeah
moving
to
the
topic
itself.
A
A
So
how
can
we
optimize
our
software
so
much
that
we
can
overcome
this
hardware
limitation
that
we
have
seen
and
that's
actually
going
to
become
a
lot
more
apparent
as
we
move
and
we
proceed
further.
So
the
need
of
the
r
is
to
improve
the
software
performance
and
also
what
we
have
to
take
into
consideration
is
that
whenever
we
talk
about
improving
the
software
performance,
it
has
to
also
be
safe
and
secure.
We
just
cannot
go
ahead
and
improve
software
at
the
like.
You
know
the
effect
of
having
bad
security.
A
We
also
need
to
ensure
that
we
have
good
security
in
place
as
well.
So
that's
where
certain
tools
like
rust
web
assembly
actually
come
to
the
picture.
So
what
is
rust
right?
Of
course,
rust
was
a
relatively
new
language
introduced
back
in
2015
and
during
that
time,
and
it's
still
supported
by
mozilla,
but
as
compared
to
some
of
the
other
languages
like
c
plus,
plus
and
c,
which
today
are
really
huge
right.
They
have
been
there
for
more
than
10
20
years,
so
why
to
choose
rust
over
something
like
c
plus
plus.
A
So
as
if
you
compare
rust
and
c
plus
plus
both
of
them
are
very
highly
com,
compliant
in
terms
of
performance
and
also
in
terms
of
the
developer
adoption
today,
and
both
of
them
have
really
great
communities,
but
one
of
the
key
areas
where
rust,
overcomes
or
sort
of
over
performs
c
plus,
is
in
terms
of
the
error
prone.
So,
of
course,
we
are
well
aware
of
the
common
issues
within
c
plus
with
respect
to
memory
management
with
respect
to
pointers
right,
it's
it's
a
very
huge
thing
right.
A
So
that's
where
rust
really
is
capable
in
terms
of
the
memory
management
and
also
be
becoming
a
lot
less
error
prone
as
compared
to
c
plus,
and
that's
one
of
the
reasons
that
why
we
would
want
to
actually
use
rust.
Now,
of
course,
we
know
that
the
standard
v8
engine
today
that
we
have
in
node.js
that
has
a
c
plus
compilation
that
takes
place
behind
the
scenes.
A
So
if
we
look
at
the
historical
background
and
how
we
were
able
to
actually
run
rust
inside
the
web,
so
essentially,
what
we
used
to
do
is
that
we
used
to
compile
that
into
native
libraries
and
then
run
them
as
extensions
with
the
existing
runtimes
like
in
node.js.
But
this
approach
proved
to
be
really
unsafe.
A
So
one
of
the
modern
ways
in
which
we
can
actually
do
that
is
that
we
can
essentially
take
our
rust
code
and
compile
it
to
this
kind
of
a
byte
code
and
then
actually
run
it
inside
of
a
virtual
machine
like
that,
for
example
in
case
of
web
assembly.
So,
just
to
sort
of
give
a
very
basic
introduction
about
webassembly
itself.
A
lot
of
you
might
be
aware
of
what
exactly
webassembly
is,
but
just
for
those
folks
who
are
relatively
new
to
what
exactly
is
webassembly.
A
So
essentially,
what
you
can
think
of
it
is
as
in
binary
instruction
format.
So
we
are
going
really
deep
into
assembly
language
and
how,
like
you
know,
machine
code
actually
gets
compiled.
So,
let's
think
of
it
as
a
binary
instruction
format
that
usually
will
deal
directly
with
your
assembly
code
and
essentially,
what
we
are
doing
is
that
we
are
taking
the
code
or
the
source
code
of,
like,
let's
say,
a
modern
language
like
c
plus,
plus
or
rust,
and
we
are
compiling
it
into
this
executable
byte
code.
A
But,
to
be
honest
like
it's
not
just
for
the
web
today,
the
ecosystem
for
webassembly
has
grown
beyond
just
the
browser,
although
it
was
initially
created
to
be
run
alongside
javascript
in
the
browser,
but
today
it
has
a
lot
of
applications
beyond
just
the
web
and
it's
used
in
a
server
side.
It's
used
in
on
its
devices
right.
A
So
that's
where
we're
also
going
to
be
seeing
how
you're
actually
able
to
use
web
assembly
with
node.js
for
running
any
kind
of
server-side,
implementations
or
server-side
applications,
and
no
it's
not
just
like
you
know,
limited
to
being
able
to
run
with
c
plus
or
these
kind
of
high
level
languages.
You
can
also
use
it
with
scripting
languages
today,
like
python
javascript.
So
essentially,
you
can
actually
run
javascript
inside
of
webassembly
today
and
we'll
also
look
at
some
of
those
use
cases
as
we
expand
into
our
topic
today.
A
So
today,
webassembly
is
also
used
for
a
lot
of
edge
applications,
especially
when
you
are
talking
about
very
less
resource
intensive
applications
that
you
want
to
run
on
the
edge.
Now
those
could
be
micro
services.
Those
could
be
dapper
and
also,
like
you
know,
like
let's
say,
running
machine
learning
on
the
edge.
That's
where
web
assembly
really
shines
as
the
standard
containers
right
they
are
very.
It
can
take
a
lot
of
time
to
actually
run
and
invoke
your
standard
containers.
A
But
when
we
talk
about
web
assembly
containers,
those
have
a
very
small
blueprint
in
terms
of
the
size,
but
also
in
terms
of
the
startup
time.
So
that's
one
of
the
great
areas
why
people
are
actually
looking
into
the
web
assembly
ecosystem
as
compared
to
the
standard
linux
containers
to
be
able
to
run
in
and
run
and
invoke
applications,
and
that's
where
I
would
love
to
introduce
the
assembly
runtime
and
essentially
what
exactly
the
web
assembly
run
time
or
was
the
meds.
A
It's
essentially
an
open
source
project
today
that
is
currently
incubated
under
the
cncf
landscape,
the
cloud
native
computing
foundation
landscape.
So
it
provides
the
runtime
for
webassembly
applications
and
can
be
used
for
a
lot
of
different
applications
again
running
microservices,
running
machine
learning,
inference
on
the
edge
and
then
even
for,
like
you
know,
any
kind
of
a
blockchain
based
application
as
well.
Now
one
of
the
greatest
advantages
of
the
website
of
was
a
meds
specifically.
A
Is
that
as
compared
to
the
other
runtimes,
it
actually
uses
something
known
as
ahead
of
time
compilation
so
that
that
is
what
is
one
of
the
biggest
reasons
why
it
is
so
highly
computational
and
really
fast
because
of
the
air
of
time
compilation
and
of
course
it
is
very
lightweight
and
portable.
So
you
can
run
it
across
multiple,
like
on
a
mac
on
windows
or
on,
like
even
your
arduino
right.
A
So
essentially,
what
we
have
come
to
is
after
having
introduced
all
these
different
tools
like
web
assembly,
was
a
meds
and
rust.
So
what
we
want
to
do
is
that,
essentially
we
want
to
stick
with
javascript
because
of
the
ease
of
use
of
javascript,
but
what
we
also
want
to
do
is
that
if
we
want
to
make
really
highly
computational
applications,
we
want
to
sort
of
offload
some
of
the
tasks
that
node.js
is
currently
doing
to
also
include
things
like
rust
and
webassembly.
A
So,
with
rust,
we'll
be
getting
the
performance
of
rust
and
with
webassembly.
What
we're
going
to
be
getting
is
a
very
secure
environment,
because
webassembly
is
really
secure
as
compared
to
any
other
type
of.
So
usually,
what
to
sort
of
explain
this
into
a
lot
more
depth?
Is
that
webassembly,
as
I
mentioned,
is
a
binary
instruction
format,
so
by
default
web
assembly
cannot
do
anything
on
its
own.
A
So
as
you
can
see
that
by
default,
whenever
you're
running
in
javascript
applications
on
the
front
ends,
of
course,
you
will
have
a
front
end
where
it's
interacting
with
the
browser.
Now,
when
it
comes
to
your
back
end,
where
you're
running
a
node.js
application,
the
standard
runtime
compiler,
for
example,
the
v8
engine
that
has
a
c
a
c
process
based
runtime
now,
what's
what
what
we
are
proposing
is
to
have
an
alternate
runtime
and
that's
your
webassembly
based
virtual
machine.
A
So
what
will
happen
is
that,
for
example,
and
I'll
be
showing
a
real
world
example
over
here
as
well,
like
let's
say
that
you
have
a
rust
based
source
code.
So
what
will
be?
What
we'll
be
doing?
Is
that
all
your
highly
competition
tasks,
for
example,
if
you
are
doing
machine
learning,
inference
with
nodes?
Yes,
so
we
know
that
machine
learning
is
really
highly
competition
right
and
very
computer
intensive.
So
what
you'll
be
doing?
A
Is
that
you'll
not
be
writing
your
actual
machine
learning
inference
code
in
node.js
instead,
what
you'll
do
is
that
you'll?
Be
writing
your
machine
learning
influence
code
inside
of
rust,
and
what
you
will
be
doing
is
that
you
will
be
making
a
call
via
your
node.js
function
to
this
webassembly
runtime
and
what
it
will.
What
it
will
do
is
that
it
will
help
compile
your
rust
code
into
a
webassembly,
executable
or
a
bytecode,
and
that
will
run
inside
your
webassembly
ecosystem
that
your
webassembly
virtual
machine.
A
So
essentially,
what
we
are
doing
is
that
your
node.js
function
is
just
calling
your
webassembly
runtime
and
all
the
highly
conventional
tasks
are
being
managed
within
rust
and
having
the
security
of
being
run
inside
the
web
assembly
virtual
machine.
Now,
your
website
virtual
machine,
has
access
and
can
basically
get
access
to
your
file
system
to
your
to
basically
to
the
hardware.
A
For
example,
if
you
need
to
access
the
gpu,
so
all
the
physical
resources
can
be
accessed
directly
via
the
virtual
machine
by
the
webassembly
virtual
machine
and
also,
as
I
mentioned,
to
your
os
as
well.
For
example,
if
you
want
to
get
some
of
your
files
that
will
be
used
during
the
training
and
like
let's
say,
once
you
generate
a
response
that
can
be
sent
back
to
your
node.js
application
in
order
to
do
any
further.
Any
further
implementations
that
you
want.
A
So
everything
with
respect
to
file
management
with
respect
to
accessing
hardware
resources
can
be
directly
managed
via
this
web
assembly
runtime
and
that
what
makes
it
really
exciting-
and
this
is
what
I
I
just
like
you
know-
spoke
about
that
you
have
you
know
this
application,
you
have
a
javascript
function
and
that's
calling
your
rest
function
to
compile
it
into
the
bytecode
and
that's
how
your
nodes,
this
application,
will
essentially
communicate
with
your
webassembly
runtime,
and
for
that
like
of
course,
I
mean.
Having
explained
all
of
this
architecture.
A
A
So
there
is
general
support,
but
the
best
support
that
you
can
get
is
with
the
linux
distribution,
so
you
could
potentially
also
do
something
like
if
you're
having
a
mac,
you
could
install
a
linux
image
on
docker
and
run
your
inference
using
that,
but
also
you
do
need
rust
language.
You
need
node.js,
of
course,
the
vasomets
runtime
and
finally,
you
also
need
the
rust
to
awesome.
Compiler
tools
in
this
will
be
responsible
for
converting
your
rust
code
into
the
wasa
med,
binary,
the
bytecode
so
to
get
started.
A
A
But
of
course
you
can
take
a
picture
of
the
starter
code,
but
I'll
quickly
give
a
walk
through
what
exactly
is
included
in
this
in
this
starter
code
and
how
you
can
get
started
and,
of
course,
the
general
idea
of
this
demonstration
that
we're
going
to
be
showing
to
you
today
so
for
that
I'll
just
quickly
get
this
source
code
over
here
and
I'll
just
quickly
share
a
share
over
here.
So
give
me
this
once
again,
so
I'll
just
quickly
go
ahead
and
open
up
the
github
repository
all
right.
A
So
what
you
can
see
over
here
is
we
are
we're
going
to
be
seeing
two
most
important
things
over
here.
So
one
is
the
node
folder
and
the
other
one
is
the
source
folder.
So
if
you
go
inside
the
source
folder,
you
will
see
one
simple,
lib.rs
function,
it's
a
rust
function
that
we
have
created
and
what
it's
doing
is
a
really
simple
rust
function
to
show
you
the
demonstration
of
the
capability
of
what
we
want
to
showcase.
So
whether
what
it's
doing
is
that
essentially
it
will.
A
To
invoke
the
call
to
this
webassembly
function
that
we'll
be
making
with
the
help
of
our
nodejs
function,
but
essentially
it's
a
very
simple
function
that
we
have
written
where
it
is
receiving
an
end
point
we'll
be
making
a
request
from
our
node.js
function
where
it
like.
You
know
this
will
basically
like
let's
say
we'll,
have
something
like
hello
world,
so
it
will
be
accepting
like
a
variable
that
will
be
used
and
it
will
be
appending
it
to
hello.
A
So,
essentially,
we
will
be
making
a
request-
let's
say
hello,
so
we'll
be
sending
that
request
and
it
will
be
appending
hello
to
shivai
to
return
whatever
we
are
sending
apart
from
hello.
So
that's
what
this
rust
function
is
accepting,
and
apart
from
this
rust
function,
the
other
thing
that
we
are
going
to
be
taking
a
look
at
is
our
node
folder,
so
I'll
just
quickly
go
back
to
the
source
directory
and
within
this
we'll
take
a
look
at
our
note.
Node
folder
within
this
we'll
look
at
our
app.js.
A
So
this
is
what
is
sort
of
the
heart
of
the
program,
so
at
this
at
the
beginning,
what
you
can
see
is
we're
invoking
this
save
function,
which
we
are
basically
getting
from
our
was
image
node,
their
starter
library,
dot
js,
so
how
this
particular
library
is
getting
generated
or
how
this
particular
source
code
is
getting
generated.
Is
that
basically,
once
we
compile
our
rust
code,
it
generates
two
different
files.
One
is
the
actual
wasm
executable
and
the
other
one
is.
A
This
was
image
node.js,
starter
library.js,
which
will
now
be
used
by
our
node.js
function
to
be
invoked,
and
that's
where,
if
you
see
over
here
now
that
inside
of
our
function,
that
we
are
that
we
have
written
inside
over
here
right.
So
what
we're
doing
is
that
we
are
sending
the
name
that
we
want
to
invoke
from
our
node.js
function,
so
this
name
will
be
sent
to
our
rust
function
where
we,
it
will
be
appended
to
hello.
A
So
if
we
were
to
like,
let's
say
if
we
had
something
like
shivay,
so
it
will,
the
final
result
would
be
hello
right.
So
that's
what
we're
doing
with
the
help
of
this
node
function
so
in
in
a
nutshell.
What
we're
doing
is
that,
once
we
have
this
node,
this
function,
first,
the
first
thing
that
we'll
be
doing
is
that
we'll
be
compiling
our
rust
function
to
get
our
wasm
executable
and
also
our
starter
node.
A
This
function
that
will
be
used
by
our
node
application
and
we'll
be
able
to
make
a
call
and
if,
for
example,
now
what
you'll
do
is
that
once
you
get
this
running,
we'll
essentially
get
an
output
like
let's
say
if
you're
running
at
on
port
3000,
in
this
case
the
port
that
we
have
exposed
to
is
3000..
So
if
you
were
to
make
a
curl
request
to
port
3000
and
send
like
let's
say,
opens
yes,
so
it
will
return.
A
Hello,
opencs,
a
similar
example
that
I
would
want
to
also
showcase
in
terms
of
the
machine
learning
inference
that
I
spoke
about
is
I'll.
Just
quickly
show
a
real
world
example.
Before
I
jump
back
to
my
presentation,
and
essentially
this
is
an
example
provided
by
second
state
that
supports
the
wasa
met's
runtime.
A
So
essentially,
what
we
have
over
here
is
a
mobile
net
tensorflow
model,
essentially
that
that's
used
for
being
able
to
detect
and
recognize
a
lot
of
the
common,
like
you
know,
objects
within
a
particular
image.
So
what's
it?
What
it's
doing
is
that
over
here
all
the
machine
learning
influence
that
you'll
see
right
from
the
model,
getting
the
input
file
that
we
get
and
doing
the
machine
learning
inference
and
actually
drawing
the
bonding
box.
A
All
of
that
will
be
taken
will
be
taken
a
place
with
the
help
of
our
rust
function.
So
none
of
this
inference
will
actually
take
place
with
the
help
of
the
javascript
function
itself,
and
it's
offloading
all
of
that
machine.
Learning,
highly
combinational
tasks
to
our
responsion.
So
that's
how
it's
acting
in
the
behind
the
scenes,
so
just
to
give
a
very
quick
demonstration
I'll
pick
up
an
image
and
probably
like
let's
say:
if
I
take
this
as
an
image,
let
me
see
what
do
we
get
if
we
classify
this
image?
A
A
What
you'll
see
is
you'll
see
a
bonding
box
created
in
on
the
object
that
it
detects,
and
it
will
basically
give
you
an
inference
of
okay,
if
you
like,
let's
say,
had
an
image
of
an
bottle,
so
it
will
create
a
bonding
box
in
front
of
the
bottle
and
it
will
let
you
know.
What's
the
end
result
right,
so
it
will
do
that
competition
for
you,
the
machine
learning
competition
for
you
and
it
will
be
able
to
detect
that.
A
But
the
general
idea
is
that
all
of
this
this
is
just
one
example
right.
If
you
had
some
more
highly
computational
machine
learning
models
right,
really
large
models
in
order
to
save
performance
for
your
web
application,
because
we
know
that
you
know
there
are
certain
resource
constraints
that
comes
with
node.js,
one
of
them
being
like
you
know
it
being
not
being
multi-threaded.
A
But
yes,
essentially,
that's
what
this
entire
ecosystem
is
and,
of
course,
it's
still
like
you
know
evolving
the
entire
ecosystem
for
for
web
assembly
itself.
The
developer
experience
related
to
web
assembly
is
not
the
most
ideal,
but
this
does
present
a
really
great
ecosystem.
That,
like
you
know,
is
possible
with
web
assembly
and
that's
what
I
wanted
to
cover
and
of
course
I
mean
the
next
slide
is
mainly
just
covering
the
entire
code.
A
But
what
I
just
wanted
to
showcase
from
this
presentation
is
that
you
can
use,
like
you
know,
webassembly
today,
with
rust,
with
node.js,
to
really
make
the
performance
and
of
your
nodes,
this
application
really
quick,
but
also
provide
it
a
very
safe
environment
to
be
able
to
execute
inside
of
but
yeah
I
mean.
Of
course,
there
are
a
number
of
other
different
kind
of
use,
cases
that
you
can
use
this
with.
A
Today
we
had
some
of
the
presentations
over
the
past
couple
of
days
where
we
spoke
about
event
streaming
in
in
node.js.
That's
also
something
that
we
are
now
looking
at,
that
you
can
actually
manage
with
the
help
of
webassembly.
Today
we
have
a
lot
of
different
tools
such
as
like
cloudflare
and
then
flash
fastly,
where
they
are
actually
using
webassembly
under
the
core
under
hood,
to
do
all
of
different
kind
of
highly
combinational
tasks
like
cdn
management
right.
A
A
But
I
will
just
quickly
go
to
the
versamatch
website
and
basically,
if
you
want
to
contribute
to
awesome,
it's
a
relatively
young
project.
As
well,
there
is
a
week
there
is
a
monthly
meeting
that
takes
place
a
community
meeting
that
takes
place
for
the
wasa
mets
project
every
month
on
the
first
tuesday.
A
So
if
you
are
interested
into
the
web
ecosystem
was
image
is
not
just
limited
to
node.js,
you
can
also
do
server-side
rendering
with
versameds,
and
there
are
a
number
of
different
javascript
based
applications
that
you
can
actually
do
with
the
help
of
was
image.
So,
of
course,
I
discovered
one
of
them,
but
you
have
all
of
these
different
other
areas
where
you
can
actually
use
was
met
and,
of
course,
just
the
rest.
Implementation
is
one
of
those
examples,
but
yes,
it's
an
open
source
project.
A
A
Yes,
so
there
are
multiple
ways
in
which
you
could
probably
do
this
machine
in
inference.
If
you
just
use
native
javascript,
it
could
take
like
let's
say
one
minute,
two
minutes
and
I'll
I'll
be
more
than
happy
to
share
some
of
these
findings
that
were
there.
I
have
a
few
resources
that
I
can
share
with
you
offline
and
then
there's
an
another
implementation
where
you
could
use
just
like,
let's
say
10th
floor
js.
A
A
Definitely
so,
as
I
mentioned
that
today
tensorflow.js
the
library
it
has
support
for
a
lot
of
different
back-ends.
So
one
of
the
back-ends
that
we
have
is
web
assembly,
so
it's
already
being
used
as
a
supported,
back-end
and
there's
all.
There
is
also
like
simply
support.
So
one
of
the
talks
that
you
gave
yesterday,
that's
like
you
know
that
is
there,
so
that
support
is
already
there
for
vivid
assembly
as
a
supported,
backend.
A
A
Yeah,
so
I
mean,
of
course,
was
image
is
not
just
one
of
those
runtimes.
There
are
multiple
runtimes.
So
where
was
the
match?
I
would
say,
because
outshines
wasn't
time
or
any
other
run.
Time
is
because
of
the
fact
that
it
has
ahead
of
time
compilation.
That's
one
of
the
biggest
factors
to
really
like
you
know,
make
it
very
fast
and
very
quick
to
do
all
these
inferences,
especially
when
you're
doing
it
on
edge
devices
which
are
very
computationally
resource,
oriented
right.