►
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
C
B
Okay,
we
are
here
on
Ye
Olde
washboard,
and
it
is
a
wonderful
site
that
everyone
here
is
probably
used
to
seeing
if
you're
not
familiar
with
wasmcloud
and
you're
new
to
this
meaning.
This
is
the
built-in
dashboard
that
comes
with
it.
It's
just
a
simple
dashboard,
so
you
can
kind
of
see.
What's
going
on
and
right
here,
we've
set
up
one
of
our
classic
demos,
which
is
the
KV
counter
demo.
B
This
has
the
HTTP
server
running
that's
connected
to
a
KV
counteractor,
the
increments
counter,
with
like
by
one
every
time
you
hit
any
given
endpoint
inside
of
redis,
which
it's
also
connected
to
and
so
classic
demo.
But
what
we've
done
is
we've
now
added
tracing,
so
this
tracing
support
is
not
yet
released.
It's
going
to
be
released
soon,
but
like
we'll
you'll
come
here
and
we'll
see,
hey,
look
the
counter
incremented
to
two
yeah,
not
really
that
exciting.
B
We've
all
seen
this
demo,
probably,
but
let
me
go
ahead
and
show
you
what
this
actually
looks
like
now,
so
I'm
I
grabbed
the
trace
ID
from
off
screen
and
I'm
going
to
come
here.
This
is
just
a
Tempo
in
grafana.
You
can
do
it
to
any
open
Telemetry
exporter
and
Bam.
There
we
go.
We
have
a
full
set
of
tracing
data
from
start
to
finish
of
that
request,
so
we
can
see
where
it
hit
the
HTTP
hdb
server,
where
it's
sent
down
to
the
actor.
B
The
actual
RPC
call
underneath
the
hood
and
then
when
it
hits
the
actual,
was
in
cloud
and
does
the
call
into
the
into
the
after
how
long
that
takes,
then
it's
the
outbound
RPC
and
then
all
the
way
out
to
the
KB
redis
increment
command,
and
so
we
have
the
entire
graph
of
exactly
what's
going
on
there
and
the
whole
time
frame.
How
on
each
spam
took
everything
you'd
expect
from
a
full
tracing
solution,
and
so
with
the
new
version
of
wasimbus
RPC.
B
C
B
Yeah,
that's
all
very
useful
here
it
also
in
in
Tempo
at
least
it'll
it'll
grab
some
of
the
messages
from
logs
as
well,
which
is
Handy
but
like
we
do,
have
a
lot
of
data,
and
you
can
see
pretty
much
everything
that's
going
on
inside
of
this,
so
here
we
can
see
the
exact
key
setting
inside
of
redis,
where
it's
coming
from
in
the
code,
the
actor
ID,
that's
part
of
it.
So
all
sorts
of
data
like
that
I
think
it
looks
like
Jordan-
has
a
question.
D
B
Nothing,
you
have
to
do
for
wiring
up
an
actor.
We
do
plan
on
adding,
probably
some
more
stuff
into
actors
in
the
future,
as
my
guess,
but
right
now
we
we
didn't.
We
didn't
add
it
indirectly
to
there,
because
that's
going
to
have
to
be
probably
provider
based
to
be
able
to
send
it
out
to
something
specific.
B
But
for
those
who
are
very
familiar
with
Watson
Cloud
you'll
see
that
we,
this
host
call
section
is
exactly
where
it
calls
the
where
it
calls
the
underlying
module,
the
basically
the
web
assembly
that's
being
run,
and
then
we
see
the
outbound
call
from
that
webassembly
module
that
goes
out
to
the
RPC
thing
to
get
what
it
needs,
and
then
it
returns
back
and
then
exits
out.
So
you
can
actually
see
the
execution.
B
Time
of
that
element
is
very
small,
because
if
you
look
at
the
stack
at
the
graph
like
one
you,
you
have
just
like
just
a
point
something
milliseconds
between
the
time
it
actually
executes.
Then
it's
all
around
the
calling
and
sending
to
KB
redis
and
then
just
a
little
bit
of
time
to
take
that
data
and
send
it
back.
B
A
B
Let's
go
to
OTP,
so
if
you
look
inside
of
OTP,
there
is
a
new
hotel
directory
and
this
hotel
directory
has
a
Docker
compose
file
that
you
can
use
to
just
immediately
set
up
grafana
and
Tempo
and
have
that
be
ready
to
collect.
So
just
keep
that
in
mind.
If
you
want
to
give
this
a
whirl,
it's
pretty
easy
to
do.
B
D
B
B
B
A
C
C
C
Okay.
So
what
I
wanted
to
do
is
give
people
an
update
on
where
the
efforts
are
with
regard
to
wadham
I
know
it
seems
like
every
time
we
have
an
update.
The
update
is
well
we're
working
on
it
and
we'll
get
there
eventually,
but
I
wanted
to
show
some
actual
progress.
So
just
like
everything
else
in
wasmcloud,
if
you
want
to
deal
with
applications,
you
can
use
wash
so
a
used
wash.
Obviously
this
is
a
an
experimental
version.
C
Wash
you
I'm
going
to
list
the
applications
that
are
available
within
a
lattice
called
root,
so
I
have
an
app
called
my
example
app.
The
newest
version
is
0.0.1
and
it's
current
deployment
status
is
undeployed.
I
guess
so.
Maybe
the
first
thing
to
notice
is
that
you
can
have
applications
stored,
ready
to
go
that
may
or
may
not
be
deployed
if
it's
deployed.
That
means
there's
an
active
autonomous
agent
monitoring
that
lattice
for
you.
C
B
C
Now
you
see
the
deployment
status
of
my
example.
App
is
ready
at
the
moment
that
status
is
fake,
I
have
the,
so
you
can
do
everything
four
atom
that
involves
pushing
and
retrieving
and
querying
the
app
specs.
So
that's
all
done
and
ready
to
go
and
you
can
deploy
and
undeploy,
but
the
autonomous
agent
that
gets
started
and
stopped
currently
does
nothing
but
I
feel
like
we
got
this
to
a
point
where
now
we
know
exactly
where
the
code
is
supposed
to
go
in
order
to
finish
Madam.
C
C
A
C
Can
you
see
what
can
you
see
the
yaml
file?
Yes,
all
right,
and
so
this
is
an
application
specification.
It's
got
the
name
of
the
app
the
version
and
inside
it
are
the
components
and
in
this
case
they're
they're
just
garbage
it's
just
random
stuff,
but
you
can
imagine
you
know
all
of
Pet
Clinic
being
in
here
or
all
of
any
all
of
your
applications,
so
any
logically
grouped
set
of
components
that
you
want
to
manage
as
a
whole
unit.
C
Additionally,
there
are
things
like
link
definitions,
but
if
you
look
at
the
Syntax
for
the
link
definition
you'll
see
that
the
target
is
just
the
name
of
a
thing
in
this
in
this
yaml
file.
So
it's
significantly
easier
to
manage
than
regular
link
definitions
and
so
there's
a
capability
in
here
and
then
another
capability
and
this
one's
also
governed
by
a
spread
scaler.
C
So
what
will
happen
is
if
I
push
this
it'll
be
stored
and
I
can
retrieve
it
and
query
it
and
do
whatever
I
want
and
then,
when
I'm
ready,
I
can
deploy
it
and
deploying.
It
starts
a
monitoring
agent
that
will
continually
monitor
the
state
of
your
lattice
and
then
and
compare
it
to
your
desired
state,
which
is
the
contents
of
this
yaml
file.
And
you
know
it
will
just
take
corrective
measures
in
order
to
make
sure
that
you
have
what
you
want
should
sound
very
familiar
to
anybody.
C
C
F
C
G
C
It
deploys
an
agent
to
monitor
your
application
deployment,
it's
doing
so
inside
a
beam
cluster,
so
you
can
run
watum
as
a
cluster
of
two
three
fives.
However,
many
servers
you
want,
and
it's
automatically
going
to
do
things
like
failover
in
case
the
server
dies.
Things
like
that.
So,
in
addition
to
what
I'm
making
sure
that
your
application
is
resilient,
item
itself
is
resilient
by
virtue
of
being
or
an
erlang.
F
Liam
yeah
yeah,
you
answered
you
answered
my
very
next
question,
which
is
exactly
where
I
was
going.
It
was
if
I
have
a
node
of
say.
You
know.
Five
hosts
here
and
I'd
want
to
make
sure
that
if
there's
a
network
partition
or
a
disconnection
or
they're
Offline
that
you
know
that
things
are
still
resilient
across
the
partitions
until
things
are
restored,
think
like
distributed
software,
you
know
things
along
those
lines
so.
G
F
E
C
E
Or
is
it
calling
directly
in
in
terms
of
the
messages
that
go
to
nuts,
because
I
guess
actually
brief?
Rebrand?
That
question
is
the
reconciler
actually
has
a
bunch
of
commands,
I
get
issued,
which
I'm
assuming
is
still
the
case,
and
those
commands
need
to
be
translated
into
something
that
OTP
understands.
C
C
I,
don't
know
if
you,
if
you
were,
if
I,
don't
know
when
you
join,
but
earlier
I'd
mentioned
that
they're
reconciler
itself.
The
control
agent
is
right
now
empty.
So
what's
written
is
the
storage
and
retrieval
of
the
app
specs
and
the
deployment
and
undeployment
of
the
agents,
but
the
agents
themselves.
Don't
currently
do
anything,
that's
still
code
that
is
yet
to
be
written.
But
your
your
point
is
is
correct
that
what
needs
to
happen
is
on
some
timed
interval
basis.
C
C
G
E
C
C
C
E
E
C
E
Sorry
so
I
mean
similar
to
well
actually
not
similar,
but
intense
sort
of
like
the
host
process
actually
goes
down
and
therefore,
like
the
providers
and
actors,
all
just
kind
of
die.
Wadham
doesn't
run
inside
a
host
correct,
but
if
the
host
actually
comes
back
up,
what?
What
is
the
process
as
in
to
restore
everything
that
was
there
before.
C
C
That's
a
very
different
concern
than
what
wadham
does
wadham
will
monitor
the
state
of
your
lattice
and
if
the
state
that
you
have
described
is
still
healthy,
waddam
will
take
no
action.
So
if
your
abstract
says
I
want
three
actors
and
two
providers
and
I
want
them
scheduled
in
such
and
such
a
way.
If
a
host
that
didn't
have
anything
from
your
application
on
it
goes
away,
wadham
doesn't
care.
C
E
C
You
would
either
use
a
config
server
if
what
you
want
to
do
is
make
sure
that
every
single
host
starts
with
the
same
set
of
data
or
same
you
know
contents,
and
that's
where
you
know.
Let's
say
you
want
every
single
host
in
your
infrastructure
to
start
with
a
specific
capability
provider.
That's
what
you
would
use
a
config
server
for
you
would
not
use
waddam
for
that.
E
A
A
C
A
C
Goes
down
that
is
part
of
the
requirements,
and
then
it
comes
back
up
again
before
waddam's
update
cycle.
Then
it
will
never
have
been
the
wiser
and
won't
have
needed
to
take
any
action.
But
if
it's
down
longer
than
you
know,
one
of
Adam's,
you
know
update
ticks,
then
one
of
them
will
try
and
take
corrective
action.
C
E
C
So
the
first
question
is
like
I
said
we
would
not
recommend
running
both
wadham
and
the
config
server
or
if
you
do
run
them,
you
use
them
for
two
entirely
different
reasons
with
non-overlapping
resources
that
said:
wadum
tags
all
of
its
resources,
so
that
there
can
be
a
version
of
an
HTTP
server
provider.
That's
running
that
is
managed
by
wadham
and
one
that's
managed
not
by
webm,
and
it
won't
interfere
with
the
unmanaged
resources.
E
C
G
C
If
it
needs
to
take
action,
so
anytime
anything
happens
in
the
lattice,
it
will
trigger
a
check
to
see
if
corrective
action
needs
to
be
taken
in
response
to
that
event
and
the
timer
that
will
be.
There
is
more
just
there
for
backup
in
case
important
events
have
been
missed.
It
can
then
probe
the
lattice
to
get
up-to-date
information.
A
A
C
Yeah,
we
actually
had
a
big
long
discussion
about
using
jet
stream
versus
using
redis,
and
the
verdict
was
that
the
redis
got
us
operational,
faster,
haven't,
ruled
out
using
jet
stream
in
the
future,
especially
as
it
gets
more
mature
and
we
want
to
do
things
like
maybe
make
the
event
logs
that
wadham
admits
to
be
durable
or
semi-durable.
We
might
want
to
look
into
using
Jetstream
for
that.
C
D
I
have
one
question
we
obviously
gnats
is
very
much
the
backbone
of
all
of
this,
and
one
of
our
awesomest
tools
as
developers
is
that
NGS
gives
us
that
free
developer
tier
have
we
baselined,
since
this,
like
with
wadham
and
all
this
other
stuff
like.
If
we
were
to
put
like
a
simple
app
with
some,
you
know,
EPS
per
month,
have
we
Baseline
like
the
amount
of
traffic
we
will
send
over
naps
over
like
a
month
time.
D
C
Yeah
Brooks
this
sounds
like
something
that
might
make
for
a
decent
blog
post
but
yeah.
So
the
it's
difficult
to
Baseline,
because
the
traffic
that
you
use
or
the
the
data
that
you
consume
over
NGS
depends
entirely
on
how
much
traffic
goes
across
and
if
you're,
using
Leaf
nodes
judiciously,
then
traffic
that
doesn't
need
to
leave
one
particular
region
to
go
across.
Ngs
won't
leave,
and
so
it
won't
incur
any.
You
know
message
or
bite
accrual
against
your
quota.
C
C
You
know
things
like
S3
buckets
and
whatnot,
because
then
you
know,
like
the
worst
case
scenario,
is
you've
got
an
actor
on
one
side
of
the
leaf
node
and
a
capability
provider
on
the
other
side
of
another
Leaf
node
and
they're
going
across
NGS,
and
they
are
chunking
S3
files
back
and
forth.
That's
probably
the
the
most
data
you
could
consume
using
wasm
Club
and
again,
that's
all
based
on
the
app
and
based
on
usage
I
have
in
in
all
of
my
lab
experiments
and
I.
Do
a
ton
of
them.
A
G
G
You
know:
Dev
containers
and
all
sorts
of
things,
but
I've
been
looking
at
dagger,
mainly
as
an
attempt
to
learn
dagger,
which
is
Solomon
hikes,
new
Venture
after
Docker
I
guess
and
it
uses
build
kit,
which
is
the
back
end
effectively
for
building
Docker
images,
Moby
eventually
and
Q
Lang
as
a
front
end
for
that,
in
the
same
way
that
a
Docker
file
is
a
front-end
for
build
kit.
So
Docker
far
has
like
a
list
of
commands
to
build
an
image
and
then
build
kit.
G
We'll
look
at
that
and
do
multi.
You
know
workout
director-day,
cyclic
graph
and
know
all
the
ordering
which
things
need
to
be
done
and
to
as
much
as
impossible
as
possible
in
parallel
and
and
in
multiple
layers
and
catch
all
those
layers
and
never
repeat
what
that's
been
done
before
Etc
and
what
Solomon
Heights
is.
What
dagger
Dio
is
doing.
G
Is
it's
using
Q
Lang
as
a
way
to
describe
the
all
the
things
that
need
to
happen
in
order
to
build
stuff
in
an
attempt
to
homogenize
all
the
CD
CI
pipeline?
You
know
service
providers
that
are
out
there.
Jenkins
GitHub
actions,
Circle
CI
Travis,
build
kite
Etc
and
to
be
able
to
run
these
things
locally
as
well,
which
is
really
really
cool.
So
I've
got
an
interface,
a
provider
and
an
actor.
G
So
it
starts
with
a
plan
and
the
plan
has
actions.
These
underscore
actions
are,
are
basically
private
variables
effectively,
but
there's
one
here
build
provider
and
there's
another
one
here:
build
actor.
So
if
I
just
type
dagger
do
on
its
own,
it
tells
me
that
there's
two
available
actions
build
provider
and
build
actor,
so
I
can
do
build
provider
and
it
what
happened
very
quickly,
because
it's
sort
of
been
done
before
and
there's
a
cached
layer
somewhere
there.
G
So
when
I
call
build
provider
it
effectively
copies
onto
a
scratch
layer
like
an
empty
file
system
effectively
the
con,
the
output
from
the
from
this
build
provider
thing
which
actually
does
the
build
it
takes
this
Source
interface
and
for
the
interface
and
for
the
provider
and
when
I
do
the
active
it
takes
one
for
the
interface
and
for
the
actor
and
they're
declared
here.
So
this
is
the
client.
This
is
the
the
bit
that
takes.
That
gives
the
docker
images
permission
to
read
my
local
file
system.
G
So
so
there's
a
file
system,
section,
there's
an
embar
section
as
well,
and
this
gets
the
outside
world
into
the
into
build
kit
effectively.
So
the
interface
directory,
which
is
here
excluding
rust
Target,
is
a
dagger
file
system
and
it's
got
read
access
on
that
and
it's
same
for
provider
and
actor
and
then
the
output,
the
right
bits
so
I'm
going
to
write
the
output
of
build
provider
and
build
actor
actions
here
and
write
them
to
that
thing.
G
G
But
what's
interesting,
I
guess
is
with
the
actor
stuff.
Build
actor.
Is
the
action
and
it's
taken.
The
output
from
sign
actor
and
sine
actor
has
taken
the
output
from
build
actor,
and
these
are
effectively
types
that
I've
imported
up
here
so
in
in
the
ACT,
I
mean
I'm
such
an
action
before
to
be
the
same
thing
and
there's
a
build.q
and
the
build.q.
Has
this
build
type
declaration
effectively,
which
is
which
declares
all
these
parameters
that
I'm
passing
in
and
does
the
docker
build?
So
it
pulls
for
us
latest.
G
So
that's
where
the
where
the
built
stuff
goes
so
then,
when
I
go
back
so
when
I
go
back
to
dagger
key
on
the
actor,
this
is
signature,
so
actually
build
actual
output.
It
then,
is
input
into
the
sign
actor,
so
there's
a
sine
dot
Q
in
there
somewhere,
which
does
a
similar
thing.
It's
got.
Some
claims
then
put
filed
output
file.
The
work
directory
pulls
wash
image,
copies,
The
Source
into
the
work
directory.
G
That's
extending
it
with
this
Ampersand,
extending
it
with
the
command
that
I
want
to
run,
which
is
obviously
declared
in
here
and
Docker
run,
and
it's
slightly
effectively
washed
clones
sign
with
the
name
and
all
that
sort
of
stuff
and
then
the
claims
which
I'm
flattening
out
into
that
same
list,
giving
it
the
input
font
and
then
it
has
the
same
output
mechanism.
So
when
I
run
build
actor.
G
G
G
G
G
Did
I
cancel
it?
No
I
did
yeah
yeah
it's
going
to
take
a
few
a
few
seconds
to
build
it,
which
is
probably
not
worth
waiting
for,
but
it's
pretty
cool
because
then
I
can
created
GitHub
action.
That
is
just
a
dagger
action
and
it
just
runs
this
build
up
to
our
build
provider,
and
it's
exactly
the
same
in
CI
as
it
is
locally
I
can
test
it
all
locally
without
going
through
the
whole
CI
Loop,
while
I'm
building
stuff
so
yeah
yeah,
that's
the
demo.
G
Oh
it's
finished
now
so
yeah.
There
we
go
so
now.
If
I
list
the
build
directory,
the
actor
yeah
was,
the
actual
actor
was
built
last
built
at
1157
and
the
signed
actually
at
13
23..
If
I
gave
it
another
chain,
another
change,
then
I'd
get
a
one
that
was
built.
Now,
that's
really
cool,
not
repeating
work
and
working
out
exactly
what
it
needs
to
do
doing
it
in
the
right
order,
basically
done
to
build
kit,
sometimes
just
a
useful
thing,
really
I
think.
A
G
G
A
A
E
G
I
think
I,
I,
I
I
think
that
to
me,
I,
don't
know
I've
never
seen
this
said
anyway,
but
I
think
that
using
Q
Lang
as
a
way
of
unifying
configuration
from
all
different
places
and
being
able
to
ex
you
know,
have
configuration
for
specific
things
that
you
can
extend
and
unify
together
into
into
a
build
configuration
which
you
can
then
just
give
to
build
kit
and
say
execute
this
thing.
It's
quite
it's
quite
a
powerful
mechanism.
G
Yeah,
it's
a
bit
of
a
a
bit
of
a
mind
because
you've
got
the
whole
cue
length
thing
in
the
way.
Everything
is
just
very
declarative.
It's
like
a
subset
of
Jason
and-
and
you
just
declare
it
a
set
of
constraints
that
must
get
narrower
and
narrower
until
they
actually
land
on
a
concrete
value
and
then
that's
effectively,
the
Json
or
the
ammo
or
the
whatever
configuration
that
you
need.
G
That
describes
what
has
happened
so
I
suspect
that
at
some
point,
Adam
could
be
driven
by
culin,
whatever
it
wouldn't
be
about,
but
use
case
for
killing
and
and
I.
Think
quite
a
lot
of
people
are
using
it
to
drive
kubernetes
configurations
where
you
know
people
are
getting
a
bit
sick
of
like
yaml
problems
and
like
customized
users,
overlay
thing
and
there's
Helm.
It's
just
template
driven,
but
Q.
A
A
A
We're
working
with
the
folks
in
the
math
slack
to
figure
out
what
the
issue
is
there,
but
just
as
a
heads
up.
Another
thing
that
I
wanted
to
mention
is
that
Taylor
and
I's
talk
is
actually
MMI.
Talk
is
actually
on
YouTube
now
that
just
disrupting
the
downtime
Continuum,
so
I
will
share
that
link
in
the
chat.
But
if
you
missed
it,
if
you
weren't
able
to
go
to
coupon
EU,
that's
now
live
and
we'd
love
for
you
to
check
it
out.
A
And
lastly,
the
thing
that
I'd
like
to
mention
is
we
are
going
to
be
at
and
we
are
sponsoring
the
open,
Score
Summit
in
North
America.
Here
in
a
couple
of
weeks,
you
can
see
our
super
fun
cosmologic
logo
under
the
silver
look
level,
so
cosmonic
the
company
is
going
to
be
sponsoring.
This
I
believe
it's
in
Austin.
If
you're
in
Austin,
please
come
and
see
us.