►
From YouTube: wasmCloud: waPC cli - 1/13/21 Community Call
Description
wasmCloud Weekly Community Call - this week featuring a demonstration of the new waPC cli code generator, a high level discussion of memory management in #WebAssembly, and wasmCloud version .15 completion review.
#wash #code #programming #wasm #webassembly #development #IT #newcode #community #github #oss #opensource #career #software #browser
A
B
Sure
my
name
is
gustav
and
I'm
here
as
a
curious
contributor
hoping
to
help
out
with
this
project.
I
work
professionally
at
a
consultancy
agency
in
sweden
and
I
guess
that's
it.
This
is
all
very
new
to
me,
but
I'm
very
grateful
to
be
here
with
you
guys
and
you
seem
like
really
cool
people,
so
yeah
get
you.
C
A
Okay,
that's
awesome
and
with
our
you
know,
new
desire,
we're
gonna
go
ahead
and
get
started
with
the
demo.
So
phil
kitty
has
been
with
us
for
a
long
time.
He
works
on
a
lot
of
different
technologies
that
we
use
in
the
stack
and
today
he's
going
to
do
a
quick
demo
and
walk
through
of
the
new
wapc
plea.
So
phil
turn
it
over
to
you.
Buddy.
D
The
first
step
in
wap,
c
or
ypc
is
to
solve
for
really
an
n
by
n
problem
with
polyglot
right.
So
there
are
multiple
languages.
We
want
to
write
webassembly
in
and
there
are
multiple
hosts
that
we
want
to
consume
web
assembly
from
right.
So
you
know
they're
going
to
be
standards
to
address
this
in
the
future,
but
there
needs
to
be
some
tooling
here
and
now,
and
I
think
this
is
what
a
goal
was.
D
D
So
you
know
it's
kind
of
up
to
you
to
figure
out
what
you
want
to
do
with
it,
but
that
can
kind
of
lead
to
some
developer
friction
and
really
our
goal
is
to
make
it
so
you
don't
even
have
to
deal
with
that
or
solve
for
that
in
your
project
and
that
you're
kind
it's
almost
kind
of
like
we're.
Our
our
vision
is
like
grpc,
but
for
web
assembly
right,
like
you
generate
the
code,
you
get
all
the
glue
and
you're
off
and
running
right.
D
A
D
Yep,
you
got
it
so
much
like
protobuf
or
grpc,
there's
kind
of
an
idl
associated
with
it,
and
so
you
know,
and
some
of
the
internal
products
that
I
mentioned.
We
started
out
with
looking
at
protobufs
and
various
ways
of
serializing
data,
and
we
probably
won't
get
into
the
rationale
for
doing
what
we
did
here
today,
but
we
do
intend
to
document
it
in
the
near
future
so
that
it's
understood,
but
basically
what
we're
doing
here
is
we've
instead
of
using
protobuf.
D
What
we're
doing
is
actually
using
a
spec
called
message
pack,
and
there
are
a
couple
reasons
for
that,
but
in
our
in
our
usage
of
it
it
actually
seems
to
be
quite
a
bit
faster
than
protobufs,
there's
less
cpu
horsepower
being
devoted
to
compression,
which
is
a
little
bit
of
a
trade-off
there,
but
it
gets
the
memory
passing
around
a
lot
quicker.
So
the
problem
with
that,
though,
is
there's
no
real
idl
for
message
pack,
so
we
decided
to
create
one
and
we
did
it
in
such
a
way.
D
That
was,
I
guess
you
would
say,
fit
for
purpose
for
web
assembly.
So
you
know,
if
you
look,
there
are
numeric
types
here
that
are
aligned
directly
with
webassembly
and
so
the
basic
structure
here
is
you
define
your
interface,
the
for
what
your
module
is
going
to
implement
any
methods
inside
of
here
and
inputs
outputs.
So
in
this
case,
where
we're
doing
a
rules
engine
you
want
to
input
in
your
fax,
and
I
have
a
structure
down
here.
That
represents
your
facts.
It's
very
simple,
pretend
we're
issuing
loans.
D
Maybe
what
we
want
to
do
is
just
make
sure
that
your
income
is
at
a
certain
level
and
that
your
credit
score
is
at
a
certain
level
right
and
then
the
the
business
role
engine
its
responsibility
is
returning
an
array
of
decisions
as
to
why
you
might
not
qualify
for
a
loan
if
it
returns
back
an
empty
array,
you're
good
to
go,
and
it
should
approve
you
for
that
loan.
So
that's
the
basic
demo
here,
obviously
you
know
in
your
use
cases
you
can
expand
upon
the
data
types.
You
can
nest
them.
D
D
D
So
now
that
we
have
that
we're
going
to
take
a
little
bit
of
step
back
and
the
first
step
to
any
cli
really
is
to
bootstrap
or
create
or
initialize
a
new
project,
much
like
something
like
a
yeoman
or
you
know
something
along
the
lines
of
lines
of
those
tools
right.
So
the
the
unique
thing
here
is,
you
know
when
you
say
I
want
a
new
ypc
project.
D
The
the
next
argument
here
after
the
new
is
the
project
template
I
want
to
use,
and
those
are
typically
going
to
be
language
specific,
and
it
comes
that
the
ypc
tooling
comes
with
out
of
the
box
templates
for
rust,
assembly
script
and
tiny
go.
So
what
I'm
going
to
do
here
is
go
to
my
command
line
and
just
go
ahead
and
drop.
Those
three
ypc
new
commands.
A
A
D
D
D
All
right,
so
what
we
have
here
and
if
we
look
at
the
code
gen,
so
what
that
did
part
of
the
part
of
the
project
structure
is
also
to
include
a
code
generator
right
and
so
there's
a
configuration
file
that
gets
laid
out.
It
is
laid
out
for
the
language
that
you
are
building
in
so
there's
assembly
script,
things
that
it
will
build
for
assembly,
script
and
so
on
and
so
forth.
D
But
when
I
run
the
code
gen
or
really
run
the
make
file,
you
get
a
make
file
for
any
each
of
the
languages
that
you're
generating
for
and
it's
consistent
right.
So
if
I
say
make
code
in
it's
going
to
make,
the
you
know
run
the
code
in
for
that
language.
If
I
say
make
build
it's
going
to
do
the
language
specific
things
for
that
language,
so
in
rust
it
would
do
you
know,
cargo
based
things
and
so
on.
D
I
think
you
get
the
point
so
when
I
ran
to
make
it
found
out
that
there
were
some
files
that
needed
to
generate
which
a
lot
of
it
is
here's
the
glue
code
that
has
to
do
with
all
the
web
of
the
message
pack
stuff
and
the
interchange
and
passing
that
back
and
forth,
and
then
here's
kind
of
the
scaffold
part.
So
this
only
gets
generated
if
this
file
does
not
exist
and
so
from
here.
D
If
I
wanted
to
implement
the
hello
world,
you
know
I
do
the
assembly
script
way
of
doing
that,
and
I
can
there
you
go.
I
now
have
hello
world
and
assembly
scripts
so
that
that
gives
you
a
sense
of
what
you
get
out
of
the
box
when
you
first
run
the
tooling,
but
realistically
it
is
contract
first
development.
D
D
D
And
one
thing
to
point
out:
I
mentioned
the
makefile
is
almost
like
your
contract
for
building
this
thing,
each
of
the
languages
will
drop
the
dot
wasm
file
into
a
directory
called
build.
So
here
you'll
see
rules
underscore
rust.wasm,
so
I'll
move
on
to
the
assembly
script
and
it's
very
much
the
same
process.
It's
just
geared
toward
assembly
script
instead.
D
So
in
this
case
it's
generating
an
assembly
script
module
an
assembly
script,
scaffolded
index.tx,
which
is
like
your
entry
point.
If
you
will
and
it
compiles
it
and
there
you
go
so
there's
a
rules
dot
underscore
as
for
assembly
script,
and
that's
that
and
then
finally,
here's
tinygo
and
tiny
go
compiles
the
fastest
of
them
all,
because
it's
go
but
anyhow
same
result.
You
have
a
rules
underscore
tinygo.wasm.
D
So
all
right!
Well,
where
do
we
go
from
here?
Here's
where
you
imagine
I
take
like
the
ingredients
of
the
cake
I
just
put
together
and
it's
unbaked
and
I
stick
it
in
the
oven
and
then
I
like
magically
go
to
a
second
oven
and
like
pull
out
a
fully
baked
cake.
So
that,
basically,
is
this
rules
demo
project
here
and
you
can
go,
go
grab
it!
It's
at
this
repository
here
underneath
ypc
and
all
the
stuff
is
built
out.
I
didn't
go
ahead
and
build
the
rules
engine
for
each
language.
D
D
So
all
that
is
kind
of
deferred
if
you
will
to
that
really
really
really
basic
class
okay.
So
finally,
we
got
to
put
some
you
know,
look
at
what
the
rules
do.
So
the
rules
are
very
simple.
It
looks
at
your
your
credit
score
and
if
it's
lower
than
400
it'll
say
I'm
making
decision
that
your
credit
card
score
is
too
low
and
very
similarly
looks
at
your
income.
If
your
income
is
below
four
grand
it'll,
also
say
you
don't
you
know
your
income's
too
low
right.
D
So
that's
that's
really
basic.
I
already
have
this
pre-compiled.
It's
dropped
again
into
this
build
rulesdemo.lasm
and
also
what
I've
done
here
is
encapsulated
this
in
a
very
basic
go
api.
If
you
will
I'm
not
following
very
good
practices
here
like
it
does
handle
reloading,
but
it
doesn't
use
atomic
pointers
to
the
the
rules
engine
and
so
on.
I
will
enhance
this
demo
to
do
it
probably
the
more
best
practices
way,
but
it
does
work
at
least
for
demo
purposes.
D
D
E
Second,
I'm
not
sure
if
you
skimmed
over
it
or
not,
but
you
you've
got
a
host
runtime
written
in,
go
right
and
that's
right
and
that's
using
the
wapc
host
runtime
library
for
go
right.
Yep!
Okay,
I
just
wanted
to
make
sure
that
we
that
everybody
is
aware
of
what's
going
on
is
we
have
both
a
a
runtime
written
using
a
wapc
library
and
then
the
webassembly
modules
compiled
to
wasm,
also
using
a
wapc
library.
D
D
So
anyway,
yeah
to
get
back
to
this,
we
have
two
uris
that
this
expose
exposes.
So
one
is
obviously
the
decide
call
or
the
desired
the
side
uri
and
the
other
one
is
to
just
trigger
a
reload
right
and
the
logic
here
for
the
side
handler
just
literally
calls
into
the
rules
engine.
This
is
also
generated
code
by
the
way
from
the
the
code
generation
tooling.
So
I'm
able
to
generate
code
that
is,
can
be
leveraged
in
the
host
as
well,
and
that
is
what
this
code
is
doing.
C
Hey
bill,
this
is
actually
that's
a
good
point.
It's
it's
very
familiar
from
a
grpc
development
perspective.
Can
you
phil?
Can
you
show
where
you're
instantiating
the
rules
engine
in
the
go
host?
I
I
can
see
the
handlers
but
and
you've
got
the
rules
engine
there
already,
but
where's
that
get
created.
D
B
D
Okay,
yeah
so
yep
the
codes
loaded
from
the
wasm
file,
ypc
new,
so
that's
kind
of
like
again
just
passing
the
arrays
of
bytes
back
and
forth
and
as
soon
as
you
take
the
instance
of
one
of
those
things
and
throw
it
into
the
generated
code.
So
it's
just
package.new
pass
it
an
instance.
Now
you
have
like
the
equivalent
of
the
grpc
client.
If
you
will
and
then
I
make
use
of
that
grpc
client
right
here.
D
Just
again,
not
the
best
idiomatic
go
code
for
writing
a
rest
api,
but
serves
the
purpose
for
the
demo
but
calls
decide.
Facts
are
just
parsed
right
in
from
using
json
straight
from
the
request,
and
I
get
this
array
of
decisions
back
which
I'm
just
you
know,
marshaling
back
to
json
and
sending
back
an
okay
response.
So
that's
all
there
is
kind
of
to
this,
and
just
to
give
you
a
piece
one.
C
D
D
E
C
Okay,
that
that's
really
interesting,
so
I
that
I'm
I'm
super
new
to
this
wasn't
cloud
piece.
So
that's
where
I
need
to
land
when,
at
the
beginning
of
the
discussion
I
mentioned
that
I
used
to
work
at
google
and
liam
mentioned
k
native
and,
of
course,
there's
cloud
functions,
and
when
you
talk
to
those
runtimes,
of
course
you
don't
or
when
you
talk
to
those
services,
you
don't
care
about
the
runtime.
C
E
That's
this
very
definitely
what
one
of
the
the
key
things
that
weizen
cloud
is
trying
to
do.
Also
in
the
backlog
for
the
curious
there,
we
are
planning
on
building
an
open,
faz
gateway
or
an
open,
fast
provider,
so
that
you'll
be
able
to
run
wasmcloud
actors
in
a
wasm
cloud
lattice,
which
is
our
mesh
network
and
then
allow
openvas
clients
or
regular
http
clients
to
to
pass
through
open
faz
and
invoke
your
actors.
E
C
E
That's
that's
not
even
potential.
That's
that's
up
and
running
now,
so
you
can
using
crosslit.
You
can
spin
up
a
node
in
your
kubernetes
cluster
that
is
running
the
wasm
cloud
host
instead
of
cubelet.
And
that
way
you
can.
You
can
actually
schedule
actors
directly
to
specific
kubernetes
notes.
Very
nice.
D
A
D
Let
me
wrap
up
and
we're
almost
there
right,
so
I
showed
you
the
curl
command
to
run
this
business
rule
engine
right
and
the
income
was
three
thousand.
The
credit
score
was
three
thousand
or
three
hundred,
so
you
know
what,
if
I
decide,
I
wanna
give
out
more
loans.
I'm
willing
to
you
know,
relax
my
requirements
a
little
bit,
so
I'm
going
to
drop
this
down
to
300,
I'm
going
to
drop
this
down
to
3
thousand.
So
now
that
same
request
should
work
right.
D
A
Nice,
so
real
quick.
Let
me
just
open
up
the
open
up
the
call
here
so
when
we
wrote
some
documentation
for
this,
we
kind
of
broke
this
into
four
different
steps,
and
I
want
to
get
some
feedback
to
see
and
especially
for
people
that
are
just
getting
into
the
project.
Jordan,
maybe
who
wouldn't
mind
you
know
some
feedback
on
this
or
milan.
You
know
that
there
were
four
steps
essentially
to
the
cli
that
happened
here.
The
first
was,
you
know,
editing
the
schema.
A
If
everybody
fought
along
with
that
and
then
it
was
doing
the
initial
scaffolding
right,
phil
and
then
from
the
scaffolding,
it
was
the
process
to
auto,
generate
your
lab
libraries,
and
that
was
that
make
so,
regardless
of
what
language
you
picked
you
typed
make,
and
then
this
fourth
step
where
the
cake
you
know
just
kind
of
came
out
of
the
oven
baked
was
there
was
an
application
written
around.
That
was
that
was
that
clear
in
the
demo
on
the
on
the
call
today.
G
Jordan,
hey
yeah.
No,
I
thought
it
was
super
clear.
The
one
thing
I
I
missed
and
that
phil
might
have
already
had
this
prepared
and
I
just
missed
that
part
was
the
business
logic
piece
like
the
setting
the
3000
the
setting
300
was
that
just
you
had
that
prepared
somewhere
phil
and
then
that
was
the
magic
bait.
Oh
sorry,
that
was
the
magic
of
him
piece.
D
That
was
right
at
the
end,
so
I'll
go
back
to
that
right.
So
the
rules
were
are
here:
they're,
underneath
this
rules
subdirectory
underneath
the
assembly
directory
right.
So
here's
where
they're
coded
so
like.
If
this
was
a
real-life
use
case,
you
got
your
rule
authors
and
they
can
drop
these
rule
files
in
and
then
all
that
really
has
to
happen.
Is
you
have
to
wire
them
in
so
you
instantiate
them
and
add
them
to
the
engine
and
and
now
they're
they're
there.
So.
G
G
A
H
D
D
D
H
A
You
know
when
you
look
at
you
know:
here's
that
new
assembly
directory
with
the
the
module.ts,
the
ts,
config.json
and
the
index.ts,
and
then
there's
a
ton
of
templates
that
get
pulled
down
into
the
node
modules
directory
and
then
your
wasm
file
that
gets
gets
built
out
here
as
well.
So
I
think
in
general
for
anybody
who's
interested
there's
a
lot
of
opportunity
to
improve
this
based
on
you
know
today's
demo,
but
there
are,
I
tried
to
do
a
basic
hello
world.
A
A
So
that's
the
next
step,
and
there
are
some
great
examples
that
phil's
already
put
out
here
with
the
mandelbrot
example,
the
rule
demo,
that's
there
and
you
know
ibm-
is
using
this
in
their
hyper
ledger
as
well.
So
I
think
that,
depending
on
what
you're
interested
in
seeing
that
there
is,
you
know
other
other
uses
out
there
and,
of
course,
there's
the
watson
cloud
use
case,
which
is
the
one
that
we're
likely
the
most
interested
in
real,
quick,
any
other
questions
for
phil
or
anything.
A
D
A
A
You
know
I
of
course
was
trying
to
use
the
pressure
as
a
forcing
function.
You
know
to
stay
up
late
and
force
myself
to
document
it
for
you
and
they
get
to
get
feedback
from
you
or
something
along
those
lines.
Look
we
don't.
We've
got
a
few
on
the
backlog,
I'll,
maybe
ask
for
a
volunteer.
We've
got
the
bindle
potential
demo
coming
up
here,
although
I
know
that
we
wanted
to
touch
base
between
the
par
gzen
bindle
for
file
format
and
a
few
other
demos
here.
A
I
I
You
know:
crestlet
bootstrapped,
one
of
the
issues
that
we
were
supposed
to
do
la
and
the
last
year
was
I
was
supposed
to
chat
with
chris
and
get
together
and
do
the
docs
for
bootstrapping
on
critical
stack
and
because
of
any
number
of
reasons,
mainly
three
weeks
off
and
then
attempted
coups
which
I
don't
think
were
actually
related
to
the
four
seasons
landscaping
on
that
was
before
four
season
landscaping.
You'll
notice,
I've
cleaned
it
up
a
lot.
I
So
I'm
just
saying
that
I
haven't
done
that
yet,
but
added
to
that
list,
and
probably
the
critical
stack
stuff
too
we'll
make
sure
that
we
have
a
nice
easy
doc
set
on
that.
But
so
there's
like
eight
different
assemblies
or
you
know,
bootstrapping
mechanisms
and
how
you
get
crestlet
wired
up.
If
das,
you
want
to
use
google
and
you
can
use
those
as
a
sort
of
yeah,
exactly
I
was
going
to
say,
volunteer
to
to
do
a
gke1.
A
I
I
think
all
of
those
would
be
amazing
and
kit
I'll
follow
up
dez
I'll,
follow
up
with
you
guys
offline,
and
we
can.
You
know
just
give
you
guys
one
on
the
schedule
and
to
talk
about
when
we
could
do
it
and
what
what
how
how
we
can
help
you
to
help
drive
it
forward,
so
that
more
people
can
experiment
with
more
things
in
more
places.
It's
the
ultimate
end
by
end
phil
back
to
our
agenda.
A
Let's
see
community
news
watson
time
community
meeting
is
next
thursday.
1
21
meeting
agenda
is
posted
last
week's
meeting.
We
spent
a
fair
amount
of
time
working
on
some
of
the
like,
I
would
say,
project
governance,
we're
talking
a
bit
about.
You
know
like
what
does
the
patching
policy
look
like
you
know
what
is
the?
How
do
we
organize
all
those
sorts
of
things
and
with
the
team
transitioning
into
fastly?
There's
some
some.
A
A
E
Yeah,
sorry,
nothing
really
to
shout
out
other
than
problem,
starting
today
we're
working
on
finishing
out
all
of
the
rust
interfaces
and
then
we're
going
to
try
and
build
out
a
couple
of
of
the
other
interfaces.
At
the
very
least
for
all
the
languages.
We
want
to
be
able
to
run
our
canonical
example,
which
is
the
the
key
value
counter
so
for
for
that,
we'll
need
all
of
the
languages
to
have
the
web
server
capability
interface
and
the
key
value
one.
So.
E
They
weren't
issues.
I
just
started
tracking
some
of
the
to
do's
for
the
15
release
in
the
project
in
the
org,
not
really
sure
what
the
best
way
to
track.
Some
of
those
is
because
our
milestones
span,
multiple
repositories,
and
so,
rather
than
using
milestones,
I've
just
used
the
it's.
The
project
is
org-wide,
it's
not
in
a
in
a
repo.
A
Project
yeah
this
right
here,
yep.
Thank
you,
magic
of
editing,
I'll
just
go
there
magically
yep!
So
right
here,
kevin!
Yes
right
there
all
right!
So
some
a
bunch
of
video
things,
the
actor
interfaces
upgrade
the
actors,
support
first
party
actors
and
rust,
and
at
least
two
and
go
yeah.
I
mean
it's
basic.
It's
basic.
A
A
A
Anyway,
yeah,
no
we're
not
we're
not
moving
over.
Basically,
we
have
to
move
crescent
over
to
the
wasm
cloud,
repo,
the
crestlet
provider,
for
it
over
there,
which
I
think
we'll
do
first
and
then
we'll
update
all
the
wasn't
cloud
stuff
because
we
are
woefully
behind,
but
we're
also
trying
to
upgrade
to
like
tokyo
1.0
right
now
when
we
need
to
update
the
kube
libraries.
So
this
is
what
happens
when
you're
like
heads
down
trying
to
figure
out
reverse
engineering
kubernetes
so
we'll
get
to
upgrading
those
okay,
all
right!
A
I
A
J
A
Okay
and
if
anybody
wants
to
test
and
give
feedback
on
early
packages,
they're
right
here
on
package
cloud,
I'm
not
sure
that
this
is
actually
linked
anywhere
on
the
project.
I'll
get
this
linked
in
and
also
pin
it
into
slack
and
also
we'll
make
sure
that
it
shows
up
in
the
notes
heading
on
down
the
list
here:
kevin
any
open,
pr's
or
issues.
Do
you
want
to
highlight.
E
E
But
if
you
want
something
more
robust
than
that,
you
can
actually
just
specify
the
oci
reference
url
of
a
key
value
provider
and
the
wisem
cloud
will
automatically
use
that
for
the
lattice
cache.
So
if
you
want
to
switch
between
that's
replicated
in
memory
to
using
etcd
or
console
or
cassandra
or
anything
else,
you
just
give
it
the
oci
url
of
the
key
value
provider
and
it
works
like
magic.
A
That's
awesome,
kevin
and
then
on
issues
just
another
quick
call
out
here
that
there
are
a
number
of
rc's
that
are
open.
That
would
love
to
get
some
feedback
on
here.
Some
of
the
things
were
mentioned
earlier,
but
the
the
javascript
host
runtime
for
wasm
cloud,
the
swift
host
runtime
for
the
ios
platform,
the
supervision
model
and
project
bandwagon
kevin
island.
Did
you
give
anybody
an
overview
on
this?
One.
E
A
We've
got
a
number
of
demos
here,
I'll
collaborate
with
the
volunteers
to
see
if
what
the
schedule
looks
like
for
the
next
six
or
eight
weeks
or
so,
because
I
think
that's
what
we've
got
demos
laid
out
for
I.
I
also
want
to
put
out
a
a
call
to
action
with
the
dot
15
release.
We're
gonna
do
another
tasting.
This
will
be.
You
know
all
are
welcome
to
this
one.
A
So
watch
for
an
invite
on
our
slack-
and
I
think
you
guys
know
the
drill
by
now
I'd
like
to
get
this
one
on
the
on
the
books,
maybe
three
to
four
weeks
out.
So
we
make
sure
we've
got
enough
time
for
shipping,
but
we
can
do
another
bourbon
tasting
or
if
anyone
has
a
another,
you
know
volunteer
for
a
little
hangout
celebration
or
a
suggestion
for
what
they'd
love
to
do.
A
A
D
I've
looked
at
interface
types,
it's
an
ever-changing
spec.
You
know,
I
guess
I'm
trying
to
infer
what
what
kevin's
alluding
to,
but
there
are
kind
of
memory
allocation
semantics
that
are
going
on
there,
not
to
mention
like
the
lift
and
lowers
I'm
kind
of
curious
about
how
that
works,
going
back
and
forth
over
the
ff
boundary
numerous
times.
D
To
be
quite
honest,
until
I
see
something
real,
which
I
mean
rheto,
that's
kind
of
what
I
was
interested
in
hearing
from
you
as
you
are
in
the
wasm
time,
using
the
interface
types
as
they
exist
right
now
and
doing
your
research
based
on
that.
Is
that
true,
like
you're
the
bite
passing
that
you're
doing?
That's
the
wasm
time
specific
stuff
for.
K
E
E
And,
while
that's
perfectly
fine
in
certain
languages,
you
know
rust
can
pin
the
pointers
and
things
like
that.
But
then
you
have
languages
that
have
garbage
collectors
on
the
inside,
or
things
like
that,
and
you
know
part
of
what
we're
trying
to
do
with
wapc
is
not
only
be
language
neutral,
but
engine
neutral,
so
it
needs
to
work
with
more
than
just
wasm
time
and
again
it
needs
to
be
stateless.
E
So
with
with
wapc
it's
designed
specifically,
so
that
I
can
make
a
method
call
and
after
I
make
that
method
call,
I
can
completely
destroy
the
webassembly
module
and
reconstitute
it
from
scratch
and
have
no
negative
consequences,
and
so
what
what
remains
to
be
seen
is
whether
that
same
type
of
stateless
guarantee
is
something
that
we'll
be
able
to
have
with
interface
types.
If
we
can't
avoid
explicit
memory
allocations
or
long-lived
pointers
or
accidental
accidental
state
statefulness
with
interface
types,
then
wapc
will
probably
not
end
up
using
them.
K
Right
but
all
the
memory
allocations
are
eventually
made
in
guest
memory,
which
is
associated
with
an
instance.
So
once
you
shut
the
instance
down,
then
you
the
the
host,
should
de-allocate
its
memory.
It's
linear
memory
anyway.
So
if
you
recreate
it
theoretically,
you
should
get
a
new
array
of
bytes
as
as
its
linear
memory.
In
theory,.
E
Yeah
so
there's
some
in
the
weeds
discussions
to
be
had
there,
but
I
guess
the
the
takeaway
there
is
that
interface
types
isn't
something
that
is
an
automatic
adopt.
It's
a
once.
It's
once
the
spec
stops
changing
and
there's
an
implementation
in
wisem
time
and
there's
an
implementation
in
another
engine
other
than
wasn't
time.
I
D
Yeah
kevin
wants
pass
by
value,
not
passed
by
pointer
right,
and
so
you
know
we're
making
copies,
and
so
you
know
right
now.
Ypc
is
making
at
least
two
copies
right
once
there
are
things
like
shared
memory
and
some
of
these
specifications
start
to
make
it
to
the
languages
like
if
they're
shared
memory,
we
can,
in
theory,
eliminate
a
memory
copy
hop
if
you
will
right
and
make
it
more
efficient.
So
I
think
there's
going
to
be
like
baby
steps
at
achieving
the
ultimate
goal
over
time.
K
A
A
I
think
I
think
that
there
are
people
on
this
call
that
would
enjoy
it,
and
I
think
us
you
know
kind
of
documenting
but
documenting
it
together
and
writing
it
down
is
super
valuable,
like
what
you're
doing
with
your
blog
post
radio
is
is
amazing,
and
you
know
I
mean
they're
they're.
What
we
continue
to
find
is
is
that
there's
just
a
huge
number
of
people
that
are
all
stuck
at
the
same
spot.
A
You
know
and
we
as
a
team,
could
do
a
much
better
job
on
sharing
some
of
that
knowledge
and
you
know
like
and
putting
it
all
out.
So
I
I
think
that,
if
somebody
wants
to
you
know,
do
a
walk
through
here
or,
like
you
know,
maybe
review
this
in
detail.
This
could
make
it
was
making
a
great
topic
to
record
and
just
put
out
there
so
that
people
have
like,
as
of
january,
2021,
here's
here's
where
we're
all
stuck
on
this
and
here's
what
we're
doing
to
get
around
it.
E
I
don't
necessarily
mean
to
do
shameless
self-promotion,
actually
yeah.
I
do
the
edx
class
that
I'm
working
on
for
linux
foundation
has
a
chapter
in
it.
That
goes
into
excruciating
detail
on
the
various
different
ways
that
you
can
do:
guest
and
host
memory
sharing
and
copying,
and
and
where
statefulness
happens
accidentally
and
intentionally,
and
things
like
that.
G
A
A
This
is
an
ugly
version
of
the
logo.
I
only
I
only
posted
this
just
because
I
was
doing
some
there's
a
press
release
that
went
out
this
morning
around
another
project
that
I
work
on,
but
the
logo
will
be
kind
of
you
know.
Octagony
and
it'll.
Look
like
that.
I
guess
don't
even
look
at
this
doesn't
even
matter
what
would
have
posted
up
there.
So
we'll
get
the
color
scheme
done.
We're
gonna
go
with
something.
That's
in
like
the
blues.
A
So
that's
that's
where
I
think
we're
gonna
end
up
in
I'm,
I'm
I
I'm
just
behind
on
handing
the
work
off
to
a
graphic
designer
just
to
finish
up,
but
hopefully
you
know
by
I
don't
know.
If
we
have
a
dave
plan
for
the
dot
15
release,
it's
sometimes
helpful
to
drive
towards
a
date.
Maybe
we
can
pick
one
out
together
on
slack
and
I'll
try
to
like
drive
towards
a
date,
because
we're
close.
E
A
G
Cool
yeah,
and
as
far
as
that
goes,
I
mean,
since
I'm
trying
to
put
the
documentation
together.
I
don't
know
where
all
that's
living,
but
god
damn
it,
but
as
that's
being
done,
if
y'all
just
want
me
to
start
plugging
it
into
the
to
the
working
website
to
you
know
see
the
documentation.
Updating
as
it
goes.
I
can
do
that.