►
Description
Marine: dynamic Wasm modules linking - presented by @mikevoronov at IPFS bing 2022 - IPFS and WASM - https://2022.ipfs-thing.io
A
My
name
is
mike
and
I'm
from
cleveland
swaps,
and
today,
I'm
going
to
tell
you
about
marine.
Our
general
purpose
web
assembly
run
time.
The
toy
content
for
run
multimodal
web
assembly
applications
and,
in
particular
the
agenda
of
my
talk,
is
as
follows.
So,
first
of
all,
I
will
talk
a
bit
about
the
webassembly
component
model.
A
I
think
that
it's
like
the
most
valuable
proposal
that
now
webassembly
folks
try
to
push.
Then
I
will
talk
also
a
bit
about
how
we
use
webassembly
influence
and
why
we
need
our
own
runtime
and,
what's
like
use
case
for
web
assembly
in
like
fluent
swaps,
and
how,
for
example,
aqua
vm
that
was
already
mentioned,
also
approach
this
model
and
then
finally,
we
will
talk
about
the
architecture
of
marine
and
how
sdk
and
tools
and
how
you
could
use
marine
debug
your
application
and
how
it
could
be
used,
probably
with
ipod
and
ipfs.
A
So,
let's
start
with
the
webassembly
component
model
with
some
basics,
but
first
of
all
like
to
be
on
the
same
page,
I
need
to
say
that,
like
webassembly
has
one
important
restrictions
that
like
already
was
already
mentioned,
and
this
restriction
is
about
types.
Yes,
webassembly
has
only
five
basic
types.
They
are
two
integers
two
voting
point
and
one
at
types
for
sims
instructions,
and
usually
everyone
who
develops
their
own
runtime
stumbled
across
the
problem
that
like
we
need
to
pass.
A
Not
only
numbers
but
complex
objects
like
strings
arrays
structures
and
the
stuff
like
that
and
like
almost
all
runtimes
tries
to
solve
it.
Yes
tries
to
provide
some
ebi
to
like
grab
string
from
memory
converted
to
point,
run
the
size
and
lower
it
back.
So
it's
like
usual
usual
thing
for
almost
every
every
runtime
before
the
component
model,
because
component
model,
like
I
I
got,
I
got
all
the
stacks
from
the
official
proposal.
B
A
You
could
see
here
like
the
first
three.
Hello
goes.
Yes,
the
first
one
is
a
defined
portable,
binary
format
that
would
be
like
could
provide
your
language,
agnostic
interface
and
also,
I
would
say
that
not
only
language
agnostic,
but
also
operation
system
and
architecture,
agnostic
interface.
I
think
it's
the
most
valuable
part
of
this
proposal,
and
on
this
slide
you
could
see
that
could
be
called
lightweight
component
model
view.
A
So
here
you
could
see
like
a
container
or
an
application
or
a
microservice
that
contains
several
webassembly
modules,
and
but
all
of
this
module
is
comprised
from
different
modules.
So
you
could
consider
this
as
a
like
these
green
boxes,
you
can
consider
as
a
like
applications
that
itself
comprised
from
libraries,
yes
like
when
you,
when
you
write
on,
I
know
on
c
plus
rust
and
so
on,
you're
always
using
some
standard
libraries.
A
Some
other
libraries
and
component
is
a
thing
that
combines
combining
together
and
like
having
like
high
level
every
users.
You
could
come
combine
several
components
in
one
container
and
what
in
like
this
arrows
it's?
What
actually
marine
does
so
component
could
be
considered
as
a
modulus
or
applications
and
like
if
you
want
to
have
several
modules
simultaneously,
won't
combine
them,
want
to
dynamically
load
and
load
them.
A
So
in
this
case
we
could
use
marine,
and
you
know
like
I
have
been
watching
for
the
component
model
proposal
for
a
long
time
for
about
four
years,
and
I
would
say
that
this
proposal
has
a
difficult
fate,
really
difficult
wait
here.
You
see
like
main
milestones,
so
actually
component
model
proposal
is
combined
from
two
proposals.
First,
one
usually
called
interface
types
and
second
one
is
model
linking
yes
in
interface
types
it
there
were
a
lot
of
milestones.
A
By
milestone,
I
mean
something
that
completely
changes
proposal
and
like
in
2021
roberts,
only
folks
decided
to
combine
them
together
in
one
proposal
and
the
split
interface
types
to
two
proposals
and
use.
So
I
will
show
you
later,
but
now
in
component
model,
only
like
a
tiny
fraction
of
interface
types
of
initial
interface
types
version,
two
that
the
code
here
only
used
and
then,
like
other
other,
like
part,
is
called
adapter
functions.
A
They
only
like
in
in
appliance,
but
component
model
is
already
there.
You
could
use
it
from
watson
time
from
marine.
I
would
show
you
the
difference
so
like
and
and
difference
on
the
slide.
So
what
sometimes
like
allows
you
to
do
component
but
doesn't
allow
you
to
combine
companies
together,
like
it
doesn't,
allow
you
to
the
dynamic
world
and
load
modules.
A
So
let's
talk
a
bit
about
interface
types
and
about
model
linking
so
interface
types,
it's
very
old
picture
from
2017,
but
not
so
much
changed
from
this
time.
A
By
adapted,
I
mean
that,
like
it
could
lower,
it
could
lift
and
lower
types.
So,
for
example,
in
adapted
module
you
could
pass
strings
race
and
complex
types.
Then
it
could
lower
it
and
call
raw
module
that
do
the
do
like
actually,
like
all
logic
and
and
back
yes
and
back,
you
could
leave
type
from
raw
module
and
provided
as
a
complex
object
as
an
output
or
also
could
use
lifting
for
imports,
usually,
like
all
interface
types,
all
stuff
related
to
them.
A
They
are
located
in
a
custom
section,
because
custom
sections
are
completely
user
defined
and
you
could
see
you
could
put
it
like
any
bytes.
You
want,
and
usually
they
are
located
in
nothing
like
their
own
section
but
like
in
a
custom
section.
The
next
proposal
is
moodle
linking
so
model.
Linking
is
just
what
like
what
we
need
to
combine
modules.
A
Actually,
there
are
two
types
of
linking
scheme
characteristic
and
shared
nothing.
So
the
first
one
like
based
on
chart
everything
from
a
module
every
every
state,
every
state
that
the
store
like
according
to
specification,
has
such
as
memories
tables,
globals
imports
and
so
on,
and
the
second
one
like
station
is
different
module
encapsulated
state
and
provides
only
experts
and
inputs
and
modules
could
be
combined
together
only
by
imports
and
experts.
A
On
the
side,
you
could
see
also
like
a
picture
from
the
official
presentation
of
component
model.
Here
you
could
see,
like
main
keywords,
main
new
keywords-
probably
the
most
interesting
part
is
here-
is
adapted
function
that,
like
remember,
that
was
switched
from
interface
types
as
a
separated
one,
and
here
you
could
see
like
lower
params
and
lift
result.
A
So
this
how
interface
types
would
work
just
like
they
receive
stream,
yes
or
like
any
any
complex
object,
then
lower
it
to
webassembly
to
row
of
assembly,
module
memory
and
pass
and
call
x
the
actual
function,
yes
and
then
the
lift
result
back
and
it
what
actually
like.
So
in
ipod,
it's
there
is
a
similar
process,
so
we
also
have
like
a
so-called
data
module
and
you
have
rules
how
data
could
be
lifted
and
lowering
according
to
the
different
targets.
A
So
in
this
sense,
like
interface
types,
is
very,
very
similar
to
ipod,
in
my
case
so
in,
in
my
opinion,
sorry,
and
also
the
last
last
slide
from
the
official
presentation.
It's
how
it's.
What
is
the
target
of
component
model
here?
You
can
see
a
spawn
like
what
was
only
folks
says
that,
like
we
have
trade-offs
here,
we
could
support.
A
We
could
support,
for
example,
static
life
cycle
static
linkage,
but
like
nodejit
and
no
garbage
collection
on
other
side,
you
could
support
full
jit,
yes,
but
know
these
properties
and
the
goal
of
component
model
is
to
support.
Only
this
part
is
that
what
I
said
to
icons
is
picture
these
green
boxes,
so
it's
like
actually
green
boxes,
is
only
a
static
linking.
So
when
you
it's
you,
you
could
consider
it
as
a
like
when
you're
programming
on
cc,
plus,
plus,
rust
and
etc.
A
And
the
last
slide
from
this
section
is
about
fit
interface.
That's
what
I
ask
so
actually
like
component
model
proposal,
also
specifies
so
actually
it's
a
very
complex
proposal.
It
I,
I
would
say
that
it's
rule
changer
for
zero
assembly
world.
It
specified
with
interface.
A
So
it's
this
interface
comprised
of
several
like
keywords,
but
there
is
a
keywords
related
to
like
data
format
so
and
and
there
you
could
see
that,
like
wheat
interface,
support
records,
list,
tuples
and
all
star
all
bunch
of
complex
types,
so
with
interface,
you
could
describe
every
type
you
want
actually
so
like
when
component
model
like
would
take
place
and
would
widespread
there
wouldn't
be
any
necessity
for
custom
ebi
for
custom
type
conversion,
martial
lifts
in
and
over
and
so
on.
So
there
will
be
standard
way
to
do
that.
A
A
It
allows
you
to
coordinate
and
orchestrate
network
requests
and
how
it
connected
with
webassembly.
A
So
basically,
aqua
allows
you
to
like
compose
web
assembly
modules
located
on
our
peer-to-peer
network
and
in
a
self
this
modules,
or
I
would
say
that
services
and
I
would
describe
what
services
on
the
next
slide,
but
the
services
there
are
webassembly-based
they
based
on
a
websimilar
component
model
with
help
of
interface
types
and
model
linking
they
could
be
state
forward,
stateless
and
they
could
be
extendable
like
with
so-called
mounted
binaries,
so
actually
from
a
web
assembly
module.
We
could
call
external
binary.
A
I
I
would
show
you
interface
later,
so
that's
how
it
could
be
extendable
and
fluent
service
actually
is
just
a
group
of
modules,
combined
together
with
the
sharedness
and
linking
scheme,
and
one
thing
that
I
forgot
to
mention.
So
if
you
need
shared
nothing
scheme,
you
would
need
interface
types
because
it's
impossible
to
decouple
like
complex
type
from
webassembly
memory,
without
revealing
memory
table
and
so
on.
The
only
way
to
do
that
is
with
help
of
interface
types
and
that's.
A
Why,
like
marine,
also
support
all
this
component
model,
and
here
you
could
see
example
of
fluent
service
comprised
of
three
modules,
so
we
have
like
sqlite
radius
compiled
assembly
and
compatible
with
marine
interface
and,
like
I
hear
escalate,
is
linked
together
with
some
module
called
facade
through
exports
and
imports,
and
also
imagine
that
there
is
a
some
amplification
module
that
also
linked
with
the
facade
one
actually
like
in
web
assembly
or
sorry
influencer
apps.
A
We
have
chosen
web
assembly
because,
like
it,
provides
a
lot
of
advantages
like
really
what
first
of
all
it
allows
us
unboxing
modules
by
design,
so
our
miners
could
not
like
think
about
security,
the
module,
so
they
could
control
effects.
They
could
control
modules
that
like
allow
you
to
do
something
manageable
on
your
system.
A
Also
webassembly
allows
you
to
make
life
cycle
of
modules
independent
on
each
other
with
help
of
component
model,
so
you
could
develop
your
module
or
one
could
develop.
One
developer
could
develop
their
module
like
with
only
consistent
api,
so
in
this
like
as
a
it,
could
be
considered
as
development
of
dynamic
library.
A
So
it's
the
same
experience
and
here
you
could
see
like
slides
that
have
already
been
used,
so
it's
cow
maureen
is
used
inside
our
peer
architecture,
so
actually
marine
is
run
time
and
in
marine
we
run
both
services
and
aquaviums,
and
there
are
like
a
bunch
of
services,
bunch
of
aquavium
so
and
the
queue
that
manages
pool-
and
there
is
a
like
pure
core-
that
manages
queues
and
handle
events
between
the
skews
and
a
fluence
network
could
be
considered
like
this
on
every
period.
A
In
our
network
there
is
a
marine
and
there
is
aqua,
vm
and
also
marine
could
be
run
in
a
browser
on
the
client
side.
So
there
is
a
like
almost
the
same
experience
and
what's
dike,
what
dick
into
the
marine
one
time
itself.
A
So
when
we
initially
started
the
marine
we
defined
some
high
level
goals,
so
the
first
one
is
the
most
important
one
is
maureen
should
provide
like,
like
the
best
developer,
experience
that
possible
yes
and
for
us
the
best
developer.
Experience
is
like
allowing
developers
to
write
on
when
you
are
asked
as
where
is
possible.
A
A
And
here
you
could
see
the
marine
architecture
very,
like
high-level
blocks,
so
marine
actually
has
layered
architecture
and
on
the
bottom
side
we
have
like
supported
run
times.
Here
you
could
see
was
mirror
and
some
browser
runtimes.
So
for
right,
size
there
is
like
doesn't
like.
There
is
no
difference
between
runtime
and
on
the
right
side.
We
support
now
vasmir
and
move
into
wasm
time.
So
it
supports
us
and
we
have.
We
have
a
core
and
the
main
like
feature
of
core.
A
So
this,
like
part
of
marinette
itself,
for
marine
and
marine
js.
So
you
could
find
also
like
the
complete
details
and
complete
description
of
the
scheme
in
our
marine
book.
So
then
link
here
so
and
how
like?
How
we
approach
this
multi
modules?
So
actually
we
have
three
types
of
modules.
The
first
one
is
facade,
so
for
said
modules
they
expose
their
api
of
like
entire
service
and
only
they
could
be
called
from
aqua,
not
like
every
module
from
service,
but
only
facade
pure
modules
say
contain
pure
logic.
A
They
can't
access
file
systems,
they
can
access
external
binaries
and
the
the
last
one
is
factors
effectors
could
access
everything?
Could
access
file
systems
through
yz
circuits
when
they
will
be
ready
when
we
switch
to
washing
time
and
stuff
like
that?
A
So
why
we
need
pure
and
effector
modules,
because
effectors
are
those
modules
that
could
damage
your
system,
damage
system
of
miners
and
miners
should
have
a
chance
to
pick
which
modules
they
trust,
which
effector
models,
they
trust
and
when
you
deploy
pure
module,
so
everyone
could
be
could
feel
safe
because
pure
module
doesn't
call
any
import
and
yeah
web
assembly
is
unboxed
itself
by
design,
and
here
you
could
see
another
picture
how
it
could
be
represented,
so
marine
could
load
several
modules,
combine
them
together
to
services
and
provide
a
way
to
call
these
services
from
like
from
the
external
api
and
like
let's
dive
a
bit,
how
like
service
looks
like
and
what
is
how
they
could
combine
together.
A
So
here
you
could
see
service
configurations,
basically
thomas
file,
so
let's
consider
services
that
contains
of
three
modules.
It's
like
just
example:
it's
not
like
real
service,
so
the
first
module
is
first
aid.
It
should
be
more
like
put
as
a
last
line
this
next
one
is
a
cool
adapter,
so
here
we
could
see
that
we
should
specify
name
and
also
should
specify
the
section
called
mounted
binaries.
It's
essentially
our
interface
to
external
binaries,
and
this
black
line
allows
a
module
to
call
binary
located
by
this
bus.
A
The
last
one
is
vocal
storage,
so
here
could
see,
buy
and
show
off
settings,
for
example,
for
each
model
you
could
adjust
like
a
memory
maximum
memory
size.
Also,
you
could
adjust
a
yg
state.
You
could
say
that,
like
this,
module
could
use
only
these
files
and
inside
like
there
is.
It
could
be
a
mapping
from
like
this
path
to
some
shorthand.
A
And,
probably
is
the
most
important
think
here
for
those
who
want
to
use
marine
from
as
a
runtime
itself
from
their
ras
project
is
a
the
cinema
code
type
value.
So
I
value
is
like
in
num
that
you
could
use
specifying
host
experts
host
imports
and
using
it
as
a
like,
like
from
your
rust
projects.
A
So
several
guys
said
that,
like
it's
really
difficult
to
like
work
with
pointers
like
grabbing
strings
from
memory
and
stuff
like
that-
and
here
like
you-
could
see,
I
value
the
type
that
like
allows
you
to
do.
Not
use.
Don't
do
that.
Yes,
it's
like
has
just
ring
just
array,
and
this
type
is
a
like
type
that
you
could
use
in
your
host
export
function.
A
So
it's
function
that
you
are
written
on
rust
or
like
language
that
you
from
from,
like
from
those
that
you
use
marine,
and
here
you
could
see
a
descriptor
of
host
exported
function.
So
actually
this
function
is
a
quarter
that
takes
some
context.
It
doesn't
matter
so
it's
just
allows
you
to
do
some
more
stuff
and
a
vector
of
I
values
and
a
values
is
essentially
an
argument
that,
like
would
put
into
your
import
function
and
the
result
is
also
value.
A
So
here
you
could
specify
argument
types,
output,
types.
There
was
a
great
question
about
how
dynamic
linking
works
and
like,
in
our
case
it
works
like
that,
so
you
should
specify
types
you
like
they
can't
be
get
from
out
of
some
error,
so
you
need
to
specify
types
of
a
function
and
also
you
could
have
your
handler.
So,
let's
consider
an
example
for
how
mounted
binary
import
could
be
written
on
with
the
scheme.
A
So
here
we
could
see
like
a
function
that
returns
this
descriptor
and
the
most
important
part
here
is
the
closure
itself.
So
quarter
receives
arguments.
Yes,
that
is
just
a
vector
of
five
values,
called
the
functions
that
actually
do
some
logic
over
this
high
values
and
then
like
convert
result
back
to
ivalia.
A
So
that's
how
like
it
could
look
like
yes,
only
three
lines:
you
don't
need
to
care
about.
Memories
about
that
string
represent
by
point,
run
size
and
stuff
like
that,
so
you
have
handy
eye
values
and
you
could
work
with
them
and
also
you
should
specify
types
here,
but
I
think
it's
not
so
bad
developer
experience
and
it's
like
from
some
case
it's
unavoidable,
because
you
need
this
dynamic
function
linking
and
that's
how
the
entire
function
look
like.
A
So,
let's
move
on
to
the
marines
decaying
tools,
and
here
you
can
see
how
how
world
could
look
like
with
our
sdk.
So
we
want.
As
I
already
said,
we
want
developer
experience
close
to
when
you
were
asked
and
here's.
The
only
thing
that
you
need
to
do
is
just
to
use
our
procedure.
Macro
called
marine
and
like
applying
this
macro
to
a
function,
makes
it
exportable.
A
So
this
code
we
would
compile
with
our
marine
coi
tool
with
just
marine,
build
two
web
assembly
modules
that
exports
a
greeting
function
from
itself,
and
here
please
note
that
this
function
takes
strings.
It
not
takes
all
webassembly
types
takes
whenever
us
types
so
like.
Let's
imagine
like
let's
remember
again,
you
wrote
on
order
servers
that
we
consider
and
see
how.
So
this
example
was
about
previous
example,
was
about
exporting.
A
This
example
is
about
importing,
so
imagine
that
we
have
this
service
that
contains
of
three
modules,
and
we
want
to
like
combine
them
together
from
the
code
perspective
from
the
ras
side,
and
to
do
that
like
the
only
thing
that
you
need
to
do
is
just
to
use
rust,
foreign
function
interface
and
also,
if
you
wrap
like
this
external
function
with
the
marine
runtime,
you
would
have
almost
the
same
experience
that,
like
with
the
rust
ffi,
so
also,
please
note
that
here
you
could
use
whenever
rust
types.
A
Of
course,
there
are
some
constraints
you
can't
use
like
every
type
you
want.
I,
I
will
show
you
later
what
constraints
are,
and
here
you
could
see
like
how
this
module
could
be
built.
Yes,
there
are
three
webassembly
files
for
say,
coral
and
local
storage,
and
so
this.
This
is
why
just
a
little
little
example,
yes,
coral
web
webassembly
file,
just
download
file
with
help
of
coral
binary
and
the
local
storage
just
save
somewhere
in
the
file
system,
and
here
on
the
facade
module
you
use,
exported
function
from
this
two
modules.
A
A
The
only
implication
that
now
we
have
is
support
of
enams.
We
like
don't
support
them
now
because,
like
we
could
more
or
less
easily
add
them
to
marine
run
time,
but
it
would
be
so
hard
to
add
them
to
the
aqua
side.
A
So
that's
why
we
don't
like
do
it
now
but
like
if
someone
want
to
use
maureen
and
there
would
be
demand
for
them,
so
we
could
easily
easily
eat
them
at
them
and
also,
as
I
said,
marine
could
be
run
from
the
browser,
and
here
you
could
see
example
how
it
could
run
from
the
javascript
site.
So
imagine
a
service
that
has
some
not
so
trivial
signature.
A
So-
and
here
so
also-
I
haven't
said,
but
from
the
right
side,
you
could
also
use
json
objects,
so
we
could
also
co-function
not
with
just
vector
five
values
but
with
json
object.
That
would
be
also
over
it
and
like
the
result.
Pointers
would
be
passed
to
row
modules
as
it
did,
and
here
are
the
same
experience
it's
also
like
it
wouldn't
be.
I
know,
as
you
would
say,
series
just
by.
I
know,
sir
there
and
the
past
as
a
array
of
bytes
it
would
be.
A
There
would
be
like
a
honest,
like
typed
reversal,
some
comparison
and
wolverine
if
each
type
as
a
signature
says
how
signature
size-
and
the
last
topic
here
is
about
how
all
of
this
could
be
tested.
So
we
have
our
own
another
macro
called
marine
test,
and
it
provides
you
also
like
when
calls
to
a
new
rest
experience.
Hero
could
should
specify
for
like
pass
to
configuration,
file
and
pass
to
modules
directories,
whereas
the
binaries
allocated
and
you
could
just
use
inside
this
function,
you
could
use
interface.
A
That
would
be
like
completely
the
same
as
a
module
has
yes.
The
difference
here
is
usual
testing
that
that's
like
in
usual,
this
function
itself
compiles
the
webassembly
and
test
runs
from
from
the
web
assembly
itself.
Here
this
function
won't
become
part
of
our
assembly
here,
like
under
the
hood.
The
marine
on
time
would
be
instantiated
and
the
greeting
function
could
be
called
and
also
you
have
almost
the
same
experience
for
services.
You
could
test
several
services
as
it
is
like
on
the
slide
here.
A
Yes,
you
could
just
specify
them
in
marine
test
config
and
then
call
their
facade
modules
and
probably
it's
last
slide.
It's
a
last
tool
called
marine
repo.
This
is
tool
we
could
just
test
modules
from
the
repo
experience,
and
here
you
could
see.
Example
of
ipfs
like
ip
ipfs,
effector
and
ipfs
pure
module,
where
ap
face
effector
uses.
A
A
The
result
is
a
hash
that
published
to
ipfs,
and
then
we
could
call
iphosph
providing
this
hash,
and
you
could
see
this
beautiful
numbers
that
would
be
result
of
this
request
itself.
So
thank
you
very
much
here.
You
could
see,
like
all
links
to
the
marine
rasters
did
key
in
aqua
and
also,
if
you
take
care
about
marine,
please
take
a
look
to
marine
book.
There
is
like
complete
information
about
architecture,
about
sdk
how
we
could
develop.
C
So
first
question
is
why
external
binaries
like?
Why
can't
I
just
like
use,
wasn't
for
everything
like
amount
of
binaries
yeah
like?
Why
do
I
need
to
use
curl
or
anything
like
that.
A
Because,
like
you
know,
when
we
started
it,
it
was,
it
was
very
easy
to
just
call
them
like
in
a
prototype
from
your
webassembly
module
as
a
coi
binary.
A
Now
was
it
like
itself,
like
so
like
advanced,
that
it
could
be
called
from
with
help
of
yg,
not
with
help
of
like
this
cli
modules,
and
also
when,
like
circuits
was
made
in
wazi
at
the
beginning
of
this
year,
and
also
like
a
lot
of
programs
could
be,
could
be
called
with
a
unique
circuit,
with
a
local
unix
circuit,
with
help
of
yc
circuits
itself.
So
yeah,
it's
a
good
question
and
this
interface
could
be
considered
as
like
as
an
example.
A
As
a
like
the
most
simple
way
to
call
binaries
and
in
future
we
would
consider
moving
to
vasi
completely.
C
C
A
Yeah
so
yep
it's
a
good
question.
So
that's
why
we
have
like
model
several
model
types
as
effectors
and
pure
modules
and
effector
modules
should
be
reviewed
before
using
on
and
on
stuff.
C
Or
you
know,
I
agree,
I
know
my
point
is
like:
do
we
really
need
effectors
like
like?
We
can
build
a
world
where,
like
we
have
like
effectively
like
just
copy
and
write
semantics
and
immutable
files
and
stuff
like
that,
or
we
don't
actually
need
to
modify
this,
but
concern
is
like
once
you
start
having
a
lot
of
different
effects,
then
you
have
to
start
reasoning
about
the
interactions
between
different
effectors
and
that
can
get
difficult
from
a
security
perspective,
but.
D
There's
a
good
hack
around
this,
which
is
to
treat
those
systems
and
the
system
it
runs
in
as
an
actor.
So,
for
example,
you
can
model
the
binary
running
on
some
host
os
and
ideally
like
a
container
vm
or
whatever,
and
treat
that
as
an
actor
with
some
history,
and
so
maybe
the
history
changes
for
that
for
the
state
of
the
local
actor
or
whatever.
But
you
have
some
model
for
encapsulating
all
the
things
with
side
effects.
D
You
just
put
into
this
like
this,
like
really
dirty
environment
area,
where
you
don't
where
you
still
use
message
passing
into
the
pure
area,
and
so
you
can
like
compute
in
the
pure
area
as
much
as
you
want
and
ideally
fully.
But
then
you
can
still
interact
with
yes,
music
computer.
D
C
I
guess
what
I
was
looking
for
is
like
actually
just
like
taking
curl
and
running
it
inside
a
wasm
vm
and
then
giving
the
wasn't
vm
access
to
the
network
via
capabilities
and
stuff
like
that,
because
that
means
I
kind
of
like
I
don't
have
to
like
the
only
thing
like
if
I
need
to
write
state
okay,
I
need
some
kind
of
access
cables,
but
usually
I
don't
like.
Usually
I
just
like-
I
can
have
my
local
virtual
file
system,
for
example
in
ibfs,
and
then
I
produce
a
cid
or
spin
like
that.
C
So,
like
you,
just
you
very
rarely
actually
need
mutability
for
a
lot
of
the
stuff
or
effectors.
But
that's
almost
like
sorry
next
thing.
D
So
totally
I
completely
agree
in
in
the
case
of
curl.
You
just
want
to
run
that
curl
binary
within
wasm
and
so
on.
It
sounds
like
just
like
it
was
hasn't,
been
a
priority
for
them
to
like
shift
over.
However,
there
are
other
cases
where
it's
not
curl.
D
Because
right
now,
I
think
all
the
services
are
impure
right.
All
the
services
are
treated
as
like.
Who
knows
what
these
things
are
running
and
you
can't
really
reason
about
their
state.
Is
that
correct?
Or
yes?
Yes,
so
I
think
like
once
you
start
using
ipld
there.
Then
you
get
a
hash
linked
state
for
those
things,
and
ideally
those
can
become
this
kind
of
like
semi-pure
forever.
You
called
it.
D
A
Actually,
yes,
it's
it's
a
good!
It's
a
good
comment.
I
think
we
in
this
way,
we
could
consider
you
use
like
this
links
instead
of
just
pass
on
a
workout
system.
Yes,
it's
a
good
idea
to
use
a
pod.
E
Yeah,
so
sometimes
this
is
called
like
pure
state.
Sorry
impure
state,
yes
pure
state
or
pure
effects,
right
there's,
but
there's
that
distinction
right
of
this
is
something
that
I
can
rewind
and
that's:
okay
and
I'm
just
grabbing.
You
know
a
reference
versus
I'm
sending
an
email
and
I'm
updating
the
state
of
the
universe
right
so
and
you
kind
of
like
often
you
want
both,
but
you
need
to
be
really
careful
with
the
second
one.
C
Dexcom
wasn't
it
looks
like
it's
almost
the
ipod
data
model
and
we
should
be
able
to
just
create
codec
as
you're
saying,
but
is
it
self-describing
internally
as
like
I
can,
I
can
take
an
I
value,
object
and
say
what
it
is
like.
This
is
like
no.
A
No,
it's
it's
just.
I
will
so
it's
an
answer
to
the
question
you
want
to.
Like
have
information
from
like
which
services
I
will
vector
five
value:
okay,.
C
A
A
We
have
api
how
this
I
really
crossed
the
boundary
and
like
in
the
future.
When
we
are
now,
we
are
moving
to
that's
exactly
why
you
need
to
press
that.
Yes,.
B
D
C
A
A
A
C
A
It's
this
safety
checks
by
interface,
type
instructions.
D
A
C
Okay
never
mind:
we
can
talk
later.
C
So,
okay,
so
that
means
basically,
this
does
not
work
as
ipld.
It
would
require
more.
A
So
there
is
a
like
it's
a
written
binary,
so
that
contains
only
one
export
functions
and
there
is
a
how
it
looks
like
from
the
low
level
stuff.
There
is
a
adapter
function
for
this
row
type
function
and
contains
of
interface
type
instruction
that
actually,
like
the
do.
All
the
like.
All
the
logic
of
type
extraction.
A
A
B
Okay
and
then
so
how
much
binding
can
you
generate?
Well,
you
have
the
function,
the
output
types
right,
so
you
can
generate
that.
But
can
you
generate
like
the
actual
function
calls
like
from
javascript
into
the
web
assembly
like
what
what's
been
does
currently.
A
Yes,
it's
it's
it's
similar
to.
What's
in
my
engine,
yes
and
like,
if
you
are
talking
about
so
the
first
thing
that
I
need
to
say
is
that
binaries
run
both
on
a
javascript
site
on
rough
side
that
they
are
essentially
the
same.
So
the
glue
codes
are
generated
by
the
our
procedure,
macros.
A
They
are
the
same
both
for
javascript
and
rust
and
like
it's
a
bit
similar
to
what
was
my
engine
does
is,
but
it
does
it
only
for
the
outskirt
side-
and
there
are
like
there
is
a
bunch
of
ebi
functions
that
could
every
module
export
to
the
remodel
export
like
allocate
the
allocate
and
stuff
like
that,
so
they're
similar
to
what
should
we
do
in
the
interface
type
site
and
like
actually
a
core
module
that
that
core
on
this
swipe?
A
It
actually
call
it
actually
interprets
interface
types
instructions
and
then
some
sort
of
like
web
assembly
memory
type
should
be
done.
It
calls
import
function
from
marine.js
and
marine.js
acts
here
as
a
some
sort
of
manager
and
itself.
It
also
comes
to
a
specific
module
and
extract
memory
from
it.
You
might
answer
the
question
yeah.
B
A
So
actually
maureen
doesn't
support
shared
every
single
linking
scheme
at
all.
Okay.