►
From YouTube: Using IPFS/IPLD from WASM - @matheus23 - IPFS and WASM
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
A
Welcome
everyone
today,
I'm
giving
you
a
wasm
experience
report.
It's
not
quite
what
what's
in
the
track
as
a
title,
but
still,
I
think,
like
it,
turned
out
to
be
something
a
bit
of
a
different
kind
of
talk.
So
I
hope
you
forgive
me
for
that,
but
in
principle
we're
still
I'm
still
talking
about
like
using
ipld,
essentially
from
wasn't.
A
First
of
all,
hey
everyone,
I'm
philip,
I'm
a
theater
iii
on
github.
I
work
as
a
protocol
engineer
at
vision
and
I
work
on
ucan
there
and
I
work
on
winifs,
specifically
rs
winfs,
and
I
want
to
specifically
shout
out
app
cipher
here
who's.
One
of
my
colleagues
who've
been
I've
been
building
this
with
push
prop's
name
yeah
and
we
went
wasn't
with
our
rs
winifs.
A
So
why
did
we
do
that?
The
answer
is
we
are
hoping
for
efficiency
and
portability
and
why
portability?
Because
well,
if
you
have
content
addressing,
then
you
get
portable
data,
which
is
really
nice.
But
that
means
you
want
to
have
portable
compute,
because
now
your
data
lives
somewhere
else
and
that
might
be
a
phone.
It
might
be
a
laptop.
It
might
be
a
data
center
or
whatever
you
want
to
do
something
with
this
data
in
most
cases,
and
it
depends
on
the
environment,
et
cetera,
et
cetera.
So
you
want
to
have
something.
A
That's
super
portable
and
another
thing
actually
is
encryption
forces
you
kind
of
to
push
your
computations
to
the
edge
and
do
your
computations
there,
so
that
means
browser
environments,
mobile
phones,
et
cetera,
et
cetera,
unless
of
course,
full
homomorphic
encryption,
but
yeah
we're
not
quite
there.
Yet
I
think
so
yeah
that
meant
when
we
built
winfs,
which
is
like
a
file
system,
abstraction
similar
to
unix
fs.
A
That
is
meant
to
like
power
user
build
apps
and,
like
personal
data
store,
we
got
requests
like
people
wanted
to
run
it
in
browsers,
of
course,
which
is
where
we
started,
but
then
also
command
line
interfaces
or
in
the
server
in
their
servers
or
workers.
A
That
just
naturally
happened
and
our
strategy
before
was
well.
We
will
write
it
in
typescript,
it'll,
run
a
node
and
we
can
put
it
into
workers
or
command
interfaces
by
providing
that
environment
like
with
node
or
dino
whatever
it
is.
A
But
that
was
like
slightly
painful
and
we
wanted
to
try
it
wasn't
and
like
that's
how
it
went.
That's
that's
like
our
talk
now
yeah,
so
we
built
iris
winifest
and
I
should
really
say
that
ferris
having
a
construction
hat
is
like
very
on
topic.
It
is
very
much
a
work
in
progress.
A
When
I
say
wasm,
there's
a
bunch
of
things
that
are
very
different
than
like
other
vms,
like
node
or
whatever,
specifically
wasm
is
not
a
vm
or
it's
very
restricted,
there's
no
side
effects
by
default,
which
means
you
have
no
networking.
You
have
no
disk,
no
indexeddb
or
something
like
that.
But
that
also-
and
I
think
aden
previously
mentioned-
that
it
kind
of
forces
you
to
think
about
your
assumptions,
which
is
kind
of
nice,
and
that's
also
like
something
that
forces
you
to
make
interfaces.
A
Maybe
good
interfaces
use
interfaces
which
was
not
that
much
the
case
with
our
javascript
and
typescript
code,
so
that
was
nice.
It
also
has
no
built-in
gc,
which
is
limiting
yeah.
So
that's
something
to
keep
in
mind
and
also
like
every
time
you
have
two
different
kind
of
environments,
the
host
environment
and,
like
it
wasn't
kind
of
thing,
you
need
to
think
about
like
how
data
structures
in
like
your
wasn't
thing
are
going
to
live.
But
that's
something
I'll
talk
about.
A
Briefly,
later,
all
right,
so
interesting
thing
number
one
we
reached
for
a
simple
block,
store
abstraction
as
like
a
way
of
solving
a
bunch
of
those
problems.
I
I
mentioned
on
the
previous
slide.
So
basically,
that's
what
it
looks
like
this
is
like
from
just
taken
from
our
ross
code.
We
have
a
put
block
and
a
get
block.
There's
some
bytes
you
put
into
your
blog.
So
that's
what
you
expect
from
your
host
environment,
you
provided
with
the
ipld
codec
and
you
get
back
a
promise
of
a
sid.
A
It's
not
captured
in
a
type
here,
but
that's
just
because
it's
interacting
with
js
in
that
case
same
thing
with
the
gap
lock,
there
are
maybe
ways
to
do
it
more
efficiently.
I'm
interested
to
hear
your
thoughts
so
far,
we're
not
focusing
on
that
that
much
but
yeah
it's
it
solves
a
bunch
of
things.
It's
all
for
us,
the
storage
abstraction.
May
it
be
disk.
A
May
it
be
in
xdb
that's
up
to
the
host,
but
it's
like
you
will
need
a
block
store,
whether
you're
running
it
in
the
browser
or
whether
you're
running
it
in
a
server
or
some
other
kind
of
environment.
So
I
think
that's
like
a
good
abstraction
to
build
around
a
block
store
is
not
the
best
abstraction
for
everything
you
mainly
want
to
have
it
in
like
low
latency
environments.
A
So
you
don't
want
to
have
this
interface
when
it
takes
you
a
long
time
to
like
go
back
and
forth.
So
in
our
use
cases,
this
has
worked
out
fine,
so
far,
so
yeah
also
another
interesting
side
effect
of
that
is.
You
can
kind
of
build
like
different
things
that
all
connect
to
a
box
store
like
your
networking
thing
that
syncs
your
dax
with
other
machines
or
whatever
you
can
all
these
can
all
like
be
different
things
that
all
connect
to
this
block
store
and
they
don't
have
to
know
about
each
other.
A
A
So
the
like
all
of
the
hard
computation
is
mostly
like
building
together
the
right,
dag
and
that
is
like
abstracted
away
and
all
of
the
decisions
around
like.
How
do
you
want
to
do
highly
efficient,
like
adding
stuff
into
your
directories
or
whatever
can
be
a
concern
of
a
layer
above
or
how
to
do
transactions
etc?
How
to
do
like
super
fast,
high
concurrency?
A
So,
like
we've
really
built
a
core
around
this
thing,
we're
hoping
to
like
abstract
away
a
bunch
of
these
problems
and
put
them
into
like
the
yeah.
It
should
be
a
problem
to
host
essentially,
and
so
the
abstraction
looks
like
this.
For
example,
this
is
the
just
creating
a
directory
somewhere
at
a
path
in
an
existing
directory,
and
you
can
see
that
it
returns
the
end
just
another
directory.
A
So
yeah,
that's
that's
the
immutability
you
it's
like.
If
you're
squint
hard
enough,
it
is
almost
like
you're
taking
a
sid
and
producing
a
new
sid
and
like
there's
just
a
public
directory
can
like
be
turned
into
a
sid,
there's
just
a
small
layer
of
caching.
On
top
of
that-
and
that
is
what
I'm
that
is
my
next
point,
you
don't
have
to
deserialize
stuff
twice.
We
think
that's
like
some
way
of
optimizing
stuff.
You
can
also
lazily
load
things
with
a
like
with
this
abstraction.
A
So
we
have
this
link
here,
which
essentially
is
like
here
is
a
link
that
can
be
either
sid
or
some
actual
decoded
data,
and
that's
what
we're
basing
our
abstractions
around
now.
This
has
come
up
in
a
similar
form
in
other
libraries.
This
is
like
the
immutable
version
of
it
and
yeah.
You
can
see
that
either
you
have
you've
created.
A
You've
read
something
from
the
network
and
then
it's
at
first
they
sid,
and
then
you
have
a
cache
next
to
it,
if
you've
already
decoded
it,
which
is
this
one
cell
for
the
value
cache
here
or
you've,
just
built
something
yourself
within
the
wasn't
runtime
and
you
might
not
have
serialized
it
yet,
and
so
you
add
a
cache
for
the
sid
next
to
it
and
once
you've
serialized
it,
you
don't
have
to
serialize
it
twice.
You
can
just
refer
to
the
sid
and
you
can
see
like
our
public
directory,
then
kind
of
lazily
loads.
A
The
tree
that's
below
it
by
just
linking
to
links
instead
of
the
struct
itself
or
acid,
and
the
last
interesting
thing
is.
We
noticed
that
memory
management
can
be
tricky.
So
when
you
have
your
wasm
node
or
your
wasm
thing,
you
may
give
pointers
into
your
memory
to
your
host,
which
can
be
difficult
and
so
like.
A
If
you
look
at
the
generated,
typescript
types,
you'll
see
that
wasn't
bind
gen
was
nice
enough
to
generate
us
a
free
function,
which
also
means
we're
kind
of
responsible
for
freeing
our
wasn't
memory,
and
if
we
don't
do
that,
we
have
memory
leaks
that
can
be
difficult.
You
have
to
keep
that
in
mind.
A
What
you
can
do
is
roughly
1991
of
browser
usage
out.
There
today
supports
hooking
into
the
node
gc
or
like
the
v8
gc,
and
that
helps
you
freeing
up
that
stuff.
But
it's
something
to
think
about.
You
need
to
enable
it
and
yeah.
I
think
there
are
some
pr's,
it
wasn't
bind
gen
or
it
wasn't
pack.
I
think
that
we
need
to
get
merged
at
some
point
yeah.
That
is
basically
it
it's
not
much.
A
A
Side
of
things
so
yeah
his
question
was:
can
I
talk
more
about
the
wasn't?
Was
he
kind
of
side
of
things
I'm
not
100
sure
what
the
wazi,
what
it
all
encompasses?
As
far
as
I
know,
it
also
encompasses
like
trying
to
abstract
over
syscalls
like
common
syscalls
like
networking
doing
yeah
disk
writes
whatever,
and
I
think
this
kind
of.
A
I
don't
want
to
do
that
at
least
not
in
rswinifs,
as
long
as
I
can
just
do
it
all,
with
a
block
store
abstraction
which
does
most
of
the
abstraction
for
me.
If
we
have
some
code
around,
let's
say
networking
that
is
very
yeah.
It's
complex
code
around
networking
that
I
can't
solve
with
just
function.
Imports
in
wasn't
like
without
finding
a
simple
kind
of
small
abstraction
that
can
easily
implement
it
in
hosts.
A
C
The
signature
returns
a
promise
which
is
sort
of
a
very
common
return
type
for
a
browser
api,
but
I
assume
you
probably
want
to
use
this
interface
in
more
than
just
browsers.
Is
that
correct.
A
Yeah
there's
actually
like
two
interfaces.
This
is
the
js
facing
interface
and
we
do
have
an
internal
rust
interface
and,
like
I
think
this
has
come
up
before
in
in
this
track.
We're
not
entirely
sure
what
our
strategy
for
other
things
besides
the
browser
is
going
to
be.
Maybe
it
is
easier
for
us
to
just
build
commander
interfaces
in
rust
or
build
servers
on
rust.
Maybe
it
is
easier
for
us
to
provide
microservices
in
rust
and
use
them
from
other
microservices
on
the
server.
A
B
A
I
think
there's
there's,
I
know
that's
well
there's
some
strategies
that
go.
Not
the
wasm
route,
which
is
just
like
there
is,
for
example,
so
wasn't
bind.
Gen
is
doing
a
lot
of
the
heavy
lifting
here.
I
don't
have
to
care
about
the
serialization
format
between
javascript
and
our
wasn't
or
our
rus
in
the
wasm,
and
if
I
didn't
have
wasn't
bind
gen,
this
would
be
really
hard.
I
would
have
to
yeah
you've
mentioned
in
your
talk.
You
just
push
integers
back
and
forth,
and
you
have
pointers
into
your
wasn't
memory.
A
That's
not
very
helpful,
so
wasn't
binding
is
doing
a
lot
for
us
here.
There's
also
c
bind
gen,
which
is
essentially
making
c
libraries
out
of
rust.
Maybe
that
is
the
way
to
go
and
there's
like
lots
of
yeah
lots
of
programming
languages
bind
or
provide
bindings
against
c.
So
maybe
that
is
the
way
to
go.
That
is
something
I've
been
thinking
about
still
concerned
about
yeah.