►
From YouTube: wasmCloud Community Meeting - 26 April 2023
Description
Welcome to the wasmCloud community! Tune in live where we discuss the latest developments in the wasmCloud ecosystem, WebAssembly standards, and break out sweet demos.
Agendas for wasmCloud community meetings can be found at: https://wasmcloud.com/community
A
All
right,
everybody
Welcome
to
the
wasmcloud
community
meeting
for
Wednesday
April
26th.
We
are
all
back
from
kubecon
with
a
force
and
we
have
a
pretty
I
think
we
have
a
pretty
fun
agenda
for
today.
Let
me
go
ahead
and
go
ahead
and
share
my
screen
and
we
can
get
started
so
I'm
sharing
my
whole
screen
because
I'm
going
to
hijack
it
right
after
we
get
done
with
the
agenda.
But
what
we're
going
to
talk
about
today?
A
We're
going
to
see
a
little
demo
and
do
a
discussion
on
the
wasmcloud
application,
deployment
manager
or
watam
the
declarative
application
format,
the
open
application
model
and
where
we're
at
with
the
0.4
release
there
we're
going
to
talk
all
things
all
things
water
and
then,
after
that,
we
have
another
discussion
that
we
have
queued
up
from
Steven.
A
We're
we're
all
going
to
chat
about
the
built-in
number
gen
capability,
what
it
means
in
a
cryptographic
context
and
and
what
this
may
look
like
for
generating
random
bytes
and
then
also
with
all
the
things
coming
out
of
kubecon
we're
going
to
do
a
little
wrap
up
there
and
I
have
all
the
video
recording
links,
including
the
playlist
from
the
whole
Cloud
native
awesome
day,
and
the
links
to
almost
everybody's
talk,
we're
still
waiting
on
Kevin's
to
get
published
from
the
main
conference.
A
So
without
further
Ado
I
think
we
can
go
ahead
and
get
started,
I'm
actually
going
to
be
doing
I'm
going
to
be
leading
this
first
part
on
wadham
I
talked
about
it
a
little
bit
last
week,
but
it
was
on
the
conference
floor
and
a
little
bit
flurried.
So
I
wanted
to
bring
it
up
again
in
a
context
where
everybody
can
see
it
and
ask
questions
and
I
can
have
a
little
bit
more
of
a
brain
to
to
explain
it.
A
So
if
you
haven't
heard
of
this
project
before
the
overall
tldr
and
what
this
is
most
useful
for
is
making
sure
that
you
can
declaratively
manage
was
on
cloud
applications
across
an
entire
lattice,
and
so
this
works
alongside
existing
wasm
Cloud
tools
that
essentially
hooks
into
a
naps
connection
that
the
same
one
that
your
wasmcloud
hosts
using
and
then
it
will
survey
the
lattice
for
the
entire
state
of
like
all
the
different
hosts
and
actors
and
providers
that
are
running.
A
But
what
this
really
means
for
you
or
you
as
a
a
developer,
is
that
you
can
Define
your
applications
in
terms
of
a
common
format.
This
is
the
open
application
model.
I
guess
I
might
as
well
just
pull
that
up.
But
this
is
another
open
standard
kind
of
like
how
we
use
the
open
container
initiative
or
oci
for
our
artifacts
oam
just
makes
sense
for
us
to
use
this
to
Define
applications.
So
using
this
model
you
can
define
a
wasm
Cloud
app.
That's
got
some
general
things,
it's
an
it's
an
application
name
and
version.
A
We
support
multiple
versions
of
applications
and
I'll.
Show
you
an
example
of
that.
But
the
real
magic
comes
in
the
components
section,
so
you
can
define
a
list
of
components
that
are
either
actors
or
capabilities
and
then,
as
a
part
of
those
components,
you
can
define
a
spread
property
or
a
spread
trait,
which
you
can
Define
like
a
scale
or
the
amount
or
kinds
of
different
hosts
you'd
like
to
spread
across,
and
you
can
also
Define
link
definitions,
which
is
where
you
can
essentially
Stitch
these
components
together
and
Stitch.
A
These
Watson
Cloud
actors
together
and
give
configuration
so
you'll
recognize
this
echoactor.
You
may
have
seen
essentially
this,
but
in
an
imperative
context
like
wash
control,
start
Echo
and
start
HTTP
server
and
then
link
Echo
to
http
server.
What's
really
nice
with
this
is
with
wadham.
You
can
Define
this
declarative,
manifest
and
essentially
say:
hey
wadham.
Please
go
make
this
the
state
of
my
lattice,
and
this
is
a
really
familiar
model
for
people
to
manage
applications.
A
This
is
exactly
how
people
work
with
kubernetes
deployments
and,
if
there's
anything
that
kubernetes
did
really
really
well
and
anything
that
people
like
it's
being
able
to
declaratively
say
here
is
the
way
that
I
want
things
to
be.
Please
go
make
it
happen,
I,
don't
care
how
I
just
want
to
have
an
application
running
so
moving
forward,
I
like
to
actually
show
you
what
this
looks
like
and
then
go
through
a
couple
of
examples
on.
B
A
Demo
and
then
we
can,
we
can
kind
of
move
on
to
questions
discussion
all
that
kind
of
stuff,
so
this
is
currently
in
an
alpha
State.
We
do
have
a
release
here
so
and
there's
some
instructions
that
we're
even
making
easier.
You
can
use
water
and
wash
together,
but
I'm,
going
to
show
essentially
from
this
branch
of
wash
what
this
looks
like
so
now
as
a
part
of
running
wash
up,
you
may
catch
it
really.
A
Quick
Autumn
starts
up
really
fast,
but
we
actually
start
or
download
and
start
the
Autumn
binary
when
you
run
wash
up
and
it's
just
a
just
a
rust
binary.
So
there's
nothing
super
special
there
and
if
you
go
to
localhost
4000
you'll
see
the
I
left
that
over
you'll
see
a
couple
of
the
the
wasabel
dashboard
as
you're
used
to
seeing
it.
But
now,
if
we
want
to
take
a
look
at
our,
if
we
want
to
interact
with
Autumn,
we
can
actually
do
that
through
wash.
A
So
if
you
do
wash
app
list,
it'll
tell
you
all
the
applications
that
you
have
managed.
Of
course
that's
going
to
be
empty.
So,
let's
start
with
our
Echo.
If
we
I
actually
put
in
a
PR
a
little
earlier,
that's
now
merged
into
the
Watson
Cloud
examples
repo.
So
all
of
the
actor
examples
now
have
this
Autumn
yaml
file.
A
If
we
look
at
that,
it's
actually
a
little
a
little
dark,
I,
don't
know
if
that
shows
up
well,
essentially
got
the
same
thing
from
the
example
or
from
the
documentation
here
in
the
examples
repo.
So
what
we
can
actually
do
is
we
can
just
do
a
straight
up,
wash
app
deploy
bottom,
and
this
will
take
that
manifest.
A
Put
it
and
then
deploy
it
and
those
verbs
are
intentionally
different,
but
I'll
talk
a
little
bit
more
about
it
later,
but
when
you
do
wash
up
to
flow
bottom
bottom
will
then
tell
your
host
exactly
what
it
needs
to
start
in
order
to
make
that
application
a
reality.
So
you'll
see
Echo
starts
up,
then
HTTP
server
starts
up
and
then,
as
soon
as
that
shows
up
as
healthy.
We
link
them
together
with
the
defined
link
definition
and
so
that
we
can
actually
take
a
look
at
is
actually
on
port
8080.
A
And
if
we
go
look
at
port
8080
Tada,
you
can
see
that
we
have
our
Echo
application.
So
without
doing
any
of
the
the
drop
downs
or
wash
control
start
type
commands,
we
have
now
deployed
the
echo
application,
which
is
really
sweet.
It's
really
nice
to
be
able
to
say,
hey,
go,
make
this
a
reality,
and
then
you
now
have
an
application
running
so
in
terms
of
the
other
things
that
wash
or
that
wadham
can
do.
A
If
we
take
a
look
at
the
applications
that
are
listed,
this
is
actually
something
that
we
need
to
fix,
but
we
have
the
one
Echo
example.
If
we
wanted
to
make
a
change
to
this,
if
we
want
to
make
a
change
to
this
application,
we
can
come
in.
We
can
bump
this
version
to
zero
zero
two
and
then
we
could
do
something
like
make
sure
that
there
are
three
replicas
running
in
this.
For
this
echoactor
and
I
mentioned
the
difference
between
put
and
deploy,
but
what
you
can.
Actually,
this
might
just
work.
A
Let
me
try
this
we
deploy
Autumn.
This
will
actually
put
the
newest
version
of
the
application
and
then,
if
we
take
a
look
at
the
app
list,
we're
going
to
say
we're
on
zero
zero
two
and
you
can
see
that
we
actually
went
up
a
little
past
three.
This
is
part
of
the
alpha
release
and
something
that
we're
okay
with.
We
can
essentially
Converge
on
the
proper
State
a
little
bit
over
time.
So
wadham
actually
has
the
ability
to
manage
multiple,
different
versions
of
applications,
and
you
can
update
them.
A
You
can
roll
back
by
putting
a
newer
version
all
those
things.
Additionally,
what
you
can
do
is
undeploy.
So
if
you
have
an
an
application
like
this,
you
can
undeploy
it
and
it
will
remove
all
those
resources
out
of
the
lattice.
So
let
me
show
you
something:
one
of
the
examples
is
a
little
bit
more
complicated.
A
We
take
a
look
at
the
animal
image,
downloader
example,
and
if
you
haven't
seen
this
one
before
this
is
one
actor
that
has
we're
just
running
one
instance
of
it,
but
we
are
linking
to
http
client,
blob,
store
and
messaging
and
we're
starting
those
three
capability
providers,
so
starting
this
normally
is
a
little
cumbersome,
but
with
watch
app,
we
can
just
deploy
that
manifest,
and
this
will
essentially
go.
Do
the
same
thing.
A
Tell
the
host
to
start
all
of
these
resources
and
then,
as
soon
as
this
goes
healthy,
we
should
see
that
they
come
across
now.
Actually
using
this
application,
we
can
do
a
request
to
awesome
Cloud
Dot
animal.dog,
and
this
is
what
the
application
just
does.
Oh
no
I
messed
something
up
here
with
the
actual
application.
Okay
I
might
have
had
a
wasn't
Cloud
host
running
in
the
background
for
this
one
anyways
anyways.
A
The
the
point
of
this
is
that
you
can
really
easily
manage
your
applications
in
this
way,
and
so,
if
we
undeploy
animal,
this
will
remove
all
those
resources
out
of
the
lattice.
A
So
what
we're
going
to
be
asking
people
to
do
as
we
keep
working
on
as
we
keep
working
on
wash
and
wadham
we're
going
to
be
pushing
towards
an
official
0.4
release
once
we
work
out
some
of
the
smaller
kinks
in
watam
as
we're
actually
getting
to
test
it.
But
what
we
essentially
want
to
do
is
give
people
a
way
to
run
all
the
Watson
Cloud
examples
with
just
that
one
command
wash
app
deploy
and
then
the
actual
manifest
for
the
example,
and
that
makes
it
really
easy.
A
So
that
was
kind
of
a
lot
with
the
the
demo
and
talking
about
wadham.
Does
anybody
have
any
questions
or
things
that
they'd
like
to
discuss
around
the
the
project
and
the
format.
A
Well,
you
can
use
it
today.
I
have
a
PR
open
in
the
wash
right
now.
Let
me
go
ahead
and
bring
that
up.
Really
quick
I
got
a
got
a
PR,
open
and
wash
that
adds
support
for
wadham.
So
this
will
actually,
when
you
run
wash
up,
it
will
run
bottom
and
then
it's
ready
for
you
to
use
the
wash
app
sub
commands
I'll
go
ahead
and
send
that
in
the
chat.
A
So,
if
you'd
like
to
install
from
this
from
this
link,
it's
going
to
be
version
0.18,
you
can
get
playing
now
with
any
of
our
any
of
our
examples
that
are
in
the
examples,
repo
yeah
Kevin.
D
Yeah,
so
I
was
wondering
if
you
could
show
what
happens
if
you
accidentally
turn
off
or
accidentally
stopped
one
of
the
capability
providers.
That's
managed
by
your
bottom
application.
A
Oh
yeah,
so
let
me
go
ahead
and
go
ahead
and
do
that.
So,
if
I
take
a
look
back,
I'm
gonna
share
this,
so
I
went
ahead
and
I
just
deployed
the
same
application
again,
so
I
deployed
the
animal
example,
and
so
if
you
come
to
any
of
these
so
autumn
not
only
starts
these
things
initially.
It
also
ensures
that
the
state
of
the
lattice
reflects
this
application
over
time.
A
So
if
you
were
to
take
one
of
these
actors-
and
you
were
to
delete
this
animal
image,
downloader
out
of
the
lattice
there's
a
certain
cooldown
period,
but
essentially
what
happens
is
that
I'll
do
the
same
with
HTTP
client
Autumn
will
take
them,
we'll
we'll
calculate
the
difference
in
state
and
see
hey
that
this
application
is
supposed
to
be
running
an
HTTP
client
and
an
animal
image
actor
and
we'll
restart
that
resource
in
the
lattice.
We
can
do
this
for
any
of
the
providers.
A
We
can
do
this
for
the
link
definitions
as
well
the
actor
there.
It
goes
the
essentially
what
we
have
is
a
cool
down
period
And.
So
we're
kind
of
working
on
tweaking
that
to
make
it
pretty
seamless,
but
we
don't
want
to
issue
too
many
commands
at
the
same
time.
But
this
is
really
nice
because
it
can
we
cover
things
happening
over
time.
If
you
accidentally
were
to
go
and
stop
one
of
these
resources,
watamu
will
make
sure
that
it's
still
running
for
that
and
yeah.
A
It's
pretty
sweet
to
watch
I'll
talk
over
one
other
Edge
case
as
well,
because
you
could
be
using
something
like
the
animal
image.
Downloader
for
multiple
different
applications
in
your
lattice
and
Autumn
is
only
responsible
for
managing
the
resources
that
it
deploys.
So,
if
I
deploy
extra
instances
of
this
animal
image,
downloader
you'll
see
that
Autumn
isn't
going
to
stop
them
and
that's
actually
on
purpose.
So
the
one
instance
of
animal
image
downloader,
that's
managed
by
wadham
it.
A
It
can
see
that
it's
running
and
the
four
extra
instances
that
I
started
on
my
own
are
essentially
unaffiliated
with
that
application,
and
that
becomes
really
important.
When
you
start
thinking
about
running
like
multiple
HTTP
servers
or
running
multiple
applications
that
may
use
the
same
actors,
they
don't
conflict
with
each
other,
which
is
really
neat.
So
we
can
kind
of
scale
this
back
down.
A
Yeah
so,
based
on
the
you
can
take
a
look
at
what
wadham
is
actually
doing.
If
you
turn
on
the
the
rust
logs
to
a
more
verbose
level,
you
can
kind
of
get
in
get
an
idea
of
what
each
scalar
is
doing
within
wadham,
but
yeah
you're.
Exactly
right.
You
can
also
Supply
an
open,
Telemetry
endpoint
to
to
Autumn
and
it'll
export.
All
those
traces
I
actually
haven't,
given
that
a
try
with
the
full
wash
up
Suite,
but
it
should
work
the
same
as
as
wasn't
Cloud
as
well.
A
Alrighty
well
yeah
we're
we're
super
excited
about
wadham
and
what
it's
going
to
do
for
some
of
the
introductory
tutorials
and
what
it's
going
to
look
like
for
managing
applications
in
wazen
Cloud.
It's
a
really.
A
You
know
whether
or
not
you
like
yaml,
which
you
can
use
Json
if
you
really
dislike
using
yaml,
whether
or
not
you
you
like
the
actual
format
of
doing
that,
it's
it's
really
familiar
for
people
who
are
coming
from
a
cloud
native
context
to
write,
declarative,
manifest
and
I
think
that
this
is
going
to
really
make
approaching
the
ecosystem
a
little
easier,
starting
with
a
format
that
people
are
familiar
with
and
then
seeing
a
lot
of
examples.
A
How
you
can
kind
of
stitch
that
together,
so
we're
really
excited
we're,
probably
going
to
do
a
weekly
or
so
check-ins
on
wadham,
as
we
lead
up
to
an
official
0.4
release,
and
if
anyone
is
interested
in
taking
a
look
and
contributing.
We
have
a
couple
of
issues
now
in
the
wadham
repo
that
have
the
good
first
issue
tag.
At
least
one
I.
Remember:
tagging
one
yeah
a
couple
of
issues
that
have
the
good
first
issue
tag.
A
This
project
is
completely
written
in
Rust,
so
if
you're
interested
in
contributing
these
are
great
ones
to
take,
just
feel
free
to
come
in
and
leave
a
comment,
and
let
us
know
that
you're
interested
in
working
on
it,
because
we're
definitely
accepting
contributors
at
this
point.
Now
that
we've
we've
pushed
to
the
first
like
Alpha
release.
A
All
right
any
other
questions
before
we
move
on
to
the
next
part
of
the
meeting.
A
F
F
You
asked
me
to
give
a
short
intro,
so
I'm,
Johan,
High
I
met
the
whole
team
I
think
at
the
kubecon,
which
was
pretty
exciting,
I
work
for
machine
metrics,
which
is
a
iiot
platform,
so
we
collect
data
from
machines
and
so
I'm
pretty
much
interested
in
how
that
all
plays
out,
because
we
use
Nats,
we
use
cloud
events
use
all
the
underlying
technology
already
for
our
data
streaming,
so
might
be
a
good
fit
and
I'm.
F
Just
gonna
look
a
little
bit
in
the
how
how
you
operate,
how
that
works
and
setting
up
some
demos
for
internal
uses.
A
Nice
well
yeah.
Thank
you
so
much.
It
was
great
talking
to
you
on
the
on
the
floor
last
week,
yeah
so
time
works
last
week,
and
and
thank
you
so
much
for
for
joining
the
call
it's
great
to
great
to
have
more
people
in
here.
A
All
right,
well,
I,
know
that
the
next
thing
on
our
agenda
I
can
go
ahead
and
share
that
again.
The
next
thing
on
our
agenda
is
to
talk
a
little
bit
about
the
wasm
cloud,
built-in
number
capability
and
and
it's
a
applications
to
cryptography
and
then
specifically
the
the
contribution
from
Steven
generating
random
bytes,
and
so
you
may
have
seen
a
couple
of
PRS
go
out.
I'll
just
share
part
of
this
one
Stephen
and
feel
free
to
jump
in.
A
If
you
wanted
to
add
a
little
annotation
here,
but
this
PR
adds
in
one
more
function
into
the
into
the
built-in
number
gen
interface,
which
is
random,
bytes,
and
so
essentially,
what
this
does.
As
you
give
it
a
certain
number
of
bites
and
then
the
awesome
Cloud
host
is
responsible
for
generating
kind
of
a
list
of
those
bytes,
and
this
specifically
ended
up
being
useful
for
or
or
would
be
useful
for.
Someone
like
Steven
for
cryptographically,
generating
some
random
amount
of
information.
Now
we
have
a
couple
of
operations
that
do
similar.
A
Things
like
random
32
generates
a
random
32-bit
number,
but
I
think
in
this
case
Steven
needed,
like
256
bits
of
of
random
information,
so
in
lieu
of
just
like
looping
and
doing
that
six
times
or
so
you
know
kind
of
adding
a
generic
function
to
this.
So
we
talked
in
slack
a
little
bit,
there's
a
few
things
around
like
how
we
need
to
bump
and
version
this
interface.
A
D
Yeah,
the
it's
probably
not
all
that
obvious
from
the
evolution
of
it
over
time,
but
the
the
built-in
interfaces
are
designed
specifically
for
I
guess
what
I
would
call
best
effort
and
functionality.
So
if
you
need
a
good
for
example,
then
what
you'll
get
is
a
cheap
and
easy
to
create
good?
We
don't
give
you
the
monotonically
increasing
time,
sortable
Goods.
We
just
give
you
a
random
number
same
thing
with
the
regular
random
numbers.
D
Is
they
are
they're
random,
but
the
host
and
the
interface
itself
makes
no
guarantee
that
it's
cryptographically
random,
so
we're
not
taking
any
extra
measures
to
make
sure
that
the
random
numbers
that
this
thing
gives
you
are
usable
for
cryptography,
so
I
think
where
this
ends
up
where
this
ends
up
having
the
conversation
is.
D
The
the
super
short
version
is
that
there
are
extra
measures
that
a
random
number
generator
needs
to
take
in
order
to
give
you
what's
called
the
cryptographically,
safe,
random
number
and
so
I'm
oversimplifying,
but
those
are
more
random
than
regular
random
numbers
and
so
yeah.
What
I'd
like
to
open
the
floor
for
in
terms
of
discussion
is
the
the
philosophical
difference
between
what
numbers
should
be
provided
by
the
built-in
and
which
ones
we
think
should
be
provided
by
separate
providers.
E
Yeah,
that's
kind
of
where
I
get
stuck
is
I'm,
not
sure
the
best
approach
to
generate
those
numbers,
because
I
was
even
thinking
out
on
my
walk
today.
I
was
wondering
if
Lassie
is
at
a
point
where
I
could
be
doing
that
in
an
actor
and
I'm,
not
sure
if
that
would
ever
be
a
thing
or
not,
I've
never
thought
about
the
provider
aspect.
So
it's
good
to
note
that
the
number
gen
isn't
meant
to
do
those
things
because
from
like
a
user
perspective,
that's
what
I
was
kind
of
thinking.
E
It
was
for
and
I
wouldn't
be
opposed
to
using
a
provider
to
do
that.
If,
if
it
was
you're
looking
for
like
a
more
pseudo-random
cryptographical
number
and
then
that
realistically,
you
could
probably
use
some
crates
that
exist
already.
E
But
I
was
looking
at
the
Elixir
or
erlang
modules
and
there's
one
called
crypto
and
I
wasn't
too
sure
how
cryptographically
secure
that
was.
But
that's
kind
of
what
I
was
looking
into
when
I
was
adding
the
random
bytes
thing
and
then
another
thing
I
also
had
difficulty
with
from
a
user
perspective,
is
sometimes
when
you're
generating
these
numbers.
I.
E
Think
a
lot
of
crates
refer
to
like
these
numbers
by
bits
and
then
because
in
the
rest,
World
we're
kind
of
referring
to
them
as
bytes
and
a
bit
of
my
ignorance
to
just
not
understanding
it
completely,
you
get
a
little
modeled
thinking
about
it
as
bits
and
bytes.
E
So
it's
like
am
I
requesting
this
many
bits,
but
because
Rusk
is
using
ASCII
characters
and
we
have
to
request
bytes
like
it,
it
gets
a
little
bit
modeled
from
a
user's
perspective,
so
I
I
think
for
me,
I'm,
not
so
concerned
where
I
generate
this
number
as
long
as
I
know
how
to
generate
it
and
like
what
information
I'm
requesting.
A
So
I
raised
my
hand,
unfortunately
not
to
give
too
much
more
clarity
into
this,
but
to
ask
kind
of
another
question,
because
I
know
that
through
Wazi
or
or
wasm
time,
there
is
like
a
there
is
a
way
to
get
a
random
number
or
at
least
in
theory,
I
guess,
to
help
fill
in
the
ignorance
Bailey.
Can
you
help
me
out
there
yeah?
A
Okay,
in
theory,
there's
something
called
Wazi
crypto
I
I'm,
trying
to
keep
in
mind
all
these
things
that
we
have
built-ins
and
in
in
the
early
or
in
the
Elixir
host
we're
kind
of
giving
best
effort
random
numbers.
A
We
could
kind
of
upgrade
that
to
more
cryptographically,
secure
functions,
but
I
think
it's
just
part
of
the
reason
is
that
that's
a
complicated
assertion
to
make
and
so
I'm
looking
for
ways
for
us
to
leverage
the
Wazi
functions,
and
so,
if
that's
kind
of
a
Stillman
proposal
State,
maybe
that's
not
something
that
we
can
quite
use
yet.
A
I,
don't
I,
don't
I
know,
Jordan
is
next,
but
maybe
Bailey.
If
you're
responding.
C
Directly
to
me,
yeah,
okay,
yeah,
so
lazy
crypto
does
have
real
implementations
in
places.
People
are
using
it.
Other
people,
like
some
some
people
I
know,
have
used
it
and
run
into
some
friction.
It's
pretty
hard.
If
you're
trying
to
do
things
that
really
rely
on
things
like
open,
SSL,
so
I
don't
think
the
path
is
smooth.
C
Yet
when
there
are
wazzy
interfaces
for
things
that
doesn't
necessarily
mean
that
there
is
a
wassce
implementation
for
a
sad
thing,
and
so
we
need
rfcs
and
work
to
happen
like,
for
example,
within
the
bycode
alliance,
rfcs
repo,
to
say
this
is
how
we
think
wazzy
crypto
should
be
pluggable
in
these
other
systems,
but
I
mean
if
you
search
for
a
while
some
time
and
see
it.
C
It
looks
like
it
should
work,
but
I
can't
speak
to
it
and
I
all
I
can
speak
to
is
I,
see
a
lot
of
friction
and
issues
that
it
get
reported.
A
I
think
that's
an
ideal
future
that
sounds
like
for
now
we're
probably
best
off
either
using
the
built-in
number
gen
or
creating
a
crypto
interface
and
then
having
a
provider
Implement
that,
but
you
know,
move
on
from
there
all
right,
I've
cut
Jordan
off
enough
times,
I'll.
Let
him.
B
Go
I
I
forgot
what
I
was
going
to
say,
I'm
joking,
no,
so
my
input
is
on
the
topic
is,
is
not
specific
to
crypto
or
anything,
but
from
the
perspective
of
like
a
host
right,
I
think
we
need
to
take
into
consideration
like
we're
all
running
them
on
map
books
now,
but
eventually,
if
we're
on
like
an
esp32,
will
it
ever
have
enough
entropy
to
give
you
a
true
random
number?
B
The
answer
is
no,
so
I
would
think
it's
like
in
the
platform's
best
interest
to
not
get
in
the
business
of
cryptography
specifically
right,
that's
those
are
strong
words
and
people,
and
you
know
if
you
say
we
give
you
a
cryptographic
number
in
our
host
you're
signing
up
for
a
lot
so
I
would
I
would
argue
that
this
is
a
hundred
percent,
a
provider's
job
outside
the
the
internal
one,
which
is
good
for
like
prototyping.
D
Yeah
Jordan,
pretty
much
said
it
better
than
I
could
have
the
or
a
number
of
reasons
putting
putting
cryptography
support
into
the
built-in
contract
carries
with
it
a
number
of
implications.
D
So
if
you
were
to
add
that
crypto
stuff
to
the
built-in
interface,
then
people
assume
that
all
of
the
hosts
have
that
support
built
in
and
like
I
mentioned
in
chat,
adding
that
to
The
Elixir
host
actually
affects
how
portable
that
host
is
where
it
can
run
easily
and
what
the
installation
prerequisites
are
and
again
to
Jordan's
point
the
it's
a
really
big
can
of
worms.
D
Even
things
like
asking
for
a
set
of
random
bites,
depending
on
which
crypto
modules
and
libraries
you're
using
some
of
those
take
5
10
15
input
parameters
for
how
it's
supposed
to
work,
which
algorithm
it's
supposed
to
use
and
so
on,
and
so
the
the
short
version
is
the
the
wasn't.
Cloud
host
should
not
be
in
the
business
of
doing
cryptography
because
that's
best
left
to
people
who
know
what
they're
doing.
E
I
was
looking
up
olenka,
so
like
I'm
100
on
board,
with
like
having
to
use
a
provider.
If,
if
that's
the
recommendation
but
I
think
I
I
I
might
have
missed
like
I
might
be
not
looking
at
this
from
the
correct
context.
E
But
is
there
a
way
we
could
add
language
around
number
gen
to
make
sure
it's
explicit
that
for
a
number
generation,
it's
mostly
meant
for
maybe
prototyping
or
something,
and
then,
if
you
want
to
be
generated
like
I,
didn't
even
know
that
about
the
guids
that
it
wasn't
time
sortable.
E
So,
like
that's
really
great
to
know
and
like
the
rust
Grand
crate
gives
you
access
to
all
kinds
of
pseudo-random
number
generators
like
Cha-Cha
20
and
you
can
choose
so
it's
like
I'm
I
think
it's
valuable
to
be
able
to
have
a
provider
for
that
and
be
able
to
swap
it
around.
And
then
you
don't
have
to
worry
about
it
in
the
host
I'm
just
concerned
about
the
you,
like,
a
user's
perspective,
looking
at
number
gen
and
seeing
Oh.
This
is
something
I'm
going
to
compare
to
Rand
and
that's
all.
D
Yeah
I'm
just
going
to
skip
the
line
real,
quick
and
and
add
that
it's
a
great
idea
to
have
that
those
guarantees
or
lack
thereof,
documented
so
I,
think
what
we're
going
to
want
to
do
is
make
sure
that
in
the
the
built-in
interface
you
we
can
add
documentation
right
on
top
of
the
Smithy
which
will
make
its
way
into
the
code
gen.
So
we
can.
We
can
make
sure
that
those
guarantees
are
are
in
there.
A
Yeah,
we
have
to
be
really
I
guess
just
general,
though
we
have
to
be
really
careful
around
any
documentation
we
put
in
the
interface
itself,
because
it's
inherently
not
tied
to
any
implementation.
So
for
the
built-in
you
know,
most
people
are
going
to
be
using
the
OTP
host,
but
with
multiple
different
hosts,
possibly
being
places
that
you
can
run
was
on
cloud
actors.
A
Different
hosts
may
have
different
different
implementations,
as
Jordan
was
alluding
to
so
I
think
what
we
should
do
in
the
built-in
interface
and
then
in
the
cryptography
interface
that
we'll
probably
talk
about
here
in
a
second
or
a
proof
of
concept.
We
should
always
make
the
note
that
the
interface
itself
makes
no
guarantees
around
cryptographic,
viability
and
then
the
actual
implementation
is
the
one
that
has
to
do
that.
A
So
with
that
I
think
we
have
one
action
item
to
come
out
with
documenting
the
interfaces
more
thoroughly
around
their
purpose
and
then
I
just
want
to
make
sure
that
we
that
we
loop
back
and
then
and
then
maybe
I'll
come
back
to
you
I
want
to
make
sure
that
Stephen
you
have
what
you
need
to
move
forward
for
your
use,
because
I
think
you're
you're
still
going
to
be
generating
these
random
numbers,
whether
or
not
you
need
them
to
be
truly
random
or
not
so
I
would
propose
that
we
leave
the
built-in
interface
as
is,
and
we
take
advantage
of
a
provider
interface
in
order
to
have
bigger
flexibility,
and
if
we
wanted
to
start
that
with
just
the
random
bytes
function
that
you
were
contributing,
I
think
that
sounds
great.
A
We
can
start
it
out
simple
and
then
it
is
welcome
to
you
know
kind
of
change
over
time,
because
it's
an
example
or
something
that
we're
working
on.
How
does
that
sound
as
a
path
forward?
So
we
have
that
separate
interface
and
then
a
new
capability
provider.
For
you
know
we
can
call
it
crypto.
We
could
call
it.
You
know
example
crypto.
We
can
figure
out
those
kind
of
details
later,
but
that
implementation
actually
does
the
random
number
generation.
E
Oh
yeah
I
was,
if
we're
gonna
be
do
it.
Maybe
we
can
maybe
start
this
as
a
spike
and
just
investigate
that
wassi
crypto
and
a
provider
like
if
I
have
to
make
something
might
as
well
just
see
if
it's
possible
and
then
maybe
you
don't
have
to
worry
so
much
about
using
wassi
in
the
future.
If
it's
possible
to
get
there
now
and
it's
not
going
to
give
too
much
headache.
C
And
that
and
that's
around
what
I
was
raising
my
hand
for
so.
We've
talked
a
lot
tactically
about
what's
available
today
right
and
it
seems
the
the
today
answer
like
right
now:
writer
provider,
but
I
did
want
to
clarify
that
and
I
guess.
This
is
more
brainstorming.
C
What
what
we
should
have
right
is
in
the
Watson
Cloud
Watson
Cloud
repo.
We
should
have
an
implementation
of
Wazi
crypto
I,
don't
think
it
should
be
a
built-in
per
se.
I
think
it
should
be
a
wazzy
fill
kind
of
similar
to
what
we
showed
off
at
the
wazam
IO
demo,
where
we
were
able
to
supply
a
key
value,
implementation
that
was
actually
distributed
and
live
somewhere
else.
C
For
all
the
reasons
that
we've
talked
about
for
portability
and
entropy
and
all
those
kind
of
things
and
so
I'm
saying
maybe
we
we
toss
out
a
GitHub
issue
that
we
Spike
on
for
Implement
wazzy
crypto
for
the
Watson
Cloud
host,
because
right
now
we
don't
turn
on
that
flag
or
anything
so
yeah.
We
don't
support
it,
but
we
totally
could
and
I
think
a
lot
of
people
are
building
stuff
for
it
and
it's
something
that
Colin
from
Adobe
wanted
as
well.
G
Billy,
can
you
just
maybe
explain
your
thinking
a
little
more
clearly
on
why
you
think
there
should
be
a
Wazi
fill
I
know,
there's
that
great
blog
post,
that
Kevin
I
think
you
pulled
together
and
put
up
on
the
cosmotic
blog
I'll
link
that
into
the
into
the
chat
here,
but
maybe
just
make
sure
that
people
understand
the
pattern
that
you're
putting
for
there
and
why
why
you
think
that's
the
right
right
path
forward.
C
Yeah,
so
you
know:
I'm,
not
gonna
I'm,
like
nervous
to
declare
expertise
and
cryptography,
because
that
field
is
deep,
but
the
from
what
I
understand
there
is
a
concern
about.
If
you
we
had
a
host
that
was
running
as
a
built-in
on
an
iot
type
device,
would
we
have
the
level
of
entropy
that
we
need
for
random
numbers?
C
I
don't
know
could
be
no
could
be
that
we
want
that
to
be
something
that
runs
somewhere
else
and
the
reason
why
I
wanted
to
use
a
technique
of
a
wasifil
is
that
we
can.
Let
you
write
your
code
just
like
you
would
in
any
other
environment
following
the
documentation
like
hey.
Why
is
the
crypto?
Is
the
right
way
to
do
this
type
of
thing
with
webassembly
components
build
your
component?
C
Just
like
you
would
normally
do
we
take
that
off
the
shelf
component
and
when
it
runs
and
wasm
Cloud,
we
handle
the
distribution
for
you
and
make
sure
that
we're
using
that
capability
in
the
right
environment
so
that
we
have
the
right
level
that
entropy
and
all
that
type
of
stuff,
I
hope
that's
clear,
I
and
if
you
haven't
seen
it
I
totally
read
Kevin's
blog
post
on
that
topic.
I
I
really
appreciated
him.
Writing
that.
E
A
Can
I
get
a
volunteer
for
someone
to
lead
up
writing
that
issue
either
in
the
Watson
Cloud
Watson
Cloud,
repo
Bailey,
all
right
Bailey?
It
is
officially
assigned
to
you
so
we'll
get
that
issue
I'm
really
interested
in
following
that
one,
and
hopefully
helping
and
we'll
go
from
there.
A
Steven
definitely
signed
up
cool
I
I
wanted
to
shout
out
one
one
more
quick
thing.
We
actually
have
in
our
examples
repository
this
crypto
directory.
That
has
a
couple
of
cryptography
examples
and,
as
mentioned
it's
using
the
built-in
number
gen
capability.
So
it's
not
something.
That's
explicitly
cryptographically
guaranteed
to
be
random,
but
these
are
some
really
two
really
sweet
examples
for
signing
a
payload
and
verifying
a
signature.
I
believe
Steve
wrote,
wrote
These
up
and
and
put
them
in
our
examples
repo,
but
these
are.
A
These
are
really
awesome
for
a
couple
examples.
If
you
wanted
to
take
a
look
here,
I
guess
I'll
send
this
in
the
in
the
chat
as
well.
I
wanted
to
at
least
shout
that
up
if
people
were
looking
for
other
places
or
that
actual
example
that
exists
now.
C
Actually
Brooks,
do
you
mind
pulling
up
two
slides,
I
thought
of
another
reason
why
wazzy
feels
really
valuable
here
in
this
use
case?
I,
don't
know
if
you
can.
G
A
A
If
you've
got
it
yeah,
you
got
power,
so
you
can
share
okay.
C
Cool
I.
C
Now,
I
don't
know,
usually
somehow
vicariously
I
don't
know.
Yeah
Steve
made
these
shapes,
which
I
I
think
is
a
really
cool
way
of
talking
around
this
problem
and
so
something
that
a
lot
of
host
implementers
are
doing
right
now
for
a
lot
of
these
different
wazzy
apis,
like
let's
say
it
was
a
key
value
in
this
case
they're,
embedding
as
part
of
that
host
layer,
the
redis
client-
which,
of
course
is
the
thing
that's
gonna-
have
all
the
cves,
and
so
by
decoupling.
This,
especially
for
a
use
case,
that's
around
cryptography.
C
It
makes
a
ton
of
sense
so
that
even
this
part
here,
the
capability
is,
is
separated
away
from
those
hosts.
Yeah,
okay,
jigsaw,
puzzle.
Pieces,
yes,
is,
is
how
they
work,
and
so
that
that
way,
this
little
piece
here.
This
green
piece
is
that
what
we're
discussing
around
as
being
the
wazzy
Phil,
the
the
piece
that
we
adapt
to
Las
cloud
and
and
work
over
like
wasabus
RPC,
so
anyways
this.
C
G
C
G
Bailey,
you
know
the.
Let
me
just
explain
as
my
simple
understanding
that
and
the
host
is
a
lot
simpler,
because
it's
not
we're
not
making
any
of
the
stuff
into
each
host,
it's
loaded,
so
that
it's
loaded
on
demand,
which
also
means
that
it's
pluggable
and
could
be
extended
at
runtime,
as
opposed
to
you
know,
baked
in
a
compile
time.
So
if
I'm
sorry
is
it,
yoshin
did
I
pronounce
that
right.
G
G
If
Joanne,
for
example,
if
you
wanted
a
private
capabilities
that
you
didn't
share
with
the
public
ecosystem,
you
don't
have
the
burden,
then
of
baking
them
into
a
custom
host
and
forking
it.
You
can
simply
just
load
your
you
know:
dynamic
capability,
your
Dynamic
wazzy
fills
at
runtime,
but
Bailey
is
that
my,
like
my
do,
I
understand
this
right.
Great.
C
F
Example,
for
that
would
be
a
machine
adapter,
so
we
have
machine
controls
that
we
would
have
providers
for
basically
yeah.
G
Yeah,
exactly
yeah
exactly
yeah,
that's
exactly
I
think
the
advantage
I've
noticed
across
many
different
open
source
software
platforms
that
the
best
of
breeds
always
tend
to
be.
You
know
dynamically
pluggable
at
runtime.
You
know
by
the
users.
You
know
that
you
get
an
example
like
with
brozique.
For
example.
That's
when
I
worked
on
for
a
long
time.
You
get
the
default
capability
yeah
the
default
protocol
analyzers,
but
you
could
always
add
your
own
at
start
time.
So
those
are
that's
pretty
powerful
approach
and
pattern.
A
Yeah
this
is
a
this
is
an
awesome
awesome.
Discussion
I
want
to
make
sure
that
we
just
have
time
for
the
last
little
bit
of
the
agenda,
and
then
we
can
kind
of
get
into
free
discussion,
so
the
the
last
little
bit
I
just
wanted
to
do
a
little
bit
of
a
a
little
bit
of
a
kubecon
wrap
up.
This
section
is
really
light.
I
just
wanted
to
say
thank
you
to
everybody
who
came
by
the
wasm
cloud
or
the
cosmonic
booth.
A
When
we
were
in
Europe,
it
was
a
lot
of
fun
meeting
you
all
in
person.
It's
really
cool
having
people
come
up
and
say:
hey
I've
heard
of
wasn't
cloud
like
I
wanted
to
talk
to
you
about
what
you're
doing,
especially
like
with
with
Johan
coming
over
and
we're
talking
really
in
depth,
with
like
Nat's
things
restricting
access
and
and
like
the
different
things
that
we
can
work
on.
A
I
also
just
wanted
to
share
the
good
attitude
that
when
I
was
working
the
booth
last
week,
I
had
you
know
generally
I
I
asked
people
I
say:
hey,
have
you
heard
of
webassembly
before,
because
that
kind
of
informs
how
to
talk
about
what
we're
offering
as
a
project-
and
you
know
the
the
ratio
of
people
who
have
heard
of
webassembly
is
just
steadily
climbing.
A
This
conference
I
think
at
least
80
percent
of
the
people
who
came
over
and
talked
with
me
had
heard
of
webassembly
before,
which
is
awesome
and
even
had
somebody
come
over.
I
said:
oh,
have
you
heard
of
webassembly
before
and
they
said
oh,
who
hasn't
and
I
think
that
was
such
a
cool
thing
to
hear
and
measure
how
fast
the
server-side
ecosystem
is
is
growing
here
in
this
space
really
exciting.
A
The
only
other
thing
that
I
wanted
to
share
is
a
couple
of
links
to
a
couple
of
links
to
the
recordings
for
our
talks
that
we
did
at
at
this
past
conference.
So
I
have
one
blog,
so
this
is
actually
we
posted
on
the
on
the
cosmotic
side,
but
it
it
kind
of
sums
up.
A
All
of
the
talks
that
happened
on
this
past
wasn't
day,
and
we
kind
of
went
through
and
added
comments
on
each
one,
along
with
the
video
recordings
in
line
so
I'm
just
going
to
call
out
the
ones
that
we
had.
First,
one
evolution
of
wasm,
past
present
and
future
from
Bailey,
which
is
a
really
awesome,
talk,
kind
of
went
all
the
way
through
the
history
through
today.
A
I
wanted
to
call
out
the
next
talk
that
that
was
with
us,
which
was
actually
Jordan.
This
was
Jordan's.
First
talk
as
I
understand
it
at
a
conference
which
was
really
fun
to
watch.
Jordan
has
a
certain
he's,
got
a
charm
to
his
talk.
This
was
a
really
cool
one
and
also
just
really
neat
to
see
someone
who's
an
expert
in
the
security
space
kind
of
a
role
through
the
different
levels.
All
the
way
down
that
was
on
cloud
takes
to
secure
an
application,
especially
by
default,
really
cool.
A
Seeing
this
in
action,
I
had
a
little
bit
of
a
lightning
talk.
This
one
was
really
fun.
It
was
a
lighthearted
introduction
to
webassembly
in
the
form
of
a
Dr
Seuss
poem.
You
should
check
this
one
out.
I
had
a
lot
of
fun.
Writing
it.
Even
if
you
think
it's
lame,
it
was.
It
was
a
lot
of
fun
and
then
last
but
certainly
not
least,
we
worked
with
some
folks
at
Adobe
for
the
webassembly
or
wasm
plus
container
kubernetes
Beyond
containers.
A
They
talked
about
some
of
the
work
that
they
did
with
wasm
Cloud
inside
of
kubernetes,
to
improve
some
of
the
way
that
they're
running
their
compute
internally
at
Adobe,
which
is
really
cool.
I.
Think
this
one
is
the
most
watched
talk
from
wasam
day
so
far.
It's
it's
been
getting
a
lot
of
Buzz,
and
this
overall
is
is
pretty
exciting.
Now
the
last
one
which
I,
unfortunately
have
not
been
able
to
watch
yet
it
was
at
the
main
conference.
A
It
was
Kevin's
talk
on
building
distributed
event,
sourcing
systems
with
wasmcloud
I
heard
a
lot
of
really
good
things
about
the
session.
The
room
was
packed
people
saying
it's
the
best
soccer
the
conference.
A
You
know
I
won't
I,
won't,
say
anything
if
I
haven't
seen
it
yet,
but
I
I'm
sure
it's
great
we'll
be
able
to
we'll
post
this
one
to
you
in
the
Wasa
Cloud
select
as
soon
as
it's
ready,
so
just
wanted
to
do
a
little
wrap
up
there
and
I'll
go
ahead
and
post
some
links
in
the
chat,
but
with
that
I
think
we
can
go
ahead
and
move
on
to
just
general
free
time.
Anybody
have
any
other
questions
from
today.
A
A
All
right,
well,
I,
think
that'll
that'll
probably
wrap
it
up
for
the
for
the
day.
We
can
go
ahead
and
stop
recording
and
we'll
hang
out
for
a
couple
minutes
thanks.
Everybody.