►
From YouTube: WASM + IPLD - @stebalien - 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
Okay,
this
next
one
is
my
my
baby.
This
has
been
my
thing
for
years.
I've
been
documented
for
years
and
it
looks
like
we're
actually
we're
getting
there
and
it's
really
exciting.
So
so
this
is
talking
about
ibuildingwasm.
The
the
previous
talk
was
all
about
like
okay,
how
we're
using
ibuyzham
in
the
fvm.
This
is
talking
more
about
like
okay.
How
do
we
build
decentralized
systems
in
central
protocols
with
ipl,
name,
wasm,
and
and
why
so?
A
The
frustration
I
have
here
or
I've
always
had
with
with
really
everything
we
do
here
is
like
okay,
I
build
a
protocol
and
I'm
not
happy
with
it.
So
I'm
gonna
build
another
one.
It's
the
four!
It's
a
the
14
standards
problem
or
the
15
standards
problem.
A
Where,
like
like
someone,
someone
built
something
and
like
it's
not
going
to
work
because
you
need
to
build
another
one,
so
wonderful,
the
wonderful
thing
would
be
if
your
standards
stop
making
standards
that
doesn't
work
like
like
we've
seen
it,
it's
not
going
to
happen.
People
are
not
going
to
stop
making
standards
because
they
can
they
need
you
thanks.
We
can't
just
say
no
more
standards.
A
Instead,
we
need
improper
or
interoperable
standards.
We
need
standards.
We're
like
I
can
make
a
new
standard,
they
can
still
work
with
your
standard
and
they
can
actually
like
they
can
work
together
in
some
way.
This
is
obviously
rather
hard
because
it
means
you
need
some
kind
of
interoperable
standard
standard,
and
that
is
both
hard
to
define
and
then
maybe
other
people
will
want
to
define
other
interoperable
standard
standards.
A
So
you
need
to
define
the
like
the
most
basic,
primitive
standard
standard
standard
for
interoperability,
which
gets
hard
so,
but
really
what
you
need
is
decentralizing
tropical
standards,
so
the
problem
with
even
like
interoperable
standards,
you
still
need
to
get
people
to
agree
on
how
your
things
interoperate.
What
I
really
want
here
is
the
ability
to
like
say:
okay,
I
see
your
systems,
I
want
to
make
a
new
system,
the
interoperability
of
all
your
systems,
and
you
don't
have
to
do
anything.
A
You
don't
even
have
any
say
in
what
I'm
doing
here.
I
can
just
make
my
system
inappropriate
with
yours.
That's
the
like
the
golden
stand
here.
That's
what
I
want
so
like
this
is.
This
is
not
like
two
parties
agree
like
make
their
own
systems
and
agree
hey.
We
want
assistance
to
work
together
to
find
a
way
to
bridge
them.
This
is,
I
see
your
system.
I
built
the
system.
A
A
They
could
both
send
and
receive
matrix,
tries
this,
but
it's
like
very
much
and
like
they
have
to
like,
like
make
a
bridge
for
every
single
network,
but
but
that's
the
kind
of
thing
I'm
looking
for
here
so,
but
to
sort
of
like
walk
back
a
bit
right
now,
we're
very
much
in
the
world
of
data
where
every
standards
are
built
around
data
and
we
have
particles,
but
protocols
are
just
data
data
on
the
wire.
A
The
problem
is,
we
must
have
formats
semantics
like
how
do
we
actually
like
send
this
data
around?
What
does
the
data
mean?
When
do
I
send
a
message
on
a
protocol,
all
this
kind
of
stuff?
This
just
means
like
we
have
to
agree
on,
like
teeny,
tiny
little
details
that
we
shouldn't
have
to
touch
the
next
step.
A
Up
from
this
really
is
data
plus
code,
which
is
why
this
this
talk
is
titled,
ipld
plus
blossom
because,
like
what
I
want
to
be
able
to
do
is
have
data
or
ipld
and
attach
some
code,
ideally
in
or
form
it
in
ipld
or
sorry
in
ipld,
and
then,
instead
of
having
you
just
like
try
to
understand
my
data,
you
just
take
my
code
and
you
call
method
in
the
code
and
that
just
works.
A
Now,
I'm
going
to
get
some
specifics
here
on
on
how
to
make
this
work
or
like
why?
Why
I'm
I'm
talking
about
this,
but
that's
the
general
idea.
So,
let's
talk
about
like
current
protocols
and
how
they
currently
work.
Currently,
we
we
have
to
agree
on
what
the
protocol
needs
to
do.
We
need
to
then
like
agree
on
the
the
methods
and
messages
that
need
to
be
supported.
So
it's
a
graph
sync
where
I
need
to
retrieve
blocks.
A
Okay,
I
need
to
support
requesting
data
responding
all
this
kind
of
stuff.
I
need
to
agree
on
how
I
specify
the
data
I
want.
So
when
I
feel
in
graph
sync,
we
have
these
things
called
selectors
that
specify
what
I
want
and
there's
this
entire
language
and
build
this
entire
selector
engine.
To
run
this
thing,
we
have
to
agree
on
on
the
the
selector
execution
order,
how
they're
validated
all
the
teen
tiny
little
details
of
this
protocol
and
everyone
has
to
do
the
same
way.
A
A
A
It
has
a
get
method,
it
returns
a
block
and
whether
or
not
it
has
the
block,
and
then
I
define
a
stream
interface
where
I
can
just
write.
Bytes
read
bytes
close
the
connection
and
that's
basically
the
protocol
where
now,
basically,
I
just
send
you
a
program,
you
pass
an
object
to
this
program.
The
influences
interface.
Really
you
implement
host
functions
in
wasm
that
influences
interface.
Now
I
can
just
start
reading
blocks
out
of
your
block
store
and
I
can
start
writing
bytes
back
to
a
stream
that
goes
back
to
me.
Now.
A
We
have
to
agree
on
how
to
activate
the
stream,
but
that's
a
very
low
level
like
detail
of
like
okay.
We
need
at
least
some
kind
of
stream
protocol
here,
but
we
don't
have
to
agree
on
the
actual,
like,
like
the
protocol
that
runs
on
top
of
the
stream
at
all.
You
just
send
me
back
bytes
that
I've
specified
in
my
program
and
then
I
know
how
to
interpret
it
because
I
wrote
the
program,
but
this
means
like
if
I
want
to
change
the
selector's
work,
I
need
to
support
format.
A
I
I
want
to
send
back
like
I
don't
want
the
entire
tag.
I
just
want
some
cryptographic
proof
that
you
did
the
right
thing.
I
could
do
all
this
stuff.
It's
also
a
lot
easier
to
secure
because,
like
with
selectors
and
graphs
and
stuff,
like
that,
it's
very
difficult
to
figure
out.
Okay.
How
long
will
this
run
time
take
like
what
is
the
complexity
of
this
thing,
like
how
much
memory
will
use
something
like
that?
A
We
have
a
lot
of
like
a
ton
of
complicated
logic,
trying
to
make
this
work
properly
and
trying
to
make
it
somewhat
secure,
so
that
someone
can't
just
dos
your
node
with
with
wasm.
It's
actually
like
you.
Basically
just
you
spin
up
your
awesome
vm.
You
set
your
limits.
A
You
set
your
timeouts
and
you
just
let
it
run,
then
you
stop
it
if
it
isn't
complete,
which
means
you
have
this
nice
little
sandbox,
where
you
can
enforce
your
your
your
rules,
where,
in
traditional
protocols
like
you,
don't
generally
have
that
nice
little
sandbox
where
you
can
parse
your
rules,
so
you
can
force
them
all
over
the
place
and
gets
really
complicated
and
then
on
upgrade.
A
I
just
make
a
new
version
of
my
query
and
I
send
it
to
you
now,
of
course,
the
problem
here
is,
if
I
have
to
send
you
a
megabyte
request,
each
time,
that's
big,
but
this
is
where
I
feel
it
comes
in,
because
if
I
can
take
my
code
and
shove
it
in
ipld
and
chunk
it
in
in
the
right
way,
so
at
least
it
tries
to
reuse
some
of
the
code
because
quite
often
we
could
buy
all
exactly
in
wasm
it'll
actually
compress
well,
because
it
reuses
a
fair
amount
of
stuff,
then
like
I
can
actually
create
an
epithelial
dag
where,
like
okay,
if
you
don't
have
like,
I
tell
you
about
the
code.
A
I
tell
you
the
cid.
If
you
don't
have
it,
then
you
fetch
it
from
me
over
graph,
sync
or
bit
swap
or
whatever,
or
maybe
I
push
it
to
you,
but
then,
once
you
have
it,
you
don't
need
to
fetch
it
again.
You
can
just
run
it
because
you
already
have
it
because
and
you
you
can
know
that
you
have
it
because,
like
it's
ability,
it's
all
content
addressed.
That's
really
what
content
addressing
gives
you
and
also
what
the
duplication
gives
you
where
like?
A
If
you
have
a
protocol,
almost
does
what
I
need.
I
can
take
that
in
many
cases
reuse
many
of
the
components
and
then
just
send
you
the
new
pieces
that
I
have
that
I
need
like
this
is
not
easy.
This
means,
like
basically
content-based
chunking
of
code,
which
we
have
not
actually
solved,
but
that's
kind
of
the
next
step
in
making
this
just
like
just
work.
A
Another
example
like
to
give
is
file
types
so
before
in
the
current
world,
we
have
to
agree
on
the
behaviors,
so
read:
write,
link,
stat,
all
this
kind
of
stuff
or
for
documents.
I
need
to
understand.
I
need
to
agree
on
the
fact
that
we
have
to
right.
We
need
to
be
able
to
render
these
documents
somewhere
or
for
in
virtual
worlds.
A
We
need
to
agree
on
on
the
fact
that,
like
okay,
we
need
to
be
able
to
render
these
objects
in
3d
and
interact
with
them
and
stuff
like
that,
then
we
actually
agree
on
the
details
like
how
do
we
encode
it?
What
are
the
semantics
like?
A
What
like,
oh,
like
all
the
stuff
here,
we're
like
like
html,
is
massive
spec
pdf
is,
I
don't
want
to
talk
about
it
and
like
it's
not
great,
and
then
we
have
to
agree
on
how
they're
supposed
to
be
displayed
and
all
this
kind
of
stuff,
and
no
one
will
actually
agree
on
this,
like
all
knowing,
but
it
should
work
the
same,
so
everyone
will
get
different
outcomes
and
then
again
on
upgrade.
A
We
have
to
get
everyone
to
move
forward
and
I
can't
use
a
feature
until
I
convince
you
to
upgrade
your
code.
I
can't
like
include
some
new
thing
in
my
document
or
some
new
piece
of
my
website
before
I
convinced
chrome,
firefox,
whatever
to
upgrade,
and
unfortunately
that
means
that
everyone,
just
uses,
chrome
and
basically
browsers-
tend
to
standardize
around
one
implementation,
because
that
means
that,
like
you
just
target
this
one
thing,
everyone
uses
one
thing
and
you
can
move
really
really
fast
and
it's
not
decentralized.
A
It
is
very
centralized
after
we
can
agree
on
what
it
needs
to
support
and
that's
it.
Basically,
we
disagree.
Okay,
read:
write,
link
stat,
whatever
these
are
the
set
of
interfaces
as
long
as
it
supports
this
great,
it's
not
easy
like
we
still
have
to
figure
out
how
to
paint
the
shed.
We
have
to
figure
out
the
interface
we
need
to
support,
but
once
we've
done
that,
then
we
can
tweak
the
file
formats.
We
can
tweak
the
data
structures.
We
can
optimize
for
a
specific
use
case.
A
Do
anything
we
need
to
do
and
upgrade.
If
I
want
to
switch
to
new
file
system.
I
can
just
do
that
and
then,
basically,
whenever
I
I,
I
create
a
like
a
new
object.
Now
I
can
send
you
a
link
to
both
the
code
and
the
object.
This
is
actually
getting
into
something
else
that
I
didn't
talk
about
before,
where
like
in
ipld
we've
talked
this
many
times.
A
We
would
really
like
this
concept
of
fat
pointers,
but
like
right
now
I
can
send
you
a
c,
a
pointer
to
a
piece
of
code
or
sorry
to
an
object,
a
piece
of
data
in
the
future.
We
like,
I
would
very
much
like
the
ability
to
send
you
a
fat
pointer.
It
has
a
pointer
some
code
for
understanding
some
some
data
and
then
the
data
itself.
A
A
So
this
is
where
I
really
like
to
go
problem
here,
obviously,
is
that
the
c8s
could
get
very
large,
so
an
alternative
proposal
is
to
put
the
code
cid
inside
the
data
or
to
create,
like
sort
of
like
a
a
sort
of
an
object
that
points
to
the
code
in
the
data
and
you
point
to
that
with
a
separate
cid.
This
on
one
hand,
this
does
make
the
cds
much
smaller.
A
On
the
other
hand,
it
means
I
need
to
download
this
extra
object,
so
some
trade-offs
here,
but
that's
not
too
important,
but
this
is
not
enough.
So
the
problem
here
is,
we
have
to
agree
on
the
interfaces
and
agreeing
on
interfaces
is
really
really
hard
so
like
at
least
we
don't
have
to
agree
on
on
the
exact
implementation
details,
but
we
still
need
to
agree
that
what
is
that
like?
What
is
a
file?
How
do
I
want
to
do
this?
A
We
may
be
able
to
get
away
with
not
agreeing
on
naming
by
using
numbers
and
saying
names
or
implementation
specific,
but
we
at
least
need
to
agree
on
like
like
what
types
of
arguments
you
want.
What
are
the
semantics,
all
that
kind
of
stuff?
A
So
really
we
need
data
plus
code
plus
interfaces
and
lenses,
so
lenses
is
a
concept
of
like.
Basically,
when
you
have
some
data
in
some
format,
I
can
then
view
it
as
something
else.
This
can
also
apply
to
code.
There
may
be
more
specific
term,
but
I
just
call
it
lenses
where
like.
If
you
have
an
interface
in
one
or
one
interface,
I
can
then
create
another
interface
and
then
create
a
sort
of
interface
transform.
That
makes
your
interface
look
like
my
interface.
A
So
once
we
can
start
doing
things
like
this,
then
we
can
even
stop
by
bringing
up
interfaces.
So
example,
here
is
winfs
and
unixfs,
and
I'm
sorry
that
should
be
should
have
been
wnfs,
not
wi.
Nfs,
that's
probably
going
to
confuse
a
lot
of
people
because
it's
not
windows,
but
I
basically
quickly
yeah,
but
the
idea
is
like,
for
example,
let's
say
I
have
unix
fs
and
you
have
a
or
sorry
I
I
want
unix
of
s.
A
I
expect
unix
best,
but
I
have
a
winfs
file
like
someone's,
giving
me
a
winfs
file.
How
do
I
understand
this?
There
are
a
couple
ways
we
can
do
this.
One
winifs,
like
the
the
the
author
of
the
witness
witfs
system
or
of
this
file,
could
have
specified
in
the
the
data
type
here
or
in
the
code.
Winfs
implements
unix
fs
vsm
wasn't
code,
so
that's
sort
of
a
lens
going
from
winfs
to
unix
of
s
specified
by
the
winfs
type
or
the
winfs
code.
A
It
can
also
go
the
other
way
around
where
like,
if
I'm
expecting
unix
fs,
my
unix
of
s
type
locally
can
specify
that
anything
that
implements
winfs
implements
unix
fs
via
this
lens.
So
then
like.
If
I
get
some
winifest
object,
I
can
then
view
it
as
unix
fs,
because,
like
my
local
implementation
says
that
you
can
also
do
this
with
a
third
party
where,
like
let's
say,
I
don't
care
about
either
like
actually.
This
is
the
third
case
where
I
want
foo
fs
some
other
file
system.
A
I
can
then
create
my
new
interface
because
I
like
manifest,
I
don't
like
yours.
I
want
to
put
my
shed
purple.
I
guess
this
is
red,
so
I
want
to
paint
my
shed
red.
I
have
a
purple
shed
and
I
have
a
teal
shed.
What
I
do
here
with
so
for
my
red,
I
say
well,
my
redshed
is
implemented
by
the
purple
shed
winfs
via
some
awesome
code
and
it's
implemented
by
unix
of
s
via
this
other
awesome
code.
So
now
like.
A
If
you
give
me
any
of
these
types
of
objects,
I
can
just
understand
in
my
program
via
these
lenses.
So
now
you
can
create
this
like
what
I
like
to
call.
Oh
sorry,
the
previous
system
was
linear
development,
where
everyone
has
to
like
sort
of
like
agree
on
the
interfaces.
A
I
call
this
decentralized
development
where,
like
you,
can
make
your
spec
and
your
interfaces
and
to
figure
out
how
you
want
to
make
things
work,
someone
else
can
independently
make
a
different
file
system
that
has
a
different
interface
and
then
I
can
come
together
and
say,
wait
a
minute.
Those
are
basically
the
same
thing.
Let
me
implement
a
or
a
new
interface
and
then
specify
in
my
interface
how
your
interfaces
implement
my
interface
or
really.
How
are
your
types,
my
type
now
in
my
system?
A
I
can
just
use
my
type
if
someone
else
wants
to
use
both
of
yours.
Why
bother
like
they
could
just
use
mine
and
they
will
automatically
get
access
to
all
of
your
data,
and
then
you
can
sort
of
keep
doing
this,
so
you
can
keep
basically
forking
and
joining
working
and
joining
where,
like
multiple
parties
can
take
mine.
A
If
I
say
I
want
to
extend
it,
I
want
to
add
a
new
function
and
they
can
do
that
and
say
that,
basically,
my
my
system
is
or
implements
their
system
via
some
lens
and
is
implemented
by
their
system
vsln.
So
they
can
go
both
ways
basically
and
add
some
additional
function
or
whatever
functionality
they
want.
Someone
else
can
do
the
same
thing
over
here
and
then
a
final
party
can
come
in
and
basically
link
those
two
new
those
two
systems
together
and
say:
well,
they're.
A
Actually,
basically,
the
same
is
how
they're,
basically
the
same.
So
my
dream
here
really
is
to
not
have
to
like
get
everyone
to
agree
on
this
stuff.
Instead,
just
be
able
to
say,
look
just
add
the
feature
you
want
attach
it
to
your
data.
Not
someone
else's
database
see
your
data,
use
it
in
your
program
and
then,
if
people
like
it,
they'll
adopt
it.
A
If
they
don't
like
it,
they
won't
adopt
it,
but
no
one
actually
has
to
like
agree
up
front
anything
that
makes
this
work
is
content
dress
code
because
I
can
ship
it
around
and
I
don't
have
to
worry
about
where
it
really
lives.
I
I
can
deal
with
duplication
stuff
like
that
and
the
fact
that
it's
all
running
in
webassembly,
it's
all
sandboxed,
so
I
can
run
untrusted
code
and
the
fact
that
also
the
data
is
content
addressed.
A
That
is
the
general
idea
here.
I
I
really
really
hope
to
see
more
systems
that
tried
with
this
kind
of
stuff.
I'm
really
excited
because
I
mean
this
past
week
I've
been
seeing
a
lot
of
systems
that
are
getting
closer
and
closer
and
closer,
but
but
yeah
it's
it's.
It's
not
a
it's,
not
an
easy
problem.
The
last
time
I
sat
down
to
try
to
solve
this
problem.
A
I
got
lost
in
lambda
calculus
land
because
you
have
to
actually
decide
like
what
is
the
base
type,
because
this
is
all
very
abstract.
Like
okay,
I
have
these
interfaces
and
whether,
but
what
is
an
interface,
what
is
the
base
type
like?
I
can't
be
like
well,
really
a
function
is
and
that
that
can
be
difficult
so
like
the
hardest
part
here
is
like
agreeing
on
as
I'm
saying
before,
like
what
is
the
standard
standard
standard
like
the
ultimate
standard
we've
actually
like
somewhat
aside,
we
have
agreed
on
that.
A
A
I
ideally,
but
not
necessarily
so
like
if
you
do
this
right.
Well,
yes,
like
you
still
need
to
agree
on
on
some
code
thing,
but
like
so
sort
of
basically
like
someone
could
make
a
new
system
like
this,
it
would
not
be
backwards
compatible,
but
it
would
be
sorry
if
the
accuracy
not
four
is
compatible
so
like
you
could
make
a
new
system
that
would
be
able
to
understand
the
old
system,
because,
basically
any
system
should
be
more
general
than
the
old
system
if
it
sports
code.
But
you
would
not.
B
Yeah,
have
you
looked
at,
like
I
think,
there's
I
bet
you
look
at
a
bunch
of
things
like
this
idea
of
moving
around
code
to
the
data.
Instead
of
moving
the
data
around
yeah,
it's
existed
in
like
a
lot
of
areas.
I
mean
java.
A
Yes,
that's
yeah,
so
moving
the
code
to
the
data
is
is
useful.
It's
not
quite
what
I'm
trying
to
get
at
here,
though
so
like
I'm
trying.
This
is
more
like
little
bits
of
code
with
lots
of
data
and
well
explain
this
there's
more
about
trying
to
understand
data
with
code.
Unless
about
trying
to
do
computations.
A
If
you
do
computations,
yes,
then
yeah,
you
need
to
move
the
code
to
the
data,
but
this
is
not
quite
that
this
is
more
about
trying
to
get
basically
trying
to
get
rid
of
file
types,
because
I'm
tired
of
having
to
like
have
a
billion
different
programs
and,
like
I
want
some
new
feature
and
you
don't
have
it
but
yeah.
B
Also
another
thing
I
feel,
like
those
interfaces
map
very
nicely
to
applications
because,
like
applications
care
about
the
interface.
A
A
Yes,
yes,
my
other
motivation
here
really
is
actually
vr
and-
and
I
don't
know
what
we're
calling
them
now-
we're
not
calling
them
the
m
word,
but
those
kinds
of
worlds
yeah.
We're
like
like
that's
why
I
mentioned
like
renderable
and
also
like,
like
the
3d
object,
where,
like
you,
can
actually
now
with
something
like
this.
I
can
make
some
type
that
implements
several
different
interfaces
where
it
says
like.
A
I
am
on
object
via
this
interface
or
it
can
be
viewed
as
a
document
via
this
interface
or
it
can
be
viewed
as
a
thing
via
this
interface,
so
you
can
kind
of
like
you
really
do,
get
full
on
objects,
as
kind
of
like
at
least
might
be
in
the
ultimate
object,
oriented
programming
with
all
of
its
problems
in
terms
of
performance,
but
you
don't
like
usually
make
like
this
is
for
bigger
size
objects
or,
like
you're,
not
doing
tons
of
teeny
tiny
objects.
Instead,
you
have
like
bigger
components.