►
Description
Don't miss out! Join us at our upcoming event: KubeCon + CloudNativeCon Europe in Amsterdam, The Netherlands from 18 - 21 April, 2023. Learn more at https://kubecon.io The conference features presentations from developers and end users of Kubernetes, Prometheus, Envoy, and all of the other CNCF-hosted projects.
A
A
They
will
build
things,
they
will
break
things
and
they
will
answer
all
of
your
questions,
so
you
can
join
us
every
Wednesday
to
watch
live
so
this
week
we
have
Mikko
with
here
with
us,
to
talk
about
building
serverless
applications
using
thin
and
webassembly
very
excited
for
the
session,
and
as
always,
this
is
an
official
live
stream
of
the
cntr
and
as
such
it
is
subject
to
the
cncf
code
of
conduct.
So
please
do
not
add
anything
to
chat
or
questions
that
would
be
in
violation
of
that
code
of
conduct.
B
Thank
you
Annie,
and
thank
you
for
having
us
here.
My
name
is
Miguel
mirakkai,
Knight
and
I
work
as
head
of
product
and
developer
relationship
at
a
company
called
fermion
and
at
fermion
we
we
build.
What
we
believe
is
the
next
wave
of
cloud
computing
and
part
of
what
I'm
going
to
talk
about
today
is
how
we
use
webassembly
to
power
that
movement
and,
in
particular
our
open
source
framework,
called
spin.
That
I
will
be
introducing
you
to
and
demonstrating
some
applications.
B
B
So
I,
you
know,
I
usually
come
up
with
this
thing
about
all.
When
people
ask
about
what
webassembly
is
and
trying
to
figure
out
what
are
sort
of
the
most,
the
three
most
important
things
that
you
should
know
about:
webassembly,
which,
which
was
the
challenge
I
gave
myself
and
I,
ended
up
with
a
list
of
five
and
eight
and
ten
things.
It's
really
really
hard
to
get
it
down
to
three.
But
you
know:
here's
here's,
the
here's,
here's
what
I'm,
what
I
got
to?
B
First
of
all,
what
you
need
to
know
about
webassembly
is
that
it
is
a
specification
and
it
is
a
specification
of
a
binary
instruction
format
which
is
designed
as
a
portable
compilation,
Target
now
I'm
going
to
unfold
that
in
a
little
bit.
So
we
all
sort
of
get
a
level
set
on
on
on
what
all
that
means
and
I
believe.
The
third
most
important
thing
to
know,
as
you
are
going
to
listen
in
for
the
next
hour.
B
So
is
that
if
I
at
any
point
in
time
say
wasn't
it's
the
same
as
webassembly,
it's
just
as
not
a
name.
Basically,
it's
the
file
extension
we
use
for
webassembly
and
so
awesome
webassembly
will
be
used
interchangeably
by
me.
So
don't
be
don't
be
thrown
off
by
that.
So
there
might
be
a
lot
of
other
important
things
to
know
about
webassembly,
but
at
least
this
is
what
this
is
a
place
to
start
and
by
the
way.
B
If
you
want
to
read
about
webassembly,
there's
a
link
here
to
webassembly.org
to
help
you
get
some
more
understanding
about
the
specification
than
how
how
the
work
around
the
specification
is
going
on.
B
So
when
we
talk
about
this
portable
compilation,
Target
or
the
bytecode
format,
what
what
does
that
really
mean
for
webassembly?
Well,
when
we
walk,
we
don't
want
to
walk
you
through
sort
of
the
symbol,
the
three
simple
step
that
that
is
part
of
getting
from
the
code
you
ride
into
running
that
code
in
this
bytecode
format,
that
is
the
webassembly.
B
But
as
the
compilation
happened
for
the
code,
the
code
combined
compiles
into
this
bytecode
format
or
Into
the
webassembly
Now.
It's
it's
language
specific.
How
this
happens
today-
and
there
are
at
least
two
ways
of
doing
this
and
there's
probably
many
more
ways
depending
on
languages-
and
this
is
sort
of
you
know.
State
of
the
ecosystem
here
in
the
maturity
of
of
of
web
assembly
is
also
that
this
is
continuously
improving.
You
know
and
new
languages
are
coming
in
with
more
support,
but
that
is
sort
of
the
the
first
step.
B
That
needs
to
be
done
now
that
we
have
our
by
code
format
the
web
assembly,
the
compile
code.
We
need
to
run
that
and
the
way
that
that
works
is
that
we
have
a
virtual
machine
that
runs
our
webassembly
now.
This
is
this
is
very
similar
to
how
things
like
the
jvm
use
is
working.
That
used
to
work
still
works
today
and
many
other
scenarios,
and
this
is
where
we
need
a
webassembly.
B
Runtime
is
basically
what
will
provide
that
VM
for
our
webassembly,
the
way
that
you
run
these
web
assemblies
and
the
various
webassembly
runtimes
that
are
out
there.
There
are
sort
of
two
tube
branches
to
this,
and
one
of
them
is
dependent
on
JavaScript
and
that's
when
you
want
to
run
webassembly
inside
of
the
browser.
B
The
other
one
is
not
dependent
on
JavaScript,
which
is
also
sometimes
referred
to
as
server-side
webassembly,
and
there
are
a
lot
of
different
ways
of
doing
this,
and
all
of
that
depends
on
the
various
web
assembly
runtimes
that
you
choose
to
use
that
will
sort
of
take
you
down
different
different
paths
so
to
get
a
better
overview
of
this
whole.
What's
the
state
of
support
with
languages
when
running
inside
the
browser,
webassembly
or
running
webassembly
in
other
places
or
using
something
called
bossy,
would
I
will
which
I
will
expand?
B
B
B
B
B
This
is
what
webassembly
was
originally
designed
to
help
solve,
basically
enhance
the
experience
you
can
build
inside
of
a
browser
by
enabling
other
programming
languages
to
be
used
to
write
applications
for
in-browser
experiences,
and
this
has
been
around
for
for
many
years,
I
believe
webassembly,
as
a
specification
was
originally
from
2017
or
something.
So
it's
been
some
years
where
webassembly
has
been
used
inside
of
the
browser.
B
So
if
you
are
in
that
world
of
writing
webassembly
for
the
browser,
the
webassembly
runtimes
that
you
use
would
be
either
V8
or
spider
monkey
that
are
used
inside
various
browsers.
You
can
see
Google
and
Firefox
and
the
The
Edge
the
Microsoft
Edge
being
called
out
here
and
also,
if
you
have
Frameworks
like
node
and
D
node,
to
run
on
the
server
side,
which
uses
V8
you're
able
to
do
similar
things
with
webassembly.
B
So
there
are
a
sort
of
wassce
compatible
runtimes
out
there,
and
there
are
many
more
that
the
ones
I've
listed
here
wasn't
time
which
is
built
by
byte
code.
Alliance
is
one
of
those
there's
wasma
and
there's
wasm
Edge,
which
is
a
cncf
project
as
well.
So
these
are
all
run
times
where
you
can
run
webassembly
without
having
that
tie
into
JavaScript
and
wasi
is
what
we
have
based
our
framework
spin.
B
On
top
of
so
just
to
give
you
a
quick
idea
of
how
this,
how
you
can
you
know,
take
rust
in
JavaScript
and
combine
in
the
browser.
What
I'm,
showing
you
here
is
some
Rust
code,
and
what
I
really
want
to
call
out
is
that
you
can
see
how,
within
the
rust
code,
I'm
able
to
call
into
setup
apis.
That
should
be
quite
familiar.
B
B
So
wussy
is
what
is:
it's
called
a
system
interface,
so
it's
a
webassembly
system,
interface
for
webassembly
platform
and
basically,
what
what
was
he
sets
out
to
do
is
to
enable
code,
that's
not
running
in
inside
the
browser
to
be
able
to
talk
to
a
conceptual
operating
system.
Right,
like
you,
need
access
to
files,
sockets
clocks,
random
numbers,
many
more
things.
B
So
these
types
of
resources
that
you
would
expect
an
operating
system
to
provide,
whether
which
are
different
things
that
what
you
would
expect
a
browser
as
an
environment
to
provide
to
you
and
the
reason
why
talk
about
this
as
a
conceptual
operating
system
is
because,
because,
because
of
the
portability
right,
it's
not
talking
directly
to
the
operating
system.
Otherwise,
we'd
have
to
have
you
know
we.
B
We
will
sort
of
break
the
portability
by
doing
that
and
and
I
think
there's
that
there's
a
point
here
in
terms
of
why
we
believe
that
webassembly
on
the
server
side,
our
webassembly
is
such
a
good
good
specification
or
system
to
use
for
server
side.
Is
that
if
you
think
about,
if
you
have
to
build
an
application
to
run
inside
the
browser,
there
are
at
least
four
things
or
four
things,
I
think
I.
Typically
think
of
that
that
we
always
have
to
think
about.
One
of
them
is
obviously
portability
right.
B
We
need
that
code
to
run
in
various
set
of
browsers.
You
know
different
JavaScript
engines
running
on
different
operating
systems,
different
processor
architecture.
All
of
that
right,
you
want
to
write
your
code
once
and
run
it
anywhere.
That's
that's
why
you
write
applications
for
the
browser
typically,
so
portability
is
some
of
the
things
that
that
browser
path
takes
us
on
another.
B
One
is
security
where
you
know,
because
whenever
you
run
code
inside
of
the
browser
it's
it's
always,
you
know
it's
untrusted
in
the
way
that
you
can
hit
any
random
endpoint
and
it
will
basically
just
that
server
will
give
you
some
code.
Your
browser
would
happily
execute
it.
I
mean
security
settings
set
aside
for
a
moment,
but
you
know
it's
it's
not
it's
not
code
that
you
can
necessarily
validate
before
you
actually
end
up
running
right.
So
so
you
need.
B
B
The
the
third
one
is
is
the
size
of
the
binaries,
because
we
always
have
to
have
the
actual
executable
or
the
binary
that
we
need
to
execute
transferred
across
the
internet
like
we,
we
want
to
optimize
the
size
of
them
to
be
small,
so
that
we
can
quickly
get
them
there
and
execute
them.
You
know
at
the
time
we
actually
need
them.
B
It's
not
like
we
I
guess
we
use
that
once
like
you,
you
come
into
a
website
right
and
you
waited
for
something
to
download
and
install,
and
then
you
could
see
your
website
and
that's
you
know.
We
don't
want
that
experience
in
the
browser,
which
means
that
we
want
to
have
small
binaries
and
the
last
one
is
that
you
know
fast
startup
type.
B
They
need
to
start
immediate,
because
again
we
don't
want
to
have
a
website
experience
a
web
application
experience
being
dragged
down
by
having
you
know
things
taking
a
long
time
to
get
up
and
running,
so
those
four
things
are
actually
highly
attractive.
For
you
know
a
lot
of
the
stuff
that
we
do
in
the
cloud
native
world,
like
you,
have
things
that
are
portable,
so
build
run,
run
anywhere.
You
have
things
that
are
secure
by
default,
they
run
in
isolated
sandboxes.
B
You
have
things
that
are
small
binary
sizes,
so
they
can
quickly
be
moved
around
and
you
have
things
that
start
up
really
really
fast,
and
so
so
was
he
is
is
is
is
is
here
to
provide
that
conceptual
operating
system
for
those
type
of
workloads
that
can
sort
of
you
know
that
have
those
capabilities,
and
that
opens
a
whole.
You
know
range
of
scenarios
that
we
can
do
much
much
better
in
the
world
of
cloud
native
development
today
than
what
we've
been
used
to
before.
So
that
is
really
what
was
about
and
I.
B
Think
I've
highlighted
two
here
with
portability
and
security,
and
we
can.
We
can
dive
a
little
bit
into
the
data
if
people
are
interested
in
that
and
so
feel
free
to
ask
questions
as
we
go
along.
If
there
are
certain
things
you
want
to
know,
you
want
to
know
more
about
okay.
That
leads
me
to
spin
I'm
just
going
to
take
a
sip
of
water
here.
B
And
spin
spin
is
an
open
source
framework
that
we
have
fermium
have
been
built.
Spin
was
two
weeks
ago,
I
think
very
recently
released
as
a
1.0,
and
it
is
a
developer
tool
for
building
webassembly,
microservices
and
web
applications.
So
what
what
do
we
mean
by
that
I?
B
Demoing
I
hope
that
one
of
the
things
that
you'll
notice
is
that
you
know
the
vision
of
spin
has
really
been
to
not
necessarily
get
you
into
the
wheat
webassembly,
because
webassembly
is
a
fairly
can
be
a
fairly
low
level
thing,
but
really
to
provide
you
a
great
developer
experience
which,
because
it's
built
on
top
of
webassembly,
it
makes
it
it
makes
it
makes
it.
You
know
a
delightful
experience
to
build
applications.
B
So
you
know
rather
than
me,
trying
to
just
press
things
that
you
haven't
seen
or
rather
show
that
in
action
to
you.
So
let
me
just
start
by
doing
some
very
simple,
hello
world
introductions
so
that
we
can
sort
of
see
what
this,
what
this
is
and
then
a
little
bit
later.
We
can
dive
into
a
bit
more
of
a
complex
application
that
we
want
to
build
Okay,
so
I'm
in
a
terminal
here
and
what
I've
done
is
I
have
downloaded
a
spin.
So
actually
let
me
go
over
and
show
this
to
you.
B
We
have
a
site
called
developer,
fermium.com
and
I
am
trying
to
get
stuff
over
here,
so
those
links
can
be
shared,
which
is
basically
the
documentation
home
for
spin.
So
here
you
can
read
about
Spain.
You
can
read
how
to
install
there's
a
great
quick
start
here,
Michelle
one
of
our
College.
My
colleagues
have
have
given
to
sort
of
give
you
an
introduction
to
that.
And
if
you
notice
on
on
the
installation
side
that
we
run
spin
runs
on
Linux
spin
runs
on
Macs.
We
can
run
some
windows.
B
You
can
choose
all
of
those
those
those
operating
systems
you
spin,
but
really
what
spin
is
about
is
just
to
make
it
really
really
easy
for
you
to
write
application.
So
let's
do
this.
So
what
do
you
want
to
do?
If
you
want
to
do
spin?
Is
you
create
a
spin
application?
You
run
a
command
called
spin
you
now
what
we're
going
to
show
you
when
you
run
a
spin
new
command?
B
Is
that
there's
a
set
of
templates
that
you
can
use
to
build
applications
with
to
build
your
spin
applications
with
now
a
few
things
that
you
might
have
noticed
here
that
there's
a
lot
of
HTTP
there's
a
little
bit
of
redis,
there's
some
other
stuff
in
here
and
then
there's
a
wealth
of
different
programming
languages
like
C
C,
sharp,
go,
JavaScript,
python,
rust
and
so
on
and
so
forth?
And
this
you
know
because
webassembly
and
the
support
across
all
these
different
programming
languages
you
can
within
a
spin
application.
B
You
can
combine
the
various
programming
languages
you
want
to
use.
You
know
at
your
discretion,
it
doesn't
really
I
mean
you
can
have
a
component
in
Rust.
You
can
have
part
of
item
go.
You
can
part
of
it
in
JavaScript.
You
can
combine
all
of
these
together.
That
is,
that
is
part
of
you
know
where
webassembly
is,
is
really
powerful.
B
The
other
thing
to
notice
is
the
HTTP
part
or
the
radius
part,
which
are
the
two
things
that
I
I
just
want
to
call
out
here.
So
the
way
that
the
spin
application
model
work
is
it's
an
event
driven
model.
You
probably
like
you
know,
a
functions
as
a
service
type
of
model
that
you
know
from
services
like
Lambda,
which
means
that
spin
is
built
in
a
way
where
the
ask
and
the
developer,
who
builds
the
application,
is
to
make
a
choice
of
what
type
of
events
your
application
supports.
B
So
in
this
case
it
could
be
an
HTTP
request.
It
could
be
a
redis
q
event
happening,
and
then
you
write
the
logic
to
handle
that
HTTP
request
and
you
return
something
back
so
so
so
so
we
are
setting
this
up
in
a
way
where
you
know,
there's
very
little,
there's
very
little
boilerplate
code
for
you
to
to
deal
with,
and
you
can
just
you
know,
get
straight
into
writing
that
actual
code
you
want
to
to
handle
to
handle
a
request.
B
So
let
me
go
ahead
and
try
and
start
out
with
the
JavaScript
HTTP
Handler
here,
and
we
can
call
this
cncf
live
demo
app
and
we
can
give
it
a
description.
If
you
want
to,
we
can
choose
we're
in
the
URL
structure.
We
want
to
listen
I'll
get
into
that
a
little
bit
later,
but
now
that
we
created
this,
let
me
see:
where
did
we
put
this?
This
ended
in
the
cncf
live
demo
app
want
to
show
oops.
That's
not
what
I
want
to
do
want
to
do.
B
Three
instead,
I
want
to
show
you
what
got
created
here
so
we
have
well.
We
have
a
readme
file
in
there,
but
what
we
have
is
we
have
a
few
JavaScript
specific
things.
First
of
all,
we
have
an
index.js
and
we
have
a
package
Json,
so
we're
using
npm
as
a
way
to
handle
dependencies
within
JavaScript,
obviously
have
I
chosen.
A
have
I
chosen
had
I
chosen
a
a
template
of
a
different
programming
language.
You
would
have
seen
sort
of
the
tool
chain
for
that
programming
language
in
there.
So
so
spin
doesn't
really.
B
You
know
we
use
the
tool
available
for
within
that
programming
language
to
build
to
build
your
application.
But
what
you
also
see
in
here
is
you
see
this
vin.tumble
file
and
maybe,
let's
start
up
with
that
and
then
I
can
show
you
how
a
spin
application
is
sort
of
is,
is
designed
or
structured.
B
So
here
in
my
editor,
you
can
see
the
spin.tamil
file.
The
spindle
terminal
file
is
that
definition
of
a
spin
application
and
the
first
six
line
here
is
basically
just
some
metadata
about
the
application.
You
can
see
there's
a
manifest
version
in
there.
There's
the
author
name
well,
I
didn't
provide
a
description.
I
could
have
done
that.
There's
a
name
you
can
see
that
this
there
is
this,
that
HTTP
is
defined
as
the
trigger
type
in
here.
B
So
when
we
talk
about
this
as
a
function
as
a
service
or
event
driven
that
is
the
trigger
type
defined
in
here
and
then
I
can
version
my
application
as
part
of
this
manifest
as
well
and
then
you'll
see
I,
have
a
I
have
an
array
down
here:
I
have
a
table
of
components
that
that
make
up
my
application.
So
what
happened
as
I?
Did
they
spin
new
applications?
We
created
the
first
component
yeah.
B
We
gave
it
an
ID
which
is
the
same
as
the
name
of
the
application,
and
we
can
see
there's
a
source,
but
this
is
where
the
the
web
assembly
starts,
showing
it's
it's
its
phase
in
here
or
come
to
the
surface
in
that
there's,
actually
a
wasn't
module
or
wasn't
file
that
will
be
running
now.
How
do
we
get
from
a
JavaScript
to
a
wasn't
file?
B
Well,
we
do
that
by
running
an
MP
and
build
command
so
part
of
the
spin
application
definition
you
can
sort
of
you
can
you
know
you
define
how
to
hook
into
that,
you
know
developer
or
the
language
specific
tool
chain
in
terms
of
producing
the
webassembly
module.
So
in
this
case,
npm
run
build
will
be
part
of
producing
that
webassembly.
B
So,
let's
actually
start
by
looking
at
what's
happening
in
that
npm
with
that
npm
build
command
so
now
I'm
in
my
package.json
file-
and
you
can
see
this
is
the
build
command
that
we'll
be
running
and
you
can
see
we're
doing
some
webpack
stuff
to
create
a
module
out
of
the
JavaScript.
This
is
this
is
specific
to
spin
and
specific
to
how
we
build
an
SDK
for
JavaScript
in
spin
how
this
works.
B
Our
JavaScript
SDK
is
in
an
experimental
phase
at
this
point.
Part
of
that
is
because
the
JavaScript
compilation,
2
webassembly,.
B
So
there's
you
know,
there's
some
Evolution
going
on
here
on
the
JavaScript
side
of
things,
but
this
is
how
we
do
this
today,
and
this
is
specific
to
the
to
the
spin
SDK
and
then
what
we
do
is
we
run
a
component
in
spin
called
JavaScript
to
Watson,
which
basically
helps
take
the
output
of
the
webpack
produced,
JavaScript
module
and
created
into
a
webassembly,
and
it's
gonna
output
that
webassembly
file,
specifically
in
the
Target
folder,
which
is
then
the
one
that
you
can
see.
B
If
we
go
back
to
the
spinner
tunnel
file
that
we
will
run
when
we
run
our
spin
application.
Okay,
so
now,
for
me
talking,
let's
actually
see
this
in
action.
This
is
this
is
the
code
that
will
execute
and
you
can
see
from
the
code
up
here.
Well,
I
actually
wasn't
done
talking,
sorry
about
that,
but,
as
you
can
see
from
the
code
up
here,
the
the
template
provides
you
a
a
function
that
you
know
is
called
handle
request,
and
this
is
a
requirement
for
JavaScript
and
we.
B
What
we
do
is
that
the
spin
framework
hands
over
the
request,
the
HTTP
request
coming
in
to
you,
and
then
you
do
whatever
you
want
to
do
within
you.
You
do
whatever
you
want
to
do
with
it
within
this
function.
In
this
case,
we're
simply
just
returning.
We
have
an
HTTP
status,
200,
saying:
okay,
we
set
a
few
headers
and
we
set
some
body
text
in
there
as
well.
Okay,
now
we're
actually
gonna
go
and
try
and
run
this.
B
So
if
you
go
over
to
Temp
and
I
think
we
call
this
cncf
I
gave
this
app
a
terrible
name.
This
is
probably
where
we're
going
to
break
things
as
we
go
along.
I
need
to
run
npm
install
because
we're
in
a
JavaScript
npm
world.
B
You
can
see
that
this
component
of
this
JavaScript
is
being
served
on
the
base
route
or
the
root
route.
Sorry,
which
is
then
translated
in
here
where
we
can
see
in
Port
3000.
We
now
have
a
cncf
live
demo
app.
So
if
we
go
ahead
and
we
just
curl
that
one-
we
see
that
we
get
our
response
back
and
we
get
that
header,
we
get
the
200
okay
and
we
got
the
hello
from
JS
SDK.
B
B
You
know
that
could
be
built
in
any
programming
language,
so
I'm
just
going
to
do
a
quick
pause
here
and
any
do.
We
know
if
there's
any
questions
that
we
need
to
get
two.
A
There
hasn't
been
any
questions
so
far,
but
a
good
reminder
to
our
audience.
If
you
have
any
questions,
just
put
them
to
the
chat
and
we
will
get
them.
But
there
was
a
comment
there
was
Siam
who
said
they
are
spin
fan
already.
So
that's
very
promising
really
nice
thank.
B
Yeah
I
mean
yeah
I'm,
not
the
best
to
say
this,
but
I'm
gonna
say
this
anyway,
when
I
started
working
with
spin,
which
is
almost
a
year
ago
now,
I
mean
that
immediate,
the
immediate
feeling
you're
getting
into
this
developer
experience
where
and
I
think
it's
it's
hard
to
demo
that
but
I
mean
beyond
having
my
JavaScript
tool
chain
set
up.
I
I
just
need
spin
right.
I
only
need
that
one
executable
that
I
can
just
copy
into
my
machine
and
and
that's
it
and
and
I
hope.
B
You
know
part
of
what
you
can
see
from
the
demo
is
that
I
mean
the
build,
didn't
take
a
long
time.
It's
a
small
application
anyways
but
spin
up
is
you
know
this
is
how
quickly
these
start
and
what's
actually
more
important,
I'm
going
to
show
that
in
a
slide
in
a
second.
Is
that
the
response
speed
for
these
I
think
we
can
even
try
to
you
know
just
try
to
just
call
call
this
guy
a
thousand
times
five
different,
buy
different
clients
like
things
the
response
time
of
these
spin
modules.
B
So
actually,
what
I
did
is
I
just
ran
a
small
mini
load
test
where
I
did
a
thousand
requests
across
five
clients.
You
know
it's
it's
it's
it's
it's
fast,
responding.
I
know
this
is
local
and
I
know
there
is
hardly
any
computation
happening
inside
of
the
component,
but
what's
really
really
interesting
and
I
want
to
show
you
this
on.
A
little
illustration
is,
is
how
spin
sort
of
handle
these
webassembly
components
internally,
so
remember
that
I
talked
about
how
these
small
incises
and
that
they
have
an
incredible
startup
time.
B
That's
actually
part
of
what
you're
seeing
here.
So
if
you
try
to
walk
through
this
process
of
what's
Happening
from
when
I
run,
spin
up
to
I'm
able
to
you
know,
and
until
these
events
are
being
handled
until
the
requests
have
been
picked
up
by
spin-
is
that
spin
up
goes
and
run
another
process,
a
sub
process
to
spin
and
calling
a
spin
trigger
command
and
what
that's
been
trigger
command
does.
Is
it
loads
all
the
individual
components?
Well,
it
loads
the
individual
component
information
that
you
had
in
that
spin.tamil
file.
B
I,
remember
I
said
what
I
showed
before
we
just
had
a
single
component
I'm
going
to
show
you
application
a
little
bit
that
has
four
different
components
in
it,
and
so
what
that
means
is
that,
as
the
spin
says,
these
individual
components
are
being
loaded.
You
know
the
virtual
machine
is
being
created
by
by
wasn't
time,
which
is
the
webassembly
runtime
we
use.
So
each
component
now
runs
in
its
own
little
isolated
environment
there.
So
component
a
here
could
be
the
JavaScript
component.
B
I
just
showed
you
and
I
could
have
other
components
in
there
as
well.
Now
all
that
information
is
now
loaded
and
ready,
but
the
component
itself
is
not
running.
The
webassemd
module
is
still
unloaded
at
this
point
in
time.
It's
not
until
that.
You
know
in
this
case
I
do
a
curl
to
basically
send
an
ACP
request
that
hits
the
spin
trigger
process
that
the
webassembly
runtime
goes
and
load
that
module
from
disk,
and
you
know
handles
the
request
and
unloads
the
module
again.
B
So
each
individual
request
is
a
separate
and
fresh
module
load,
and
that
obviously
have
you
know
it
has
some
opportunities.
It
has
those
opportunities
that
you
know,
if
you
think
about
this
in
context
of
how
you
would
scale
an
application
like
this.
Is
that
they're
really,
like
you
know
the
concept
of
scaling
down
to
zero
as
such
is
at
a
fairly
different
level
in
the
sense
that
well
I
mean
if
you
run
High
scale
enough,
you
need
multiple
machines,
probably
if
there's
a
huge
request
load.
B
So
you
might
want
to
scale
the
number
of
on
the
line
machines
you
have
as
infrastructure,
but
the
individual
component,
you
don't
scale
as
such,
because
they
only
load
and
they
only
do
work
when
requests
are
coming.
So
so
you
know,
and
that's
stuff
we
can
do
because
they
start
so
quickly
and
because
they're
so
small
in
size.
B
I
had
another
point
that
just
totally
slipped
my
mind,
but
I'll
probably
get
back
to
that
one,
but
so
you
know
so
so
so
I
think
that's
that's!
That's
a
good
thing
to
be
reminded
of
when
you
see
this.
Oh
and
I.
Remember
yeah
when
I
say
that
this
open
up
some
opportunities.
There
are
obviously
scenarios
where
you
know
this
isn't
like
running
a
web
server.
You
know
where
you
can.
B
You
can
do
that
here,
because
every
single
request
is
a
fresh
reload,
so
you
need
to
somehow
you
know
offload
your
State
to
something
else
and
we
have
a
solution
for
that
which
is
great,
but
you
know,
but
so
so
you
have
to
think
about
in
that
way
and
I
think
what
I've
come
to
sort
of
acknowledge
over
this
a
little
bit
of
a
year,
I've
been
working
with
these
spin
thingies.
B
Is
that
it's
actually
nice
that
you
know
you
can
have
you
can
have
components
taking
care
of
a
really
really
small
sort
of
you
know
concern
within
your
application,
and
you
don't
have
to
think
about
a
whole
lot
of
life
cycle
things
happening,
and
hopefully
that
will
show
you
when
I,
when
I,
when
I
sort
of
get
into
this
next
application,
that
I
want
to
walk
you
through
that
I
built.
B
That
is
probably
a
little
bit
more
complex
that
well,
it
is
a
little
bit
more
complex
than
the
hello
world
that
I
just
showed
so
before
going
into
that,
let's
just
you
know,
expand
on
what
what
spin
does
beyond
just.
You
know
how
we
execute,
how
how
the
whole
execution
model
is
and
what
I
showed
about
these
templates.
Well,
it's
just
that
one
binary
tool,
as
I
said
you
download
it
and
you
use
that
sort
of
as
developer
tool.
It's
also
how
you
can
you
know,
run
it
on
a
server
or
anywhere
else.
B
Spin
up,
basically,
is
the
way
to
run
your
application.
Now
there
are
opportunity
there
are
projects
out
there
that
enable
you
to
to
run
spin
in
kubernetes
there's
a
project
called
Ron
wasi,
which
enables
you
to
use
spin
as
a
runtime
class
inside
your
kubernetes
cluster.
B
The
same
way,
you
can
do
that
with
Ron
Wazi,
which
is
part
of
it's
part
of
container
D
and
there's
also
another
project
called
kwasum
that
will
sort
of
help
get
things
installed
inside
a
kubernetes
cluster
I'm,
not
sure
we're
going
to
have
time
to
show
that
today,
but
I
know
we
have
a
follow-up
on-demand
session,
where
we
can
dive
a
little
bit
more
into
into
those
those
scenarios
also
and
again,
but
some
of
these
are
early.
B
You
know
those
are
early
experiments
and
and
trying
to
figure
out
how
that
operational
model
of
these
type
of
spin
applications
can
look
like,
but
it's
something
you
can
go
and
do
today
and
Microsoft's
Azure
kubernetes
service
actually
has
a
built-in
support
for
bossy
workloads
among
those
walls
of
workloads
being
spin,
and
if
you
have
tried
the
latest
Docker
desktop
Docker
desktop
did
a
technical
preview
too,
of
wassce
support.
B
Recently,
you
can
also
run
wasi
workouts,
like
spin
directly
on
Docker
desktop,
so
many
ways
of
you
know
sort
of
getting
these
type
of
applications
into.
You
know
either
infrastructure
you
already
know
and
that
you're
comfortable
using
or
that
you
already
have.
You
know
at
your.
You
know
at
the
place
where
you
run
stuff,
okay,
so
that
was
that
was
a
little
bit
about.
You
know
how
how
and
where
you
can
run
these
things.
B
Obviously,
the
last
thing
that
I
almost
forgot
to
mention
is
that
fermion,
the
company
that
that
has
been
building
spin,
a
company
where
I
work.
We
also
have
a
cloud
offering
to
run
spin
applications,
so
fully
managed
Cloud
for
running
spin
applications
as
well
and
I'm
going
to
show
you
that
a
little
bit
how
these
applications
deploy
into
the
cloud.
B
B
No
spin
doesn't
provide
anything
for
logging
outside
of
capturing
standard
output
and
standard
error.
So
if
you,
if
so
it's
not,
it's
really
not
a
concern.
That
spin
goes
into,
which
means
that
you
know
you
would
probably
use
a.
B
Let
me
back
a
little
bit
inside
and
so
so
in
a
spin
application
as
I'm
handling
a
request
and
I
didn't
show
that
here
you
are
able
to
do
outbound
calls
as
you,
you
know,
as
you
handle
requests,
so
so
one
way
of
doing
that
is
that
have
your
component
log
out
as
it
executes.
B
So
basically,
you
write
the
code,
so
you
implement
logging
in
your
component
yourself,
other
than
that
you
would
have
to
you
know
you
have
to
fall
down
to
the
infrastructure
level
and
pick
up
the
log
files
that
spin
are
producing
so
standard
out
and
standard
error
are
being
logged
into
log
files.
So
you
know,
if
you
use
things
like,
is
it
fluent
D?
Those
are
the
types
of
things.
B
I
might
be
a
little
bit
off
of
my
comfort
zone
here,
but
you
know
some
of
those
log
collection,
tooling
things
that
can
pick
up
log
files
that
that
will
be
a
way
where
in
these
infrastructure
is
in
areas
you
can.
You
can
collect
the
data.
A
B
Yeah,
that's
a
really
good
one,
so
I,
you
probably
have
noticed
I'm,
so
I'm
in
I've
always
mentioned
a
few
things.
I
mentioned.
You
know.
Maturity
of
wassi
I've,
mentioned
various
support
for
various
levels
of
maturity
and
support
for
programming
languages,
and
also
specifically
how
our
JavaScript
SDK
is
experimental.
B
A
lot
of
this
boils
down
to
support
for
the
individual
programming
language
being
able
to
compile
to
webassembly,
and
then
the
state
of
the
wassce
specification,
which
are
sort
of
you
know
the
things
that
we
interact
with
in
terms
of
what
we
can
do
from
from
programming
language
point
of
view.
If
you
want
to
be,
you
know
where
you
let's
go
for
those
those
where
you
know
the
system.
Language
is
like,
like
this
particular
rust,
and
also
a
language
like
CNC
plus
plus,
has
far
best
support
for
for
webassembly.
Today.
B
Go
has
very
recently
gotten
I'm,
actually
sure
if
everything
got
got
merged
in
but
go
should
should
also
be
be
there
be
very
close
to.
We
have
been
using
tiny
go
up
until
now,
because
tinygo
had
better
awesome
support
so
far,
but
go
should
be
very
close.
B
If
not
already
there,
if
you
look
at
the
interpreted
types
of
languages
like
JavaScript,
typescript
Python
and
those
there's
a
lot
of
effort
going
on
to
improve
that
right
now
like
basically,
what
what
is
being
done
today
is
The
Interpreter
is
the
one
that
is
being
compiled
on
to
whoever
simply
not
the
actual
code.
So
that
definitely
has
some
important
performance
impacts
there.
So
that's
thing
that
that
needs
to
be
solved,
and
if
you
look
at
things
like
you
know,
Java
and
net
also
have
some
preview
and
experimental
support
at
this
point.
B
So
that's
that's
sort
of
the
programming
language
side
of
things.
The
other
thing
I
think
is
worth
mentioning
is,
was
he
so
was
he
has
a
preview
One
release
right
now
and
some
of
the
main
things
that
we're
looking
forward
to
in
was
a
preview
2
is
to
be
able
to
use
sockets
directly
from
within
our
component.
So
today
the
way
that
we've
solved
this
has
been
is
basically
through
SDK.
B
We
enabled
you
to
do
outbound
connectivity
through
a
certain
set
of
protocols,
so
HTTP
redis,
MySQL
and
postgres,
but
once
we
get
to
the
next
preview
of
Quasi
group
able
to
have
sockets,
which
means
that
you
can
use
any
library
that
relies
on
the
network
connectivity.
So
there's
some
movement
on
the
wassi
side
and
the
wasi
roadmap
to
to
get
to
that.
B
So
I
think
those
are
the
main
limitations
to
be
aware
of.
At
this
point,
whoops
yeah.
B
There
are
yeah,
there
are
a
lot
of
places
we
can
go.
Let's
do
this,
let's,
let's
do
the
spin
one
I'll
just
get
that
down
here
in
the
chat
and
that's
a
good
place
to
start,
and
it
will
help
you
understand
and
read
about
the
the
spin
project.
There
are
some
links
here.
Talk
about
web
assembly
component
model
wasn't
time
and
stuff
that
we
we
build
on.
This
is
this
is
definitely
a
good
place
to
start.
A
Perfect
we'll
get
that
link
to
the
audience
but
sounds
like
a
good
place
to
start
cool.
B
Okay,
so
let's
move
on
and
let's
let's
look
at
something
beyond
that
hello
world
example,
and
let's
probably
go
over
here,
okay,
so
I
build
an
application
that,
let
me
just
show
you
the
application
straight
or
maybe
that's
easier,
and
then
we
can
sort
of
take
a
look
at
the
code
and
how
how
this
all
works
in
a
spin
scenario,
I
have
built
an
application
that
enables
you
to
create
shoplinks.
B
So
it
enables
you
to
create
easily
ways
to
redirect
a
little
bit
of
flaws
in
here,
but
we'll
we'll
get
back
to
that.
So
basically,
what
I
can
do
with
this
application
and
everything
you
see
here
by
the
way
the
front
end
and
everything
is
served
by
a
single
spin
application.
I
can
go
in
and
I
can
say:
hey
yeah
I
want
a
short
link
to
a
cncf
live
webinar
and
that
will
be
a
I.
Don't
have
a
link
handy?
Let's
just
do
this
is.
B
Okay,
I
know
we
don't
need
to
shortening
cncf.io
as
long
as
we
know
it's
IO
and
not
org,
but
but
anyways.
You
know
you
sort
of
get
the
idea
here.
Right,
I
can
go
and
save
these
in
here
and
you
can
see.
I
now
have
a
redirect
and
if
I
click
that
it
takes
me
to
cncf.
What's
also
nice
with
this
small
application
that
I
built
is,
if
we
go
back,
I
have
a
way
to
generate
QR
codes
right.
B
So
there's
something
here
about
a
UI
that
we
present
in
the
browser
there's
stuff
in
here
where
we,
you
know,
generate
QR
codes,
the
stuff
in
here
we
save
State.
So
all
of
these,
you
know
are
things
we
can
build
with
with
spin.
So
let's
take
a
look
at
how
this
application
I'm
just
going
to
go
over
into
my
tech
series
as
well,
and
what
I
want
to
start
showing
you
is
the
Tamil
file,
which
is
that
it's
called
an
application
manifest.
Let's
call
it
an
application
definition
again,
you
can
see.
B
I
have
some
metadata
to
begin
with,
and
that's
not
the
only
relevant
thing
is
there
that
it's
it's
an
ACP
trigger
yeah,
let's
give
spinner
spin
Taylor.
That's
that's
true!
You
wouldn't
you
wouldn't
know
how
many
times
that
thing
comes
up
but
yeah.
B
B
Today
we
have
some
experiments
of
supporting
multiple
trigger
types,
but
in
this
case
they
all
are
so
you
can
see
that
I
have
three
I
have
three
things
in
my
application
in
here,
three
components:
first
of
all,
I
have
an
API,
and
what
you
can
see
is
that
the
route
that
the
serving
API
is
slash-
API,
okay
and
so
that's,
basically,
the
API,
the
crowd
API
from
application
right.
That's
where
I
can
create
a
new
shortening.
That's
where
I
can
list
all
my
shorting
I
can
delete
them.
I
can
get
a
specific
one.
B
So
that's
all
good.
The
next
component
that
I
have
is
my
client.
So
that's
my
front
end.
Now.
You
noticed
up
here
that
you
may
have
noticed
that
this
is.
This
is
a
a
wasn't
file
API
that
wasn't
filed
serving
this
component
and
you
can
see
it
has
sort
of
a
a
local
disk
reference
which
means
that
this
is
something
that
builds
locally
now
with
the
client
component
back
here,
it's
a
little
bit
different.
Now
this
is
not
a
component
that
I
built.
B
So
what
I'm
able
to
do
here
is
I'm
actually
able
to
take
components
that
someone
else
built
and
put
it
in
and
make
it
part
of
my
application
and
that
sort
of
enables
me
to
you
know
very
easily:
have
these
sort
of
generic
reusable
components
so
I
can
construct
applications
in
a
fairly
quickly
way.
Now,
for
my
client
here,
what
I'm
using
is
something
called
the
spin
file
server
and
all
that
is
is
file
server.
So
basically,
this
will
serve
a
set
of
files
and
that's
what
I
use
for
my
UI.
B
So
this
component
has
this
configuration
down
here
where
it's
able
to
serve
a
set
of
files.
Now
this
is
part
of
you
know.
I
mentioned
the
security
model
of
webassembly
a
little
bit
earlier,
and
it's
it's
what's
what's
called
a
capability-based
security
mode,
which
means
that
a
webassembly
any
of
these
web
assemblies
that
I
have
here
there.
B
This
is
the
only
web
assembly
that
are
actually
able
to
access
my
file
system
when
it
runs,
and
the
only
reason
why
I
can
access
is
because
I
configure
it
with
access
to
a
certain
set
of
files,
in
this
case
I'm
configuring
to
access
the
directory
call
client.
B
So
so
the
cable
based
security
model
is,
you
know,
I've.
It
means
that
the
model
the
the
web
assembly
component
only
gets.
You
know
access
to
what
you
specifically,
you
know
enable
it
to
have
access
to
it's
not
about.
You
know
permissions
of
the
use
of
running
the
process.
It
is
actually
you
cannot
get
out
of
that
virtual
machine
or
the
sandbox
inside
the
webassembly
runtime,
unless
you
explicitly
are
given
the
the
permission
to
do
so.
B
It's
the
same
thing
that
if
I
had
a
component
that
needed
to
reach
out
to
an
HTTP,
endpoint
I
would
have
to
in
here
specify
specifically
which
HTTP
endpoint.
Can
this
specific
component
call?
So
it's
a
very
fine-grained
security
model
in
here
and
what
I
really
like
about
this
model
from
a
user
point
of
view?
Is
that
I
mean
the
default?
Is
that
these
can't
do
anything
but
just
live
with
inside
themself
and
their
own
little
memory
space
unless
I
explicitly
tell
them
to
do
so
or
being
able
to
do
so?
B
B
My
last
component,
then,
is
something
that
I
built
myself,
and
this
is
the
one
that
is
actually
doing
the
redirect
and
what
you
may
have
noticed
about
this
component
and
also
the
API
component
is
that
they
both
have
this
thing
called
the
key
Value
Store
defined
and
the
key
value
store
is
something
that's
built
into
spin,
where
we
enable
you.
You
remember
that
I
mentioned
earlier,
that
anything
is
a
freshly
reload
of
a
component.
So
so
I
don't
have
shared
memory.
B
I,
don't
have
memory
persisted
between
handling
request,
which
means
that
if
I
need
to
store
anything
between
my
request,
I
need
a
place
to
store
them
so
well
with
spin,
we
provided
a
key
value
store
for
you,
so
there's
a
simple
API
that
you
can
use
from
code
to
store
keys
and
values
and
retrieve
them
back,
and
they
can
actually
be
shared
across
components
inside
an
application.
So
in
this
case
the
API
component
has
access
to
the
default
key
value
store
and
the
redirect
component
is
accessed
to
the
same
key
Value
Store
okay.
B
So
that
was
a
little
bit
of
some
of
the
capabilities.
These
spin
things
sping
applications
can
have
and
what
they
provide
all
of
these
by
the
way
or
the
two
that
I
haven't
written
in
in
in
in
Rust.
So
you
can
see
we're
using
cargo
commands
here
as
a
way
to
to
build
to
build
the
components.
B
B
There's
a
bunch
of
use
statements
up
here
in
the
beginning,
because
I
I
have
some
external
libraries
or
crates
that
I
use
I
have
a
structure
defined
in
here
is
basically
my
name:
I
have
a
bit
of
helper
functions,
create
a
random
string.
This
is
always
nice
and
then
this
is
the
handle
redirect
command.
That
is
annotated
with
this
ADP
component
macro,
and
if
you
remember
what
this
looked
like
in
the
Javascript
file,
I.
A
B
This
is
not
about
learning
multiple
programming,
which
is
sort
of
give
you
an
idea
that
it's
the
same
model.
We
have
I
had
a
handle
request
function
in
JavaScript,
but
basically
a
request
was
handed
over
to
me.
I
returned
some
stuff,
it's
the
same
model
in
Rust,
I,
get
a
request
and
I
do
stuff
and
I
return
a
result
right
so
HTTP
and
HTTP
out.
B
But
what
I
can
do
in
here
is
because
I
have
that
key
value
store
in
my
API
I
can
I
can
open
my
store,
so
you
can
see,
there's
an
easy
API
to
just
open
the
default
store
that
is
available
there
and
then
I'm
gonna
figure
out
whether
a
post
came
in
whether
a
git
came
in
whether
the
lead
came
in
through
the
HTTP
request.
B
If
it's
post,
I'm
gonna,
you
know
get
the
body
of
the
post
request,
I'm
gonna
serialize,
that
into
a
link
and
then
I'm
going
to
use
the
store.set
API,
which
basically
means
now
I'm
going
to
store
this
into
my
key
Value
Store.
If
everything
is
okay,
we're
gonna
return
a
HTTP
created
code
back
to
the
caller.
B
You
know
what,
as
we
go
along,
let's
actually
just
see
this
in
action
and
it
will
do
spin
up
and
we
already
have
spin
running
somewhere
so
didn't
break
things.
We
just
didn't
make
things
work
on
the
first
go,
but
it
was
folks,
let's
call
the
API
so
basically
I'm
just
calling
Paul
3002.
Now
you
can
see
this
is
running
at
3002
and
you
can
see
my
API
down
here
is
running
on
3002
and
basically
what
because
this
is
going
to
be
my
my
get
command.
B
We
can
see
that
what
we're
doing
when
we're
getting
is
that
we
just
we're
checking
if
there's
any
query,
parameter
that
I
added,
if
I
didn't
add
any
we're.
Basically
just
gonna
go
and
get
all
the
keys
in
our
store
and
we're
just
going
to
iterate
through
this
and
get
all
our
records
out.
Probably
want
to
do
this.
B
So
if
I
went
in
and
I
asked
my
API
for
one
of
the
specifics
you
can
see,
I
will
now
get
that
up.
22.
B
1
there
you
can
see
I
get
that
one
specific
reader
from
my
API
and
again
I
want
to
just
call
out,
because
this
is
always
so
funny
as
we
run
these
things,
how
quickly
things
work.
Basically,
as
I
as
I
run
this
command,
this
webassembly
module
gets
loaded,
it's
gonna
evaluate
the
get
command.
The
query
parameter:
it's
going
to
open
that
key
value
store,
which
locally
is
backed
by
no
another
nose,
my
sequel
instance
on
disk.
So
it's
actually
gonna
go
down
to
that.
B
Mysql
file,
wrap
the
record
and
send
it
back
to
me
and-
and
it
just
happened,
really
really
quickly
so
yeah.
That's
always
it's
always
a
joy
okay.
So
basically,
this
is
just
a
crowd
API,
and
that
is
that
is
what
that
is.
What's
interesting
about
this
local
version
of
my
application
here,
I'm
just
gonna
go
into
the
admin
interface
is
that
you
might
notice
that
I
didn't
have
that
QR
code
generation
function
in
here
so
I
can
still
go
and
edit
these.
B
If
I
want
to-
let's
just
call
this
edited
for
now,
so
now
we
can
see,
is
edited,
but
I
don't
have
that
keyword
functionality.
So
let's
say
you
know:
I've
started
developing
this
application
and
I
got
into
this
point
where
I
need
to
add
this
extra
functionality.
How
can
I
go
ahead
and
do
that?
B
I
can
use
that
for
spin
new
or
spin
add
command.
Now
it
so
happens
that
someone
very
friendly
who
is
well,
it's
actually
me
anyways.
They
did
one
of
these
components.
I
actually
created
a
spin
component,
which
is
a
QR
code
generator,
which
is
just
an
HTTP
component
that
if
you
know,
if
you
curl
that
component,
if
you
send
that
nxtp
request
to
that
component
and
anything
you
put
into
the
URL
is
an
argument-
will
come
back
as
a
QR
code.
B
So
the
QR
code
that
I'm
showing
you
here
in
this
GitHub
site,
where
this
component
lives,
is
taking
you
to
GitHub
com,
ferment
Spin,
and
this
is
actually
something
that
I
want
to
use
my
application
because
I
want
to
have
you
know
a
way
of
generating
QR
codes
for
those
those
redirects
that
I
have.
So,
in
order
for
me
to
do
that,
I
need
to
First
go
ahead
and
install
this
as
a
template.
So
I
do
spin
templates
installed
I
point
to
that
GitHub
repository
and
you
can
see.
B
B
B
B
B
What
we
will
get
back
now
is,
we
should
be
able
to
get.
This
is
an
SVG
of
a
QR
code
to
get
you
to
cncf.io,
so
I
now
have
that
functionality
as
part
of
my
application
by
basically
just
taking
that
remote
component
and
adding
it
to
my
application.
B
So
I
did
do
a
little
bit
of
trick
here
to
prepare,
because
obviously
the
next
thing
that
I
would
go
ahead
and
do
now
I,
don't
know,
but
the
next
thing
that
I
would
go
ahead
and
do
is
somehow
implement
this
in
my
client
right.
This
is
the
HTML
that
I'm
using
for
my
client
and
I
did
go
ahead
and
cheat
a
little
bit
and
I.
Think
I
should
have
something
in
here
that
I
just
needed
to
that
section
up
here.
B
Sorry,
that's
in
the
Javascript
file
Hey
there
you
go
let's
uncomment
this,
and
so
so
the
idea
is
right.
That
I
am
now
I've
added
some
functionality
to
my
client
that
enables
a
QR
button
and
when
I
click
the
QR
button
I
think
I
have
that
down
here.
B
That's
the
short
link,
that's
the
edit!
That's
oh!
This
is
one
right
when
I
click
that
button
we'll
go
and
encode
the
URL,
which
is
the
key
that's
in
there
and
then
we'll
call
that
QR
endpoint
right
and
we
will
show
a
modal
that
will
give
us
the
QR
code.
So
let's
go
ahead
and
I
just
so.
I
I
change
the
static
file,
which
means
I
just
have
to
save
that
file.
B
I,
don't
have
to
rebuild
my
application
because
spin
will
just
serve
serve
those
35
to
my
file
server,
so
I
can
go
back
into
the
admin.
Interface
and
I.
B
Because,
let's
see
if
this
one
will
take
us
to
developer
ferment.com
spin
and
hopefully
I
can
show
I
need
to
edit
out
of
this
okay.
This
is
obviously
yeah.
Sorry,
this
is
going
to
run
from
my
local
machine,
so
you
won't
get
the
full
Q
either,
but
it
is
a
valid
QR
code.
I
can
I
can
tell
you.
B
Okay,
so
I
hope
this
gave
a
good
idea
of
you
know
what
you
can
do
with
spin.
What
spin
is
what
webassembly
is?
You
know
some
easy
hello
world
to
ease
you
into
developing
your
spin
applications
a
little
bit
more
of
a
complex
type
of
application.
How
you
can
use
this
idea
of
components
and
spin
applications
to
share
functionality,
and
you
know
we
hope.
We
hope
that
more
people
want
to
join
that
ecosystem
of
having
these
small
components
that
just
make
it
easy
to
compose
applications.
B
Where
you
know
you
can
bring
component
in
any
programming
language
and
make
it
part
of
your
spin
application
yeah.
So
do
we
have
more
questions?
And,
yes,
we
I
think
we're
nearing
the
one
hour
mark.
A
A
Better
yeah,
if
anyone's
typing
away,
please
send
it
now
and
while
we
wait
to
see
if
anyone
is
gonna,
send
a
question
in
I
have
a
question:
what
will
the
future
for
when
assembly
or
spin
look
like.
B
Yeah
so
I
I
touched
a
little
bit
upon,
you
know
languages
and
supporting
languages,
and
definitely
you
know
having
better
support
for
for
the
languages
that
are
so
bought
somewhat
supported.
Today
we
know
where
we
get
fully
on
par
with
performance
and
those
things
we
are
heavily
invested
in
both
the
JavaScript
and
python.
At
this
point,
because
we
believe
that
a
lot
of
developers
would
like
to
have
those
languages
being
available
in
a
framework
like
this,
so
that
is
definitely
the
the
there's
some
work
that
we
want
to
do
there.
B
On
the
web
assembly
system
interface.
There
is
a
really
good
roadmap,
actually
in
general
I'm,
just
going
to
do
a
filter.
There
was
a
conference
two
weeks
ago,
called
wasam
IO
and
there's
a
there's
a
a
lot
of
very,
very
great
Talks
on
YouTube.
Now
so
it
wasn't.
Io
I
don't
have
a
link
handy,
but
it
should
be
fairly
easy
to
find
that
one,
and
there
are
some
talks
that
talk
about
the
roadmap
of
wassi,
so
particularly
the
the
socket
supports,
are
being
able
to
use.
B
You
know
normal
database
libraries
and
drivers
that
you
use
today
in
your
applications.
Being
able
to
to
support
all
of
that
which
is
somewhat
hard
today,
is
definitely
going
to
be
good
and
then
the
the
big
one
further
out
is
something
called
the
webassembly
component
model.
I
mean
we
have
a
minute
left,
so
it's
really
really
hard
to
go
into
that.
B
So
you
know
the
QR
code
generator
that
I
here
used,
as
with
you
know
and
exposed
to
an
HTTP
endpoint
I
could
actually,
even
though
that
would
have
been
written
in
a
different
programming
language
than
what
I
wrote.
My
client
in
I
could
just
reference
it
directly
from
within
my
client
as
a
library
sort
of
in
that
sense
right.
That's
the
whole
idea
of
the
component
model
to
get
to
that
point
where
libraries
written
in
different
programming
languages
can
be
used
by
by
one
another.
So
that
will
definitely.
B
You
know
that
that's
the
big
change
and
we're
probably
going
to
see
more
of
that
in
the
next
six
months
or
so,
and
and
how
that
would
impact
the
spin
developer
model
and
application
model
like
it'll
be
interesting
to
see,
but
but
that
that
will
be
a
a
bright
future.
Once
we
get
to
that
point,
great.
A
I,
like
it
ambitious
goals,
are
good
and
looking
forward
to
seeing
that
bright
future
as
we
go
along
as
well,
and
I
saw
that
Karen
also
linked
the
sessions
to
the
chat.
So
if
anyone
wants
to
check
them
out,
please
use
that,
but
that's
all
that
we
have
time
for
today.
A
So
let's
start
wrapping
up.
So
thank
you.
Everyone
for
joining
the
latest
episode
of
cloud
native
live.
It
was
really
great
to
have
a
session
about
building
serverless
applications
using
Spin
and
webassembly.
I
really
love
the
introduction,
as
well
as
the
questions
from
everyone
today,
especially
love
the
comment
great
to
see
you
giving
us
thin
a
spin
extra
points
for
that,
but
in
the
coming
weeks
we
have
more
great
sessions
coming
up.
So
thank
you
for
joining
us
today
and
we'll
see
you
next
week.