►
Description
wasmCloud is a platform for writing portable business logic that can run anywhere from the edge to the cloud, that boasts a secure-by-default, boilerplate-free developer experience with rapid feedback loop.
https://wasmcloud.com
A
B
B
So
my
background
is
in
parallel,
Computing,
mostly
doing
all
sorts
of
things,
mostly
about
developer
experience
and
making
models
that
are
easier
for
programmers
and
now,
since
a
few
years,
back
I'm
more
into
cloud
computing
and
serverless,
and
also
looking
to
make
life
easier
for
developers
and
I
found,
wasn't
Cloud
first
I
went
to
crustlet
and
and
using
webassembly
in
kubernetes,
but
then
I
found
wasn't
that
and
I
I
immediately
found
it
appealing.
So
that's
what
I'm
focusing
on
on
our.
A
A
That's
right,
yeah
and
I
actually
have
a
great
discussion
for
a
little
bit
later
after
demos.
To
talk
about
that.
So
that's
great.
Thank
you
so
much
for
for
doing
an
introduction.
Now
we
can
move
on
to
I
think
that's
all
the
new
new
members,
so
we
can
move
on
to
demos
and
I.
Think
Taylor
has
yet
again
something
very
exciting
to
share.
C
Yes,
I
do
so:
let's
go
ahead
and
talk
about
this
exciting
new
idea.
We
have
so
we've
I've
been
working
on
a
couple
of
us.
Maintainers
been
working
on
a
proof
of
concept,
because
one
of
our
goals
has
always
been
to
be
part
of
the
Community
standards
that
are
out
there,
but
the
problem
was
is
wasm,
is
so
bleeding
edge,
I
like
to
call
it
hemorrhaging
Edge
that
we
often
like
they're.
C
Just
there
were
so
many
gaps,
I
mean
we
just
barely
got
sockets,
which
is
great
that
we
have
it
now
and
really.
We
we've
really
only
started
to
see
some
real,
concrete,
solid,
relatively
quick
progress
in
the
last
six
months,
and
so
because
of
that,
like
we,
we
had
to
do
what
we
had
to
do
to
make
things
work
such
that
we
could
actually
have
a
real
system
because
you've
always
been
able
to
with
lots
of
cloud
build
something
real
with
it.
But
now
we
have
something
coming
up.
C
If
you
haven't
heard
of
the
component
model,
that's
something
that
is
very
interesting
and
is
is
coming
up
relatively
quickly
and
is
gaining
a
lot
of
community
traction,
and
so
that
is
where
this
is
going
to
go
today.
So
the
component
model
is
basically
something
that
allows
you
to
take
arbitrary,
webassembly
modules
that
import
or
export
specific
specific
functions-
and
you
can
say
like
I-
would
like
to
import
these
or
I'd
like
to
export
these
and
then
you're
able
to
take
those
modules
that
satisfy
those
contracts.
C
Just
like
we
have
contracts
in
wasm
cloud
and
glue
them
together,
and
so
with
that
we've
been
thinking
of
a
way
of
how
we
can
do
this
and
so
we're
working
on
a
blog
post.
That
is
going
to
explain
all
this
as
well.
We
just
had
a
wrench
thrown
in
today
because
once
again,
hemorrhaging
edge
and
a
bunch
of
things
changed
literally
two
days
ago,
but
I'm
going
to
show
you
what
we
got
to
and
then
I'm
going
to
update
everything
with
what
we
had.
So
let
me
share.
C
C
C
What
we're
able
to
do
is
split
things
up
into
four
different
webassembly
modules
and,
as
you
can
see
here,
the
only
one
that
actually
matters
is
the
business
logic
and
the
rest
of
these
things
can
be
provided
by
the
person
doing
the
contract.
So,
let's
see
what
exactly
this
looks
like.
So
let
me
come
over
here
and
do
this.
C
Is
the
preview
of
the
blog
post
so
got
to
see
that
I
guess
let's
go
ahead
and
start
looking
at
this
I'm
going
to
enhance
a
bunch,
and
let
me
move
this
bar
up
out
of
the
way
so
right
here
you
we
have
what
are
called
wit
files.
This
is
webassembly
interface
types,
that's
where
the
width
thing
comes
from.
C
So
each
of
these
contracts
explain
like
what
something
can
import
or
export
inside
of
Any
Given,
webassembly
module,
and
so
with
this
we
have
four
new
ones.
So
I'm
going
to
start
from
the
very
top
of
the
diagram
that
we
were
looking
at
right
here:
the
HTTP
server
wasm.
So
this
is
basically
an
HTTP
server
receiver
and
it's
going
to
implement
the
wazenbus
receive
thing.
This
receives
a
message
and
returns
back
an
opaque
payload.
We
might
change
up
what
this
looks
like
in
the
future.
C
C
And
so
when
you,
when
you
go
down,
you
actually
look
at
the
actor.
The
actor
is
the
thing
that's
going
to
be
implementing
the
HTTP
server
contract
and
it
says:
oh,
hey,
here's
this
handle
request
and
it's
the
thing
that
actually
takes
the
request.
Does
everything-
and
in
this
case
it's
going
to
be
doing
the
key
value
increment.
This
is
our
key
value,
counter
example,
and
so
it's
going
to
be
calling
once
again,
it's
imported
a
key
value
thing
and
exported
an
HTTP
server.
C
So
if
we
go
back
and
look
at
those,
you
see
HTTP
server,
it
has
the
HTTP
request
the
response
and
then
the
handle
request
function
and
you
have
the
key
value
which
we
strip
down.
Just
to
be
increment
for
this
specific
proof
of
concept,
so
then
that
all
this
code
right
here
looks
almost
exactly
like
what
we
had
before
with
the
key
value
with
the
the
KV
counteractor.
But
the
difference
is
there
is
absolutely
no
wasn't
Cloud
specific
code
up
here.
All
you
see
is
Imports
directly
from
the
generated
with
bindings,
so
that
means
anytime.
C
There
is
a
wit
binding
for
any
language
you'll,
be
able
to
write
this
in
any
language
and
bind
it
directly
to
or
and
Export
it
out
and
then
be
able
to
connect
it
in
with
everything.
So
there
is
zero
was
on
thought
specific
code.
Now
this
has
a
few
distinct
advantages,
and
hopefully
we're
going
to
see
if
we
can
actually
do
this
when
we
fully
implement
it,
but
it'd
be
really
cool
if
we
can
even
make
it
so
that
this
is
interchangeable,
you
could
technically
run
it
anywhere.
C
That
has
the
same
width
contract
but
either
way
you'll
see.
There
is
no
was
in
Cloud
specific
code
here
and
the
other
two
you
can
see
are
are
going
to
work
very
similar.
You
have
the
key
value
one
and
it
has
the
increment
function
that
it
exports
for
us
that
actually
does
the
the
thing
to
increment
it,
and
it
calls
this
wasn't
bus,
send
method,
which
is
that
last
component
in
our
in
that
diagram,
I
had,
which
is
what
can
send
something
to
the
host
for
for
the
proof
of
concept.
C
Here
we
just
are
using
like
an
FD
right,
but
we
will
expose
a
function
from
the
host
into
the
sender
to
be
able
to
do
it.
Now,
that's
a
lot
of
stuff.
What
does
this
all
mean?
In
the
end?
What
we're
able
to
do
is
actually
bind
every
single
one
of
these
together
and
and
put
them
into
a
single
web
assembly
module.
C
So
what
this
will
now
be
is
a
user
will
code
up
their
actor,
the
KV
counter.wazen,
and
then
the
contract
will
be
providing
these
other
web
assembly
modules
and
the
wasem
bus
sender
will
be
provided
basically
by
core
was
on
cloud
and
then
everything
can
get
glued
together
to
be
put
together
into
a
compiled,
webassembly
module.
That
is
then
run
to
be
the
the
actor.
You
know
what
this
does.
Look
like
in
the
end,
I'll
show
it
actually
running.
C
C
And
you
can
see
right
here
that
we
got
a
message.
This
link
name
default
contract
name
message
is
all
coming
from
that
last
webassembly
module
in
the
in
the
stack
that
was
all
glued
together
and
then
you
can
see
that
our
our
it's
receiving
a
response
out
of
the
webassembly
module,
which
is
the
final
body
with
the
response
data
that
it's
expecting.
C
So
basically,
this
allows
us
to
have
something
extremely
modular,
that
we're
able
to
then
swap
out
and
glue
things
together
and
makes
it
so
that
we
no
longer
have
to
create
a
separate
was
and
bus
RPC
per
per
language.
So,
instead
of
having
to
now
like,
we
created
the
go
one-
and
there
was
this
all
this
effort
to
put
into
it
now
all
we
do
is
we
can
write.
C
Can
be
writing
it
in
python
or
go
or
whatever,
and
it
doesn't
really
matter
if
the
other
components
were
written
in
rest,
and
so
this
follows
a
lot
more
along
the
lines
of
what
webassembly
and
the
component
model
is
supposed
to
do.
So
that
is
like
a
huge
fire
hose
of
information
and
I'll
go
ahead
and
stop
sharing
for
now.
Just
so
I
can
like
see
everybody's
faces
and
interact
and
do
the
chat,
but
anyway,
so
let
me
go
back
through
chat
and
see.
If
there's
any
questions.
C
Yes,
the
Smithy
will
go
away.
Bye,
bye,
Smithy,
that's
one
of
the
side
effects
of
this,
and
so
that
makes
it
a
lot
easier,
because
now
all
these
contracts
are
defined
using
the
similar
format
that
anyone
else
in
the
webassembly
community
is
using.
And
yes
because
Jordan
learned
it,
we
did
definitely
want
to
switch
it
just
because
we
want
to
keep
him
on
his
toes.
That's
what
keeps
Jordan
at
his
best
anyway.
Let's
see.
C
C
So
here
in
the
in
the
KV
counter,
this
is
what
your
actor
currently
looks
like.
Okay,
so
you
have
all
the
imports
from
our
interfaces
in
the
Watson
bus
RPC.
But
then
you
just
have
function,
handle
request
and
it
has
this
logic.
Now,
let's
compare
that
to
what
it
looks
like
looks
like
in
the
new
version.
C
Yeah,
so
all
of
this
is
available
in
the
spike
wit
interfaces
branch
on
the
actual
examples
repo.
So
you
can
take
a
look
at
this
code
directly,
but
if
you
look
at
your
actor
in
comparison
to
what
we
just
saw,
it
is
almost
the
exact
same.
It's
a
much
Slimmer
import
section.
The
code
is
basically
all
the
same
and
works
the
same
way.
So
I
wouldn't
worry.
If
you're
someone
who's
working
on
a
bunch
of
actors,
this
won't
actually
be
too
much
of
a
breaking
change
for
the
actors
themselves.
C
You'll
have
to
delete
a
few
lines.
You'll
have
to
use
with
buying
gen,
but
otherwise
it's
going
to
remain
mostly
the
same.
The
main
breaking
change
will
just
be
that
with
the
new
system
we
won't
be
able
to
run
the
old
actors,
so
you'll
have
to
compile
them
to
this
new
thing,
but
the
work
on
actors
shouldn't
really
be
affected
too
much.
C
And
looks
like
Matt's
had
a
question
too
yeah.
There's
no
need
anymore
for
specific,
wasn't
Cloud
code
generation
with
with
whitbine
Gen
like
this
you'll
have
to
use
our
interfaces
and,
like
I
said
they
could
end
up
being
custom
interfaces
for
wasm
cloud
because
we
have
to
like.
We
haven't,
accounted,
for
example,
how
to
include
link
name,
but
they
will
just
all
be,
using
wit
and
the
wit
bind
gen
stuff
rather
than
custom
code
gen
that
we've
had
to
do
before.
A
Dad
in
there
I
do
have
something
to
add
and
I
just
want
to
say
that
Matt's
said
in
the
chat.
This
is
so
cool
I,
don't
know
if
we
published
the
chat
alongside
video
on
on
YouTube,
so
I
had
to
bring
it
up
now.
One
thing
that
I
was
thinking
about
is,
since
this
is
a
this
is
a
breaking
change.
People
are
gonna
have
to
recompile
their
actors.
D
D
A
C
Yeah
I
mean-
and
it's
like,
we'll
be
able
to
introspect
the
modules
to
be
able
to
tell
like,
if
something's
doing
it,
the
old
way
and
like
we're,
there's
a
whole
another
thing
around
implementing
this
that
we're
going
to
have
to
improve
a
lot
of
the
developer
experience
side
of
this
so
to
be
able
to
distribute
things.
This
is
why
we
added
experimental
support
for
bindle
in
the
first
place.
C
Bindles
allow
you
to
distribute
all
of
these
things
together,
because
to
compile
all
this,
you
have
to
have
the
interface
available
you
and
then
you
have
to
have
the
different
modules
available
and
and
put
them
together,
and
so
Bindu
will
have
to
be
used
to
to
distribute
this.
So
we're
going
to
have
a
bunch
of
like
developer
experience,
things
that
also
need
to
be
in
place
before
we
actually
swap
things
over.
C
But
we
wanted
to
show
this
because
we
just
wanted
to
prove
that
it
could
be
done
and
explain
what
we
see
the
future
of
of
this
in
wasm
Cloud
as
and
so
it
should
like.
It
should
give
you
at
least
some
excitement
about,
like
oh,
hey,
like
I'm,
not
going
to
have
to
worry
about,
wasn't
Cloud
specific
code
anymore,
because
it's
now
all
just
inside
of
webassembly,
which
is
really
cool
to
me.
D
C
Okay,
well,
that's
it
for
me.
If
anyone
has
any
questions,
I'm
gonna
have
to
drop
here
soon,
but
I
will
be
available
on
the
awesome,
Cloud
slack
and
then,
once
again
there
will
be
a
blog
post
and
I'm
just
working
with
some
of
the
people
over
the
bytecode
alliance
to
figure
out
like
if
there's
a
way
to
update
to
things
right
now
and
I
actually
just
got
an
answer.
It
looks
like
it's
probably
not
right
now.
C
This
is
welcome
to
the
hemorrhaging
hemorrhaging
Edge
everybody,
so
we'll
I'll
probably
publish
it
as
is,
and
that
will
give
people
a
detailed
explanation
of
how
everything
works,
code,
samples
and
the
like.
So
anyway.
Sorry
for
the
long
demo
I
try
to
keep
him
short,
but
this
was
a
big
one
and
it
took
a
lot
of
explanation.
So
hopefully,
people
found
it
valuable.
A
C
Yeah
to
it,
I
mean
here's
the
thing
most.
The
people
here
in
this
call
are
developers,
so
you
all
know
how
this
feels
like
we
tried
something
that
we
weren't
sure
if
it
was
going
to
work
and
it
worked,
and
it
is
real
cool,
so
we
had
to
share
it
with
people
so
that
people
knew
what
was
going
on
and
just
also
to
nerd
out
with
us.
So
this
is
future,
but
I
mean
if
I
personally,
this
is
not
speaking
for
the
entire
project.
C
A
A
Alrighty,
if
anybody
ever
you
know,
has
a
as
a
demo
that
they
want
to
share,
please
feel
free
to
reach
out
ahead
of
time
too,
and
slack
you're,
saying
hey,
you
know,
I
have
this
idea,
it
would
take
a
couple
of
minutes.
I
want
to
show
it
off,
just
feel
free
to
ping.
You
know
me
or
Kevin
or
Liam
or
whoever
on
the
WASP
Cloud
maintainer
team,
and
we
can.
A
All
right,
we'll
pass
demos
I
have
a
quick
thing
for
the
community
that
I
mentioned
last
week,
but
I'll
just
bring
it
up.
Real
quick
again
was
in
cloud
or
the
company
behind
a
lot
of
the
who
employs
a
lot
of
the
awesome
cloud.
Maintainers
cosmonic
is
going
to
be
a
silver
sponsor
at
open
source
Summit,
that's
in
Austin.
A
So
if
anybody
and
I
think
it's
I
think
it's
next
week
next
week
all
week,
so
if
anybody's
going
to
be
in
Austin
or
around
there,
June
21st
to
the
24th,
Liam
and
Taylor
are
going
to
be
there.
So
please
go
check
out
the
cosmotic
booth
say,
say:
hi
and
engage
if
you're
going
to
be
at
this
conference.
We're
looking
forward
to
doing
another
thing
in
person.
A
A
Awesome
well,
we
can.
We
can
share
those
at
the
end
too,
if
you
think
about
them
now,
something
that
came
up
in
our
slack
I
think
it
was
yesterday.
Jordan
Jordan
brought
it
up
about
Community
actors
or
Community
capability
providers.
You
know
when
somebody
who's
not
on
the
maintainer
team
is
contributing
a
or
somebody
who's,
not
on
the
waslam
cloud
team
is
contributing
a
maybe
an
example
actor
or
a
wasm
cloud
capability
provider.
Where
does
that
go?
A
You
know
we,
for
example,
we
have
Matt
sproerson
contributing
the
file
system
provider
which,
like
he
said,
is
kind
of
sitting
in
a
PR
into
the
capability
provider's
repo.
We
have
Matt
Joe
bride,
who
is
writing
the
key
value
implementation
of
the
Dynamo
or
a
key
value,
implementation
for
dynamodb
and
AWS?
That
one
is
pretty
much
ready
to
go
and
his
personal
Repository,
and
so,
as
we
kind
of
scale
up.
Where
do
these
providers
Go
I
mean
our?
A
Our
team
only
has
released
a
handful
of
capability
providers
and
honestly,
the
primary
reason
for
that
is
just
because
we
don't
have
all
the
all
the
Time
in
the
World
to
write
all
of
these
providers
and
and
maintain
them
to
the
level
that
we
need
to.
So,
if
we're
putting
out
something
like
the
HTTP
server
provider,
something
that
so
many
examples
and
and
apps
use
that
use
was
in
Cloud.
A
We
need
to
make
sure
that
it's
high
performance
and
doing
the
things
that
are
best
practices
for
wozn
cloud
and
that
we're
you
know
actively
updating
this
and
maintaining
it.
So
it
brought
Jordan's
question
brought
up
a
good
point.
I
thought
this
would
be
a
great
thing
to
discuss
in
the
community
call
because
you
know
the
people
who
are
here
are
the
most.
Some
of
the
most
engaged
people
in
the
community
and
I
have
a
couple
of
ideas
for
where
this
may
go.
A
When
there's
capability
providers
or
even
I,
think
it'll
be
a
less
common
case
to
have
a
standard
actor
that
multiple
people
can
use.
Though
you
know,
of
course,
Walton
cloud
has
full
support
for
that.
If
you
have
like
a
little
actor
that
just
does
a
core
piece
of
logic,
now
there's
a
couple
of
places
that
it
could
go
right.
We
have
in
the
Watson
Cloud
repo.
We
have
the
awesome
laws
and
Cloud
list.
This
has
and
I
see.
Kevin.
You
have
your
hand
raised
I'll,
just
scrap
this
a
little
bit
up.
A
A
D
We
can
have
our
actors
reuse,
those
as
well,
without
having
to
worry
about
what
language
they
were
written
in.
So
let's
say
you
know:
I've
got
a
bunch
of
actors
that
all
that
I
want
to
all
have
access
to.
You
know,
let's
say:
there's
some
machine
learning
math
that
I
want
them
all
to
have
access
to,
but
that
math
comes
in
a
rust,
crate
and
I'm
writing
my
actors
in
go.
D
I
can
now
with
the
component
model,
build
a
component
that
just
allows
me
to
expose
that
function
that
was
written
in
Rust
and
then
I
can
link
it
to
all
of
my
go
actors
and,
assuming
the
you
know,
our
distribution
ecosystem
supports.
It
will
be
able
to
make
those
types
of
shared
components
available
and
you
know
publish
those
on
bundles
and
things
like
that
and
so
I
think
it's
going
to
open
up
a
a
really
revolutionary
way
of
sharing
libraries.
F
I
think
what
becomes
incumbent
in
that
kind
of
model
and
that
sort
of
world
is
trust
and
and
sort
of
validation
and
verification
and
I
haven't
socialized
this
at
all.
But
I'll,
just
you
know,
share
it
freely
and
see
what
people
think
I
think
that
I
love
The
Nomad
proposal,
where
there's
like
a
community
section
but
I,
think
this
early
in
the
life
cycle
of
everything
that,
if
you
know,
mats
and
yeah
Matt
and
other
folks
that
are
out
developing
capability
providers.
F
If
there
is
a
process
for
them
to
become,
you
know,
wasn't
Cloud
official,
because
I
think
sort
of
the
value
that
we
would
provide
as
a
team
and
as
a
community.
Is
that
it's
something
that
we're
all
taking
shared
responsibility
for
and
there's
a
central
place
to
provide
feedback
and
changes
and
requests?
And
this
would
go
for
maybe
even
Kristoff's
the
wasem
cloud
ml
stuff.
F
And
then,
when
we
get
these
things
in
a
shared
repository
long
term,
they
would
be
signed
centrally
by
the
wasmcloud
community
keys
and
that
sort
of
has
its
own
sort
of
authenticity.
That
comes
with
it
because
all
of
our
packages,
all
of
our
capability
providers,
Etc,
could
be
all
signed
with
the
same
sort
of
group.
I,
don't
know
if
there's
any
reaction
to
that.
E
Foreign
I
think
so
my
point
in
asking
was
right:
being
hemorrhaging
Edge
as
Taylor
says
right,
a
lot
of
companies
are
going
to
require
to
be
one
convinced
to
to
buy
in
you
know
before
we
have
like
this
large
community
developers
working
on
it
as
their
daily
job
right.
So
before
I,
you
know
bring
something
into
my
ecosystem.
That's
like
a
community,
something
like
I
I,
like
Liam's
idea
of
wasmcloud
official,
because
then
I
get
a
little
bit
of
comfort
that
it's
not
going
like
the
person
that
was
doing
it
as
a
side.
E
Project
isn't
going
to
run
out
of
cycles
and
no
longer
be
able
to
maintain
it,
and
then
the
community
is
like
well,
we
can
also
we.
You
know
we
can't
maintain
it
either
so
I.
That
was
really
the
the
reason
I
was
asking
right.
It's
like
at
what
point
can
I
really
trust
that
a
community,
something
will
be
I
mean
long
term,
is
not
the
right
word,
but
at
least
maintained
for
you
know
long
enough
that
if
I
need
to
rip
it
out,
I
can
rip
it
out.
D
This
is
this
goes
to
Lynn
Clark's,
nanoprocess,
blog
post,
where
there's
a
whole
bunch
of
different
low-level
security
concerns
around
that
and
so
they're
they're
Community
challenges
that
need
to
be
solved
all
the
way
from
the
lowest
level
of
can
this?
Can
this
module
call
this
function
in
this
other
module
all
the
way
up
to
you
know,
how
do
we
distribute
modules
and
how
do
we
trust
or
not
trust
modules,
and
so
yeah?
There's
there's
a
whole
bunch
of
work
to
be
done
there
and
I
think
you
know
us
being
on
the
hemorrhaging.
A
You
know
whether
it's
under
capability
providers,
the
repository
or
under
our
documentation,
site,
whatever
is
going
to
be
easiest
or
or
maybe
honestly
put
it
in
both
places
and
make
it
so
that
it's
easy
either
way
have
a
page
for
Community
capability
providers,
which
the
the
criteria
for
going
on
that
page
I,
don't
think
needs
to
be
very
strict.
It
could
be
I
came
out
and
I
implemented
this
contract
in
a
different
way
and
I'm
using
it.
A
But
taking
things
from
that
Community
page,
you
know
seeing
what
people
are
using
if
it's
something
like
mats
is
giving
us
like
the
file
system
provider
accessing
files
is
a
pretty
common
use
case,
even
if
it's
just
for
demos
and
maybe
not
is
all
right
for
any
examples,
maybe
not
as
much
in
production.
But
you
know
taking
things
from
that
Community
page
and
pulling
them
into
Watson
Cloud
first
party
supported.
You
know
who
knows
exactly
what
the
criteria
would
look
like,
but
I
really
like
that
general
idea.
A
A
That
would
definitely
help
address
the
concern
for
people
who
are
coming
from
Enterprises.
Looking
at
things
like
you
know,
we
have
a
couple
implementations
of
the
key
value
contract
for
Vault
or
for
redis,
and
if
you
come
to
the
list
of
capability
providers,
you
say
oh
it'd
be
great
to
use
a
service
in
AWS
for
this,
because
my
company
uses
AWS.
A
When
you
see
the
dynamodb
capability
provider
in
the
community
section
then
I
mean
you
can
immediately
know
at
least
that
it's
possible
and
you
can
do
a
proof
of
concept
and
then
you
can
get
down
to
the
hard
part
of
you
know.
If
you
have
to
do
that
convincing
to
run
that
Community
maintained
capability
provider
or
writing
your
own,
you
know,
that's
I
would
argue
that.
D
Yeah
I
think
you
know
the
the
discussion
here
is
a
good
one
to
have
and
I
think
like
I
mentioned
earlier.
There
are
some
broader
questions
that
I
think
the
web
assembly
community
at
large
needs
to
Grapple
with
not
just
us
as
well
as
inclined
people.
You
know
the
other
one
which
kind
of
ties
into
the
current
discussion
is
Discovery.
You
know,
they're,
you
know
as
more
and
more
people
use
wasm
cloud
or
you
know,
build
things
that
are
compatible
with
wise
and
Cloud
the
the
need
to
make
those
things.
D
Discoverable
gets
it
becomes
more
important,
but
it
also
becomes
more
and
more
difficult
to
track
all
those
things,
because
not
everybody
who
builds
something
on
wasmcloud
is
going
to.
You
know
come
to
the
community
meeting
and
demo
it
or
make
a
PR
to
the
community
list
of
links,
and
things
like
that,
so
you
know
Discovery
is
going
to
be
a
concern
in
the
future
too.
F
A
A
E
A
A
A
A
Well,
cool
I
think
that
we've
reached
a
pretty
solid
decision
here,
or
at
least
a
solid
amount
of
information
to
put
into
an
RFC
and
continue
to
work
on
so
I'll.
Take
that
on
to
to
do
that,
Kevin
I'm
actually
really
interested
in
your
thoughts
on
the
broader
topic
of
how
we
address
dependencies
in
the
webassembly
community.
Maybe
that
would
be
a
great
to
be
a
great
blog
post
again
to
the
lines
of
like
the
nanoprocesses
comic,
so
I
guess
we
can.
We
can
move
forward
with
that.
A
I
actually
really
enjoyed
this
section
of
the
community
call
coming
like
going
through
a
kind
of
community
brainstorm
part.
So
if
there's
any
more
of
these
things,
I'll
try
and
bring
them
from
slack
into
this
discussion
and
then
go
back
to
the
slack
thread
and
kind
of
put
RFC
or
findings,
or
you
know
kind
of
what
we
talked
about
just
because
this
kind
of
audio
dialogue
is,
is
really
helpful
and
let
me
know
if
you
hated
this
and
we
can.
We
can
consider
that
too.
A
G
Lots
of
knowledge
is
a
bit
outdated,
but
I
just
thought
of
the
possibility
of
now
being
able
to
do
awesome
linking
and
being
able
to
build.
You
know
these
libraries
from
where
from
sources
where
you
don't
even
care
what
language
It,
Was
Written
in
but
you're,
just
being
able
to
kind
of
build
structures
upon
structures
and
language
is
kind
of
a
non-factor
is
is
a
very,
very
interesting
concept,
because
there
are
so
many
times
in
which
you
know,
one
person
has
implemented
it
in
goal
and
you're
like.
G
D
Yeah
and
I
I
kind
of
alluded
to
it
a
little
earlier
when
I
said
that
things
like
the
component
model
are
really
going
to
change
the
entire
way.
We
think
about
dependency
management
and
reusable
libraries,
because,
like
you
said,
you
know
having
to
worry
about
what
language
a
reusable
library
was
written
in,
it
will
ultimately
be
a
thing
of
the
past
and
so
we'll
be
free
from
all
of
those
constraints.
G
A
A
Things
like
go
can
have
really
robust
standard.
Libraries.
Things
like
rust
can
provide
some
great
memory.
Safety
things
like
assembly
script
can
compile
down
to
a
tiny,
tiny
size
so
being
able
to
take
the
best
of
all
these
worlds,
and
you
know,
from
our
perspective,
we're
writing
the
runtime
we're
providing
common
libraries.
We
can
kind
of
you
know,
choose
the
language
more
for
the
advantage.
A
It
also
has
the
advantage
of
people
who
are
like
you
said
if
they
want
to
write
something
in
a
language
they're
familiar
and
they
get
to
choose
that
back
to
the
you
know,
kind
of
original
value
prop
of
one
of
the
value
props
of
webassembly.
It's
really
cool,
it's
an
experimental
feature.
Since
we
kind
of
control
the
webassembly
underlying
runtime.
We
can
have
that
enabled
automatically,
and
so
it's
not
something
that
the
actual
developer
would
need
to
worry
about.
A
G
D
A
One
other
thing
that
we
would
love
to
convert
to
webassembly
modules
are
our
capability
providers-
those
are
native
binaries
today,
so
you
would
write
them
in.
You
know
our
most
supported
languages
rust,
but
you
actually
write.
You
know
a
rest
executable
and
generally
this
doesn't
end
up
incurring
a
lot
of
penalty.
But
there
are
things
like
needing
to
compile
exactly
what
we're
trying
to
get
away
from,
with
webassembly
needing
compile
for
a
specific
architectures
operating
systems,
making
sure
you
have
things
if
you're
not
using
rust
TLS
like
an
openssl
installation.
A
Wazi
networking
is
something
we
plan
on
bringing
in
as
soon
as
it's
feasible
for
the
webassembly
community,
because
that
just
gets
rid
of
more
and
more
things
that
we
maintain
that
are
awesome,
Cloud
specific
and
bring
in
wasm
specific
things
which,
of
course,
anyone
who's.
Looking
to
do.
Networking
and
webassembly
are
going
to
be
following
that
proposal
and
using
that
even
before
they
hear
of
or
come
on
to,
musclecloud.
A
There
is
an
experimental
library
to
compile
an
Elixir
application
and
run
it
as
webassembly,
but
I
hesitate
to
even
mention
that,
because
that's
so
far
out
an
experimental
land,
so
I
don't
know
if
we
can
get
all
the
things
in
webassembly.
But
it's
an
interesting,
interesting
idea
to
have
awesome
cloud
and
wasm
yeah.
D
D
I
mean
there's
some
ugly
details
there,
like
the
that
the
elixir,
the
experimental
thing
that
compiles
beam
to
webassembly
requires
a
webassembly
beam,
host,
runtime
and
and
also
a
JavaScript
runtime.
So
it's
not
it's
it's
not
as
cool
as
it
sounds,
but
yeah.
There
are
definitely
a
lot
of
people
doing
some
hemorrhaging
Edge
stuff
that
we
need
to
keep
an
eye
on.
A
A
Alrighty
everyone:
well,
we
have
only
a
couple
of
minutes
left
so
probably
time
for
any
any
remaining
questions
or
additional
any
additional
call
outs.
One
thing
I
can
think
of.
That's,
maybe
not
demo
ready
that
Kevin
kind
of
showed
last
week
that
experimental
Autumn
support
that's
kind
of
sneaking
its
way
into
the
you
know.
As
those
features
develop,
that's
sneaking
its
way
into
wash
right,
Kevin.
D
Yep,
the
the
PRS
are
out
there.
There's
some
minor,
refactors
and
and
touch-ups
I
want
to
do
before
merging
those
but
yeah.
My
my
prioritization
rule
for
weddings
is
that
I
can
work
on
waddam
if
I,
if
I
finish
all
of
my
regular
stuff
before
five
o'clock
and
so
far
I
haven't
been
able
to
do
that.
Yet.