►
From YouTube: Dec 16, 2020 wasmCloud Community Call
Description
Radu Matei demonstrates an experimental Wasm Berkeley Sockets API, Andrew Brown discusses the new WASI-NN design for WASI, and more.
A
Okay,
everybody
welcome
to
the
december
the
16th
watson
cloud
community
meeting,
where
we're
trying
to
enable
developers
to
build
their
function
and
services
and
webassembly
and
run
them
everywhere,
and
I
think
we've
got
a
couple
new
folks
joining
this
week.
Andrew
minxu,
do
you
guys
mind
just
doing
a
quick
little
intro
and
letting
us
know
what
you
work
on.
C
B
A
D
D
I
like
to
point
out
that
this
has
been
somewhat
sold
out
in
the
last
couple
of
months,
but
the
implementation
is
there
and
there
seems
to
be
a
consensus
about
its
about
the
api
so
far,
and
I
also
want
to
point
out
that
there
is
one
blog
post
from
kawamura
yodo,
which
has
been
extremely
helpful
in
all
this
process.
He's
documenting
adding
networking
for
line
engineering's
platform
and
his
blog
post
is
really
really
great.
D
I'm
I
link
to
all
of
these
in
in
my
blog
post,
so
in
short,
I'd
like
to
start
with
pointing
out
how
the
wazi
api
is
defined.
So
if
you
go
into
the
wasm
time,
repo
question
time
is
the
bytecode
alliance.
Implementation
for
was
is
a
webassembly
runtime
outside
the
browser
there
are
some
mentions
for
for
sockets.
Essentially,
there's
an
api
for
socket
receive
and
one
for
socket
send
but
they're
unimplemented
and
then
there's
no
way
to
actually
start
the
socket
connection.
D
So
the
first
thing
we
have
to
do
in
order
to
add
trouble
hearing
you
sorry
about
that
is
to
add
a
socket
connect
function
to
the
wes
api.
This
is
this
adds
it
to
the
wazzy
snapshot
preview
for
people
who
are
familiar
with
the
ephemeral
states
in
wazi.
You
could
add
it
into
ephemeral
state,
but
this
just
makes
it
easy,
because
it's
one
giant
file,
it's
not
much
of
a
difference,
whether
you
add
it
to
the
ephemeral
or
or
to
the
preview.
D
We
we
add
a
socket
connect
function
which
takes
an
ip
address,
a
port
and
then
returns
a
file
descriptor.
We
also
have
to
actually
implement
that
in
wazi,
and
this
is
the
main
reason
why
I
don't
recommend
anyone
using
this
particular
implementation
in
production.
This
just
starts
a
tcp
stream
and
returns
its
file
descriptor.
It
doesn't
take
capabilities
into
account.
It
doesn't
check
for
available
capabilities
and
things
like
that.
D
It's
just
a
proof
concept
that
we're
able
to
actually
start
a
socket
and
also
implementing
the
socket
receive
and
socket
send
on
top
of
essentially
rust
tcp
streams.
So
the
webassembly
module
requests
a
new,
socket
and
then
wasn't
time
actually
creates
the
tcp
stream
and
returns
its
file
descriptor
back
to
the
webassembly
module.
So
we
have
a
build
of
wasm
time
with
this
ape
with
this
new
api
and
then
right
now
we're
at
the
point
where
we
actually
want
to
implement
this
in
other
web
assembly
implementations.
D
D
So
we
can
there's
essentially
being
a
tcp
stream.
We
can
proxy
anything
we
want
on
that.
So
this
is
just
a
result
from
a
from
an
http
server
going
forward.
We
can
also
implement
this
in
the
rust
standard
library.
This
is,
it
requires
a
fork
of
the
rust,
compiler
and
standard
library,
so
I
wouldn't
recommend
anyone
doing
that
just
yet.
We'll
just
have
to
wait
for
upstream
support
in
in
rust,
but
if
you
wanted
to,
this
is
how
we
would
do
it.
D
E
D
E
D
Yeah
they're
they're
completely
separated,
so
once
we
build
a
rust
tool
chain
and
standard
library.
With
this,
we
can
basically
try
to
build
a
webassembly
module
that
just
imports
a
rust,
tcp
stream,
and
if
you,
if
you
build
the
entire
rust
tool
chain,
a
stage
two
build
compiler
with
llvm
and
the
rust
linker
and
everything
else
you
you
are
able
to
build
to
have
a
rust
compiler
that
can
build.
Wasm
was
e32.
D
A
A
D
For
some
reason
that
fails,
but
it
it
essentially
it's
it's
able
to
connect
and
to
send
messages
back
and
forth
through
the
standard
library.
So
that's
a
user
land
error
and
not
a
networking
error
so
in.
In
short,
this
is
trying
to
add
berkeley
sockets
to
wazzy
in
a
in
a
way
that
should
probably
not
be
used
in
production
right
now
and
I
I
would
recommend
people
watch
the
official
api
that
takes
into
account
capabilities
and
everything
else.
F
D
I
was
going
to
that
was
the
next
thing.
I
was
going
to
say
that
this
is
this
works
great
for
client
connections,
where
you
have
an
http
client
or
an
http,
2
or
udp,
maybe
or
whatever
client
connection
you
want
you're
trying
to
make
from
your
web
assembly
module,
but
for
actually
starting
a
server.
This
is
probably
not
ideal
and
the
reason
for
that
is
because
you
don't
have
multi-threading
at
all
in
webassembly.
So
unless
you're,
okay
with
having
single
threaded
server
listeners,
then
you're-
probably
fine,
but
it's
maybe
not
ideal.
For
now,.
A
E
So
the
wowzy
stuff
right
now
is
you
said
that
the
the
debate
had
sort
of
cooled
off
a
little
bit.
Do
we
know
if
there
is
sort
of
a
timeline
for
when
that's
going
to
stabilize,
and
if
so,
when
will
that?
When
will
this
the
berkeley
socket
stuff
make
it
into
multiple
engines
like
weizen
time
and
ysm3,
and
and
things
like
that.
D
The
good
part
about
the
the
open
pr
on
on
the
wazy
api
is
that
it
comes
with
a
work
in
progress
implementation
into
azim
time.
So
if
you
want
to
take
the
the
current
state
of
the
api
and
build
upon
it,
there's
a
fairly
good
starting
point
in
in
a
working
progress
branch
timelines.
I
have
no
idea
there.
A
D
Yeah
building
a
stage
2
rust
compiler
takes
quite
a
bit
of
time,
so
I
don't
think
everyone
will
want
to
do
this.
At
the
same
time,
I
think
if
we
want
to
meaningfully
contribute
to
this,
we
should
probably
be
looking
at
the
open
pull
request,
rather
than
my
put
together
implementation
for
this,
mainly
because
that's
complete
with
capabilities
and
everything
else
to
answer
kevin's
last
question:
I,
given
that
this
has
to
go
through
a
period
of
stabilization
in
wazzy
and
then
wasm
time
before
making
it
into
the
rust
standard
library.
B
B
D
A
Cool,
that's
awesome.
Well,
thank
you
again
so
much
for
the
demo.
I
think
it's
really
cool
to
share
what
you're
working
on
with
others
in
the
community.
Just
and
I'll.
You
know
cut
this
up
and
also
put
a
link
out
on
twitter
radio.
So
you
can
maybe
try
to
point
a
few
other
people
at
it
and
I
get
another
get
some
more
discussion
going
notes
from
our
last
meeting
are
posted
by
the
way
up
on
github,
along
with
the
lightly
edited
call
recordings.
A
A
What
I
hope
to
do
is
rope
you
into
a
demo
of
wazi
nn,
maybe
on
our
next
call,
whenever
that
is,
but
I
wanted
to
make
sure
that
everybody
had
seen
your
great
blog
post
that
went
on
the
bytecode
alliance
here.
Is
there
anything
that
you
wanted
to
comment
on
this
and
I'm
sorry
minx
you
as
well,
you
know
this.
This
blog
post
is
great
anything
that
you
guys
wanted
to
comment
on
here
just
quickly.
C
B
B
C
C
So
we
got
some
community
feedback
on
like
what's
the
next
step,
you
know
some
framework
writer,
for
example.
They
think
like
specific
operation.
Acceleration
is
more
important
to
them
because
they
don't
need
to
have
the
whole
framework
supported
right,
but
they
can
combine
to
web
assembly
and
having
a
few
operators.
You
know
accelerated
at
the
highway
level,
so
so
that's
kind
of
direction.
We're
looking
for
the
next
phase,
and
you
know
we
definitely
want
the
community
engagement
to
try
this.
What
we
have
implemented
already-
and
you
know
idea
for
improvement
for
the
next
phase.
A
A
Yes,
you
know
one
the
one
question
I
had-
and
I
know
that
this
is
this:
pull
request-
has
already
been
merged
into
awesome
time.
You
know
your
pull
request
there,
so
you
know
this
is
out.
There
was,
did
this
really
fit
at
the
at
the
wazi
level?
You
know
to
me
like,
in
my
simple
mental
map
I
always
feel
like
you
know,
wasm's
my
cpu
and
then
on
top
of
that
I've
got
wazi,
which
gives
me
some
of
my
os
type
stuff.
I
almost
felt
like
this
would
be.
B
Well,
I
I
I
would
have
preferred
to
do
to
have
done
a
lower
level
api
for
wazi
right,
like
a
a
wazzy
gpu
or
a
wazzy
tpu,
or
what
something
like
that
like
I
don't
know
what
would
be
in
those
calls,
but
right,
but
the
problem
is
right.
Now:
machine
learning,
the
ecosystems
moving
so
fast
that
that
api
would
be
quite
unstable.
B
C
Right
so
so
the
way
I
see
it
you
know
this
is
like
a
very
similar
to
early
stage
of
a
browser.
You
know
when
you
have
like
a
different
encoding
format
for
for
image
or
video
right.
So,
instead
of
trying
to
understand
you
know
actual
encoding
mechanism
like
implement
those
details
step,
you
know,
I
think
the
browser
approach
was
that
we
don't
really
care
about
the
actual
image
encoding
right.
C
We
just
take
the
image
which
is
a
model
and
and
then
there's
throw
it
to
the
hardware,
let
it
you
know,
decide
what
to
what
to
do
with
them
right.
So
so
I
think
this
may
not
be
a
bad
approach.
You
know-
and
you
know
just
assuming,
that
the
how
we
actually
understand
the
model
right
and
we
are
the
middle
man-
we
just
passed
along
this
model
and
then
how
to
decide
what
to
do
with
it.
E
Yeah,
so
for
me,
I
think
the
the
confusing
part
was
or
is
the
the
wazi
prefix
when
you,
when
you
first
see
it
it's
for
me,
I
was
trying
to
figure
out
whether
it
is
a
part
of
wazi
or
whether
it
just
depends
on
wesley
and
the
from
what
I
can
tell
from
the
api.
I
think
it
basically
depends
on
wazi,
because
you
need
some
file
based
stuff
in
order
to
do
the
model
loading.
B
E
B
E
Thing
that
that
I
like
about
the
the
imports
mechanism
in
webassembly
is
how
it
lets
you
keep
the
dependencies
as
as
isolated
as
possible,
and
so,
when
I
thought
about
how
you
might
slot
in
these
different
implementations
of
the
machine
learning
stuff,
I
don't
know
how
wise
and
time
is
is
planning
on
doing
it.
But
one
thing
that
I
would
want
to
be
able
to
do
is
to
be
able
to
get.
E
And
what
I'd
like
to
be
able
to
do
is:
choose
my
poor
wizzy
provider
and
choose
my
own
enm
provider,
regardless
of
what
the
west
end
thing
is
called.
So
that
way
you
know
if
I
or
I
would
want
to
be
able
to
do
the
machine
learning
stuff
on
straight
up
their
actors,
their
webassembly
modules,
that
have
no.
E
B
B
E
B
C
A
Well,
I
I
think
you
know
from
the
spirited
discussion
on
this
already
that
there's
a
probably
a
lot
of
opportunity
to
brainstorm
with
this
group,
and
I
was
I
was
really
interested
and
you
know
we'd
just
love
to
also
point
out.
You
know:
radu's
got
a
post
here
on
some
of
his
tensorflow
experiments
and
andrew.
A
Okay,
great
great,
so
I
know
we're
kind
of
short
on
time
here,
so
we
can
kind
of
skip
through
a
few
of
these
ralph
is
out
on
the
he
dropped
already
on
the
cressley
crit
follow-up.
So
we'll
put
a
pin
in
that
brooks.
Did
you
get
your
feedback
on
your
pull
request
that
you're?
Looking
at
on
the
crestlit
follow-up
here.
H
A
All
good
and
then
jared,
and
maybe
jordan
and
any
others
we're
we've
got
the
kind
of
website
laid
out
for
how
we
want
to.
You
know
you
relaunch,
you
know
under
the
watson
cloud
name
and
I'd
love
to
loop
in
a
couple
folks
on
a
separate
meeting,
because
we're
kind
of
short
on
time
here
on
the
two
news
on
that.
A
So
if
you
guys
are
okay
with
that
I'll
ping,
you
guys
on
slack
and
grab
30
minutes
with
you
and
we
can
kind
of
lay
out.
You
know
all
the
steps
and
tasks
that
we
need
to
to
get
that
moved
over.
We
picked
out
a
nice
template.
You
know
the
project's
gonna.
Have
you
know
a
real?
You
know,
I
think
a
much
more
product
type
feel
to
it.
E
Yeah,
so
these
are
basically
you
know:
15
20,
minute
tickets
or
issues
whatever
you
want
to
call
them
we're
using
the
code
generator
to
convert
the
whittle
schemas
into
modules
for
these
specific
languages.
So
we've
got
rust,
assembly,
script
and
tinygo,
and
the
basic
idea
is
that
we
have
these
small
modules
that
actors
use
if
they
want
to
interface,
if
they
want
a
specific
host
interface.
E
E
A
H
I
can
I
can
do
a
demo
shortly
today
or
I
can
skip
it,
but
probably
like
long
story
short.
What
I'm
going
to
try
to
do
is
road
map
out
a
0.2.0
release
for
wash,
which
includes
the
the
repel
and
and
essentially
all
the
functionality
that
we
want
to
come
with
the
wasm
cloud,
15
release,
so
that's
mapped
out
in
the
wiki
or
you
can
see
wherever
milestones
are
in
in
the
repo.
H
The
repl
is
about
to
be
merged
into
maine,
with
that
functionality
there,
including
being
able
to
call
actors
and
link
actors
and
providers,
and
I've
marked
a
couple
of
these
issues
for
that
release
as
well,
so
that
when
we
release
wasmcloud
0.15,
we
can
also
push
out
this,
like
very
distinct
version
of
the
command
line.
Tools
that
we're
packaging
with
it
and
that'll.
Give
us
a
great
starting
point
for
writing,
documentation
and
tutorials
and
and
getting
people
using
the
product
in
a
way
that
you
know
is,
is
good
and
easy
for
the
developer
experience.
H
So
once
we
get
that
out,
I
am
going
to
be
really
excited
to
see
what
people
think
about
our
documentation
and
the
experience
with
the
repel
if
you're
interested
in
trying
it
out.
Now
I
put
a
post
in
the
wasmcloud
channel
in
slack,
so
that
is
available.
If
anybody
wants
to
play
with
the
rebel
as
it
is
today,.
A
I
A
I
A
E
We
don't
we
don't
need
a
nightly
build.
We
don't
have
nearly
enough
consumers
to
warrant
such
a
thing.
What
what
we're
talking
about
with
that
with
the
build
issues?
Is
that
on
this
one
there
there
are
a
couple
of
these
release
actions,
but
we
don't
actually
have
the
regular
building
actions
there.
There
were
some
build
actions
that
the
old
west
coast
used
to
have
that
are
that
haven't
been
migrated
over
or
upgraded?
E
A
I
E
I
A
Okay,
sweet
I'll
make
sure
that
we
we
link
that
in
link
that
into
the
notes
too,
on
the
docker
compose,
I
think
that's
a
super
helpful
and
then
on
the
azure
registry.
Right
now,
our
azure
registry
is
wasp.azure.you,
know
whatever
io
or
something
like
that.
We
have
created
the
new
one
called
wasmcloud
and
we're
waiting
on
them
to
enable
public
polls
and
then
I'll
set
up
a
separate
meeting
to
follow
up
on
getting
a
website
over.
A
For
that,
and
the
last
thing
I
think
we
have
on
the
agenda.
Just
is
just
a
quick
check
in
on
the
iteration
for
the
new
dot
15
demo
experience-
and
I
know
that
brooks
you
were-
you
were
putting
some
comments
in
here,
as
we,
like,
you
know,
filled
in
some
of
the
yada
yada
yada
and
all
this
stuff
became
real
here.
J
One
of
the
things
that
I
had
a
question
about
was
more
with
wash
and
what
is
being
referred
to
as
the
rebel.
It
was
unclear
to
me
when
I
first
jumped
into
it
what
the
what
the
rebel
environment
actually
was
before
I
had
used
it
with
the
talk
I
assumed
it
was
a
rebel
for
all
of
wash,
but
none
of
the
wash
commands
actually
worked
in
the
rebel.
It
was
some
sub
set
of
commands.
J
E
E
You
can
also
do
from
inside
the
rebel,
and
the
other
requirement
is
that
everything
that
you
can
do
to
and
and
get
human
readable
output
from
the
command
line.
You
can
also
do
to
get
json
based
output
from
the
command
line,
and
I
I
don't
know
if
we
have
issues
tracking
that,
but
I
know
we're
not
feature
complete
on
having
all
of
the
wash
commands
available
inside
the
rebel
okay.
J
A
E
No
there's
not
really
all
that
much
that
I
wanted
to
go
through.
I
mean
we're
pretty
close
to,
if
not
functionally
complete,
on
the
the
new
wasmcloud
host.
So
now
it's
just
dotting
the
eyes
and
crossing
the
t's
and
making
sure
that
everything
is
tested
and
everything
is
automated,
so
that
going
forward
we
don't
we
don't
have
any
issues.
A
Okay,
that's
great,
and
I
tried
to
put
a
list
of
interesting
demos
and
some
topic
backlogs
here
in
the
towards
the
bottom.
You
know
this
is
all
publicly
editable.
So,
as
we
saw
with
our
little
experience
earlier,
you
know
feel
free
just
to
drop
in
and
add
your
own
little
participation
here.
If
there's
anything
that
anyone
else
would
like
to
see.
A
But
as
we
you
know,
I
think
the
next
few
weeks
look
like
you
know,
feature
complete
on
dot,
15
and
then
some
effort
around
the
documentation
and
the
writing
and
those
components
and
then
possibly
on
to
you
know
some
of
the
more
advanced
tutorials
and
demo.
You
know
little
video
recordings
as
we
look
at
katakota
tutorials
and
things
like
that.
So
certainly
an
exciting
few
weeks
ahead
of
us
and
it
should
make
the
ecosystem
a
lot
more
user-friendly
and
easy
to
use.
C
A
Happened
this
week
that
I
some
people
here
might
find
useful.
Please
go
ahead
so
this
week
released
bindle,
so
you
may
have
seen
that
on
the
interwebs,
which
is
just
some
experimentation,
we're
doing
around
it's
it's
for
webassembly
modules,
especially
when
you
have
like
multiple
web
assembly
modules.
That
end
up.
Thank
you
ready
for
sending
that.
I
am
currently
on
my
phone
because
my
windows
machine
and
my
I'm
on
my
windows
machine,
which
is
not
my
macbook
and
doesn't
have
a
webcam
and
so
anyway.
A
But
yes,
so
it
is
a
aggregate
object,
storage,
and
so
the
idea
behind
it
is
that
you
can
store
things
that
are
whole
aggregate
application.
So,
for
example,
in
a
wasn't
cloud
context,
if
you
wanted
to
have
the
these
actors
with
various
providers
that
they
could
use
in
in
different
circumstances,
those
could
all
be
stored
within
the
same
bundle.
So
the
yeah
right
there,
the
silverware
drawer,
is
the
example,
so
you
don't
store
every
type
of
silverware
setting
in
its
own
package.
A
So
you
don't
set
up
like
your
your
fancy
dinner
thing
with
forks,
that
you
use
it
three
other
meals,
all
like
all
in
separate
packages.
Instead,
you
put
it
all
together
and
then,
when
you
need
to
put
together,
let's
say
a
fancy
dinner,
you
pull
out
your
fork
and
that
one
that
one
kind
of
soup
spoon
that
you
need
and
a
teaspoon
for
stirring
in
something
to
your
after
dinner,
coffee
and
there's.
A
There
could
be
four
or
five
different
things,
whereas
for
breakfast,
all
you
need
is
just
a
single
spoon,
and
so
those
are
the
kinds
of
things
that
we
that
especially
in
the
webassembly
world,
actually
is
a
very
good
analog
for
what
can
be
done,
and
so
this
is
something
that's
just
an
experiment
right
now,
but
we
found
some
really
interesting
use
cases
for
it.
You
can
look
at
the
introductory
blog
post
on
the
deus
labs
blog.
A
That
kind
of
does
a
little
bit
more
detailed
explanation
and
there's
also
a
webassembly
doc
in
our
docs
directory
of
the
repo,
and
that
one
is
kind
of
a
more
long-form
example
of
what
we
envision
using
the
from
using
bundle
for
so
anyway,
it
we'd
love
to
hear
people's
thoughts
and
ideas,
and
and
if
they
they
like
it
and
they
feedback
it.
Bindle
is
a
specification
as
well,
so
it
doesn't
have.
This
is
the
rust
implementation,
that's
supposed
to
service
the
reference
implementation,
but
it
can
be
implemented
in
any
language.
A
In
fact,
I
think
if
it's
not
already
open
source
butcher
will
be
doing
it
soon.
We
have
like
a
node.js
one
that
consumes
bindles,
so
we
have
a
bunch
of
different
things
that
are
that
are
out
there
that
we're
trying
out
with
this
so
anyway
just
wanted
to
throw
it
out
there,
like,
I
said,
kind
of
dropped
last
week
after
the
call
this
is
kind
of
adjacent,
it
isn't
necessarily
directly
related,
but
it
could
enable
some
really
interesting
use
cases.
Yeah.
A
Yeah,
so
a
bundle
is
the
whole
collection
of
everything
and
a
bundle
contains
an
invoice
which
is
like
the
main
description
of
what
are
the
things
that
are
contained
in
here
and
some
useful
metadata
and
a
bundle
will
contain
a
list
of
parcels,
parcels
and
labels.
So
parcels
are
the
actual
files
or
objects
or
whatever
they
are
that
that
are
involved
here.
So
a
parcel
consists
of
a
label
which
is
the
metadata
about
it
and
then
an
arbitrary,
but
it
doesn't
matter
what
it
is.
A
It's
just
an
arbitrary
file
binary
text
file
could
be
anything
that's
uploaded
to
the
server
and
then
you're
able
to
there's
a
filtering
mechanism,
that's
built
in
there
right
now
we're
going
to
keep
iterating
and
adding
more
to
that.
That
allows
you
to
select
a
certain
list
of
parcels
based
on
the
features
you
want
activated.
So
basically
the
set
you
want.
It's
the
whole
brexit
like.
If
I
want
my
breakfast
feature,
then
I'll
get
something
that
only
gives
me
the
spoon
parcel.
A
A
A
To
that's
the
features
part
of
it
so
features
is
metadata
and
we
called
it
features
because
it's
specifically
like
meant
to
be
used
where
okay,
what's
the
os,
what's
the
architecture,
what
what
are
the
conditions
needed
for
this
and
you're
able
to
filter
on
those
features
we
figured
you
might
like
this
kevin,
we
actually
even
mentioned,
wasn't
cloud
in
the
introductory
blog
post
that
we
think
it
might
be
useful
here.
That's
why
we're?
We
would
really
love
any
feedback
that
you
you
all
have
around.
E
A
E
I
think
a
worthwhile
experiment.
We
should
probably
put
it
in
create
an
issue
for
this
inside
our
capability
providers.
Repo,
is
to
see
whether
we
can
represent
the
same
amount
of
data
that
we're
currently
using
in
in
what
we
call
parjeezy
files
as
a
as
a
bindle,
and
then
we
can
sort
of
use
that
as
beta
tester
feedback
on
the
spec
and
the
implementation.
A
That
would
be
great
we'd
love
that,
but
yes,
this
was
this
was
such
an
experiment
that,
like
we
apologized,
we
didn't
like,
say
anything
sooner
but
like
we
didn't
really
have
this
solidified
like
on
kind
of
what
we
wanted.
The
whole
spec
looked
like
until
about
two
weeks
ago,
so
I
do
know
that
definitely
figured
into
it.
H
No,
this
is
awesome.
I
think
that
we
should
definitely
do
a
proof
of
concept
with
pardeezy's
as
a
bindle.
One
thing
that
I
saw
that
looked
super
awesome,
as
I'm
scrolling
through
the
repo
is
that
bundles
are
immutable
once
you
form
them,
which
I
think
yes
is
even
better
for
us.
You
know
once
we
sign
and
push
a
bindle
or
you
know,
part
gz,
whatever
we
there's
not
much
of
a
use
case
to
modify
it
later
on
and
that
guarantees
what
we
need.
Ours
are
essentially
immutable.
A
Yeah
and
ours
uses
mainly
a
the
idea
of
that
the
name.
The
name
is
an
arbitrarily
pathy
string
and
version
is
a
it's
a
hard
sembler
requirement.
So
it's
it's
very
strict,
like
actual
sember
requirement,
that's
used,
and
then
we
stole
the
idea
of
yanking
from
crates
that
we
really
like
that
concept,
and
so
the
only
thing
you
can
do
to
a
bin
once
it's
once
you
publish,
is
to
yank
it,
and
so
like
that's
pretty
much
it.
So
it
is
immutable
and
we're
keeping
it
that
way.
A
But
I
really
I'm
really
curious.
I
think
I'm
I'm
guessing
based
on
what
you
said.
One
of
the
few
gaps
might
be
just
how
you
are
approaching
signing
and
what
we
would
need
to
do
to
be
able
to
handle
that
signing
approach
or
if
our
signing
approach
works
or
or
whatever,
but
yeah
like.
I
said.
I
think
I
think
this
will
be
useful
on
for
for
everyone
here,
because
I
think
it
really
models.
The
web,
like
wasm
module,
conglomeration,
really
well.
H
A
We
have
we
have
not
done
that
yet,
but
we
as
we
assumed
when
we
were
writing
this,
that
someone
would
immediately
want
to
or
that
we
might
even
write
like
an
oci
shim
layer.
The
idea
here
is
that
this
is
not
supposed
to
be
a
takeover
for
what
oci
does
it's
just
supposed
to
be
a
different
way
of
approaching
dependencies
for
just
dependencies
really
dependencies
for
binaries
depends
for
that,
not
just
like
layers
and
and
how
those
layers
associate.
A
So
the
o,
the
oci
component
here-
is
not
there
yet,
but
I
don't
we
we've
discussed
it
and
we
don't
think
it
would
be
extremely
difficult
to
have
a
shim
between
a
bundle
and
an
oci
compatible
layer.
The
big
thing
you're
going
to
get
over
using
bindle
natively
is
that
you
don't
have
to
fetch
all
the
layers.
If
you
don't
need
everything.
E
At
all,
like
what
we're
doing
now
with
our
files,
is
our
provider
archive
file
we're
just
sending
up
as
a
single
layer
and
so
we're
getting
we're
getting
it
down
we're
pulling
it
down
as
a
single
layer
as
well
so
yeah,
which
is
what
we
do
too
yeah.
The
least
that
could
possibly
be
done
is
to
treat
a
bundle
file
as
a
single
layer
but
yeah.
I
think,
looking
into
being
able
to
separate
the
parcels
as
layers
so
that
you
can
then
pull
from
an
oci
registry
based
on
feature
that
would
be
pretty.
A
Neat
yeah
see
that
and
that
that's
what
we're
hoping
that
this
can
help
with,
for
that
specific
reason
is
that,
like
layers,
just
aren't
a
good
representation
for
this
kind
of
aggregate
application,
so
that
that's
the
that's
one
of
the
big
reasons
and
we
thought
it
would
be
useful
to
talk
about
here.
One
question
I
have
taylor
is
that,
if
we're,
if
we're
bundling,
you
know
all
the
all
the
components
together
are
we
kind
of
reintroducing?
A
You
know
that
one
of
the
flaws
we
see
with
containers
is
that
you
have
like
you
know.
You
know
like
components
that
you
need
to
keep
up
to
date
and
version
out
and
all
that
kind
of
stuff.
You
know,
like
you
know
that
gets
stale,
because
it's
like
packaged
over
here
in
this
container.
You
know
something
along
those
lines.
A
I
don't
think
there's
necessarily
my
understanding
of
it
is
that
there
really
isn't
this
isn't
built
as
a
solution
to
that
problem
like
you're
still,
if
you
have
a
new
ver,
a
new
dependency
of
like
your
a
provider
like
you
need
a
new
provider
version
in
here
and
it's
represented
in
the
bundle.
Then
you
have
to
push
a
new
bundle
version
with
that
parcel
referenced
in
the
parcel
list,
but.
E
The
thing
is
right:
the
the
bundles
are
internally
cohesive
or
internally
consistent
right.
So
you
can't
you
can't
create
a
parcel
that
refers
to
something
outside
which
is
essentially
the
the
flawless
talking
about
in
in
containers
where
you
have.
You
can
have
a
a
doctor
image
that
that
has
a
slice
that
can
be
replaced
on
you
without
your
knowledge.
A
Yes,
exactly
we're
trying
to
avoid
that,
because
once
you
can't
because
they're
immutable,
nothing
can
change
in
that
partial
list
and
that's
kind
of
the
basis.
Once
you
look
at
our
signing
thing
kevin
about
like
how
we're
using
that,
because
if
you
sign
the
whole
because
everything's
immutable,
if
you
sign
that
that
specific
information,
then
you're
assured
that
it's
not
changed,
and
so
there
there
isn't
going
to
be
like
some
weird
like
inserting
of
another
dependency.
If
that's
what
you're?
A
So
if
there's
three
bundles
that
all
refer
to
the
same
parcel,
then
there's
no
need
to
upload
it
again,
which
exists
partially
in
oci.
But
it
gives
you
a
better
ability
to
filter
and
pull
down
those
proper
ones.
Okay,
that's
awesome!
Well,
we
are
over
on
time.
I
really
appreciate
everybody's
patience
today
and
we'll
have
that
address
moving
forward.
So
just
a
quick
show
of
hands.
Do
we
cancel
next
wednesday
or
which
would
be
the
23rd
or
do
we
keep
it
on?
A
E
A
A
Well,
let's,
let's
plan
on
just
a
killing
the
next
two
weeks,
then
and
then
separately
I'll,
do
a
call
in
slack
for
anybody
that
wants
to
hop
on
and
work
on
a
website
stuff.
You
know
and
try
to
knock
that
out,
maybe
over
break
would
be
a
goal
for
a
goal
for
me.
If
anybody
wants
to
jump
in
and
help
more
than
welcome,
there's
plenty
to
do
on,
like
you
know,
moving
documentation
over
and
the
new
structure-
and
you
know
stuff
like
that
up
a
great
meeting
today,
awesome
contribution.