►
From YouTube: IPLD weekly sync 2019-11-11
Description
A weekly meeting to sync up on all IPLD (https://ipld.io) related topics. It's open for everyone and recorded. https://github.com/ipld/team-mgmt
A
A
Usually
this
was
just
today.
It
came
up
and
they're
still
this
discussion
about
sir
day
and
take
support
for
performance
and
I
came
to
the
conclusion
that
for
IPL
D
there's
not
really
a
point
using
sturdy
because
well
we
need
a
change
that
they
don't
want
to
do.
App
spin
and
I
also
looked
into
perhaps
early
could
be
extended
and
we
still
have
our
staff
working
with
the
rest
of
the
survey
ecosystem.
A
A
It
does
seem
to
be
possible
and
my
plan
still
is
to
write
a
blog
post
about
it,
because
the
rust
community
has
a
call
for
2020
to
say
what
things
do
you
want
to
see
in
the
next
year
for
rust
and
my
item
would
be
I
want
to
be
able
to
extend
a
third-party
Mario
somehow
like
it
does
need
to
be
nice.
It
just
needs
to
be
some
way
and
this
yeah
so
we'll
see
if
they,
if
they
pick
it
up
or
not,
but
that's
my
plan
but
I'd
related
to
this.
A
The
author
of
the
C
bore
kraid,
discussed
on
the
issue
and
pink
me
that
he
still
would
want
to
have
tech
support
and
now
the
idea
is
that
he
might
fork
certain
and
the
way,
but
the
way
it
works.
Is
you
really
compile
it?
Normally,
it
would
use
the
normal
survey
and
you
won't
have
support,
but
then
you
can
add
additional
line
to
your
project
and
then
it
will
use
this
fork,
which
is
tech
support,
and
then
you
have
tech
support,
but
the
other
modules
will
still
use
this
fork
version
and
basically
just
work.
A
A
Don't
like
I
get
like
a
background
thing,
I'm
working
on
or
like
help
with,
but
it's
not
like
the
top
priority
because,
as
I
said,
it's
unlikely
that
it
will
go
upstream
then
there's.
Another
great
news
is
that
the
text
specification
it's
some
standard
that
I've
been
involved
with
a
bit.
They
have
an
extension
for
checksums
and
I
convinced
them
to
use
multi
hash
for
their
stuff
and
you
got
merged.
A
Standardization
organization
and
most
of
the
assistants
also
become
ISO
standards.
So
basically,
this
kind
of
like
this
way
kind
of
mod,
has
bubbles
up
into
an
ISO
standard.
Hopefully
so
it's
kind
of,
like
that's
pretty
I,
think
yeah
so
and
then
on
the
rough
side
of
things.
I've
looked
into
as
I
said,
I
want
to
make
the
thrust
stuff
also
work
with
others,
so
this
stuff
is
I,
look
into
the
ecosystem.
A
What
we
have
and
I
just
found
out
that
we
have
so
critical
Epps
has
done
rust,
multi
hash
project,
but
the
lip
utility
team
has
faulted
for
the
p2p,
so
we
p2p
is
not
using
the
upstream
project.
So
what
I
currently
do
is
I
beg
for
those
pages
and
to
make
sure
that
basically,
the
p2p
and
whatever
we
have
used
the
same
version
and
yeah
so
am
as
a
bigger
information.
A
The
reason
is
so
the
lip
p2p
rough
version
is
mostly
done
exclusively
even
done
by
a
false
from
hurricane,
and
so
it's
not
Piper
collapse
and
therefore
it
was
just
yeah
easy
if
I
see
them
for
forked
but
I'm
so
I
know
one
of
the
main
developers.
Well,
we've
met
so
times
in
the
past
person.
So
it's
basically
it's
not
so
it's
a
friendly
fork.
It's
not
like
they
want
to
do
something
fundamentally
different,
but
it's
just
it
was
faster
for
them
to
move
forward.
A
So
it
shouldn't
be
a
big
problem
to
and
they've
had
an
issue
open
that
they
want
to
go
back
to
upstream.
So
but
that's
what
I'm
working
on
yeah,
it's,
not
it's
actually
more
exciting
than
you
would
think,
because
it's
basically
made
huge
progress
because
you
merged
those
upstream
patches
and
get
them
really
move
with
one
click
and
yeah
make
big
progress.
So
it's
kind
of
nice,
but
it's
not
like
mentally
challenging
yeah.
B
B
B
In
the
last
couple
of
weeks,
I've
learned
a
lot
more
about
the
compiler
internals,
and
particularly
one
feature
that
turns
out
to
be
relevant
to
us
is
so
we
end
up
having
lots
and
lots
of
things
escape
to
heap
because
we
want
to
handle
them
by
interfaces
like
all
of
our
traversal
code.
The
selector
is
a
bunch
of
our
cool
features
like
that.
B
They
all
work,
because
we
can
turn
everything
into
a
node
interface
monomorphic
right,
but
for
things
to
be
held
as
an
interface
in
go,
they
have
to
be
a
pointer,
so
they
have
to
be.
The
almost
always
implies
that
they
have
to
be
on
the
heap,
but
they
definitely
have
to
be
a
pointer.
So
one
important
thing
that
I've
learned
recently
is
that,
once
you
have
one
whole
structure,
that's
on
the
getting
internal
pointers
into
positions
in
that
same
structure
is
essentially
free.
B
This
is,
is
still
easier
said
than
done,
and
this
turns
out
to
kind
of
actually
get
in
conflict
with
some
of
the
interfaces
that
we've
already
got.
So
in
all
the
code
today,
like
from
some
of
the
very
earliest
drafts,
so
we'd
have
a
note
interface.
We've
got
the
matching
note
builder
interface
and
the
note
builder
builds
up
some
value
and
then,
when
you
call
the
final
build
method
on,
it
will
return
a
note
that
is
supposed
to
then
be
read-only.
B
And
so
the
overall
semantics
of
the
note
builder
interface
is
you
build
some
small
value
and
then
you
build
a
bigger
one
and
you
fill
it
with
smaller
values
so
that
you
build
up
this
way,
and
this
is
almost
exactly
the
opposite
of
what
we
want
to
do
for
efficiency,
because
we
want
to
start
with
a
large,
extend
allocation
and
then
fill
it
in.
So
it
turns
out
that
the
interface
itself
is
it's
just
going
the
opposite
direction
of
the
way
that
the
internals
want
to
go
for
a
long
time
to
go
fast.
B
B
On
a
note
builder,
currently
the
thing
that
that
returns,
you
is
supposed
to
work
within
the
bounds
of
the
type
right.
So
if
you're
asking
for
the
builder
for
a
field-
and
it
gives
you
the
type
food
builder
you
should
have
spent-
simply
be
able
to
use
that
thing
more
than
once
to
build
several
instances
of
food,
and
if
we
tried
to
do
the
extent
based
allocation
stuff,
then
we
could
actually
cram
it
all
into
the
same
interface.
B
B
So,
basically,
lots
of
questions
about
what
the
same
interface
is
for
that,
and
so,
if
somebody
wants
to
talk
more
about
that
later,
I
think
I
need
more
than
one
opinion
and
I'll
leave
it.
There
I
see
rod,
wincing
yeah.
Sorry,
if
it's
the
correct
reaction,
though
it
really
is,
if
nothing
else,
I'm
working
on
a
big
documentation
about
things,
I've
learned
about
the
go
compiler
memory
layout,
so
that
might
help
have.
B
C
So
aside
from
the
documentation
which
I
finished
off
last
week,
well
I
finished
off
the
bulk
of
it
last
week
and
that's
I'm
happy
for
that
to
student
review
for
a
little
while,
but
I
really
would
like
to
consider
getting
input
from
outside
the
team,
so
identifying
someone
or
someone's
that
could
have
a
look
at
it
and
if
they
can
figure
out
what
we've
been
doing
for
the
past
few
months
from
the
document,
then
that's
a
win.
That
means
it's
doing
what
it's
supposed
to
do
so
I,
don't
know
what
the
process
is
there.
C
Maybe
we
merge
it
and
then
get
someone
to
review
it,
or
maybe
we
get
someone
to
review
it
in
the
state
that
it
is
now
I,
don't
know
anyway,
but
I'm
glad
that
you
guys
are
working
your
way
through
it.
That's
very
helpful,
aside
from
that,
I've
moved
on
to
so
I've
had
this
itch
that
that
isn't
in
needing
to
be
scratched.
A
Yeah,
it's
and
so
I.
Try
to
use
like
the
I
tried,
some
library
which
uses
the
tap
format
basically-
and
you
can
just
have
like
piped
to
the
browser,
just
kind
of
work
which
was
kind
of
nice,
but
I'm,
not
sure
if
it
will
like
if
it
like
the
the
Perl
again,
it
was
like
the
hello
world
testing
works,
but
anything.
C
B
C
That's
I
mean
that's
that's
really.
This
is
one
of
the
main
reasons.
I
checked
out
of
browser
day
a
few
years
ago
was
the
craziness
of
trying
to
you
know,
trying
to
make
things
that
are
compatible
across
browsers,
but
just
testing
that
testing
in
the
browser
is
just
ridiculous
and
it
really
hasn't
improved
that
much,
which
is
just
a
ridiculous
thing
about
it
since,
like
how
are
people
satisfied
with
this,
but
you
know
everyone
has
their
little
hacks
of
getting
around
it
and
yeah
I
mean
selenium,
is
still
state
of
fear
and
well.
I.
C
Think
the
thing
that
we
have
is
that
we
we're
in
that
we're
in
that
that
middle
area
of
we
don't
care
about
into
n
UI
testing.
We
don't
need
to
control
a
browser
to
do
to
test
an
interface
or
the
Dom.
We
want
to
take
library
code
and
say
this
works
in
the
browser.
So
it's
a
it's
a
subset
of
what
most
people
who
are
operating
in
the
browser
care
about,
and
so
and
it's
that
area.
That's
not
served
very
well.
C
If
you
want
to
do
end-to-end,
then
there's
a
bunch
of
options
where
you
can
many
of
them
using
selenium
in
some
form
a
bunch
of
options
were
options
where
you
can
do
that.
It's
just
that
that
vans
up
to
heavyweight
for
what
we
want.
We
just
want
to
say:
okay,
I've
got
a
library
that
I
expect
to
be
in
a
browser
environment.
C
A
So
I
just
won
one
question
this
just
came
up
today
and
I
need
should
put
more
thought
in
there
before
asking,
but
I'm
so
like
first
you've
thought
about
it
already
so
I'm
so
keen
to
hear.
The
answer
is
that
when
I
reviewed,
the
schema
documentation
stuff?
Is
that
the
the
representation
of
let's
say
a
struct?
Yes,
so
you
find
in
a
schema
the
presentation
of
a
strike,
how
it
should
be
seriously
realized.
But
what,
if
you
want
to
civilize
it
for
different
formats
differently?.
A
Why
I'm
asking
this
so
basic
background?
The
big
run
of
this
story
is
that
yeah,
don't
yeah,
but
so
just
what
I
feel.
Obviously
the
problem
is
that,
for
example,
and
especially
with
structs,
so
in
schemas
we
have
red
cards,
so
I
would
call
them
records,
which
is
busy
structs,
so
probably
call
them,
but
in
the
data
model
we
don't
have
this.
So
in
the
data
model
we
only
have
a
list
which
is
basically
the
the
thing
we
would
put
records
into.
A
But
the
point
is
that,
for
example,
in
the
Rossum
interface
type,
so
it's
between
an
upcoming
standard
for
exchanging
data
between
things
is
healthy,
based
on
web
IDL.
I
further,
keep
it
short
so
and
they
basically
don't
really
define
a
map
type,
but
they
only
have
a
record
type,
which
basically
means
is
in
our
world.
It
would
be
strange
to
transform
it
from
the
schema
from
struck
into
a
map,
then
into
lists,
so
we
can
use
it
then,
as
a
record
type.
A
Instead,
it
could
directly
be
basically
from
our
schema
into
the
record
time
and
everything
will
be
fine,
but
the
problem
is
again,
of
course,
if
you
transfer
me
to
chase
on,
you
were
to
use
the
normal
map
book,
and
it
was
just
like
something
that
Betty
came
to
my
mind
about
like
yeah.
Is
this
something
we
like
thought
about
on
yeah?
Is
it
just
we'll.
B
So
I
think
I
had
had
a
very
similar
thought
before
when
we
were
doing
some
of
the
selector
specs
stuff.
We
carried
about
serial
sizes
selectors
a
lot,
but
we
still
used
maps
for
extensibility
purposes,
but
so
we've
renamed
a
bunch
of
fields
down
a
single
character
right,
but
that's
not
what
I
want
to
see
when
I'm
debugging.
B
B
Semantics
are
identical,
so
we
can
actually
use
either
one
of
them
on
the
same
data
very
easily.
So
I
think
we
could
do
a
similar
thing
to
to
make
a
schema
suddenly
conform
to
the
Wasi
standards.
We
could
just
say:
okay,
take
the
real
schema
that
we
wrote
first
and
then
transform
it
into
another
schema
where
every
single
struct
is
annotated,
representation,
tuple.
B
A
A
So
this
was
a
huge
problem
with
couch
TV
as
it
is
in
earning
so
betting,
how
they
do
person
Chaisson
is
they
have
basically
a
list
of
tuples
where
the
key
is
basically
a
tooth
to
top
I
can
list
of
two
tuples
where
the
first
element
is
the
key
and
the
second
one
is
the
value
and
then
yeah.
This
is
how
they
have
a
map,
but
they
yeah.
A
Well,
it's
more
like
in
the
like
French
little
programming,
the
world.
You
don't
have
really
matters
at
least
internally,
which
is
a
pain
and
so
and
but
yeah
for
those
cases.
So
pity
I
was
wondering
Stu,
it
I
think
make
sense,
because
really
I
was
wondering
how
like
how
tightly
we
want
to
couple
the
representation
to
the
scheme.
Macd
is
kind
of
like
the
question
or
like,
but
if
you
can
use
the
transform
in
that's
Ruby,
yeah
and
I.
Think.
B
This
is
worth
noting
and
we
maybe
haven't
yet,
but
if
you're
doing
a
transform
on
a
schema
that
only
massages
the
representation
parts
of
it,
then
there
are
certain
properties
that
that
necessarily
preserves
which
is
cool
yeah
so
like.
If
you
had
some
other
function,
that
was
going
from
schema
to
schema,
but
it
was
massaging
some
other
things
that
were
in
like
if
it
was
removing
or
adding
nullable
annotations.
Those
would
change
the
behavior
right,
but
if
they're
just
massaging
the
representation
stuff.
C
Again,
we're
gonna
get
into
trouble
with
all
sorts
of
things
where
we're
trying
to
do
we're,
trying
to
adapt
to
specific
environments,
which
is
where
we're
gonna
have
to
do
annotations
and
that
sort
of
stuff
Cochin
is
the
obvious
place.
But
this
this
is
an
extension
of
Cochin
really.
C
Basically,
it's
basically,
you
know:
we've
got
this
nice
layer,
but
when
the
rubber
hits
the
road
in
all
these
different
environments
is
going
to
be
special
cases
everywhere
and
I
think
we
can.
We
can
probably
adapt
to
a
lot
of
them
with
different
encoding
formats
like
coming
up
with
a
new
dag,
something
or
other,
but
then
others.
C
We're
just
gonna
have
to
expose
specific
rules,
and
that's
where
we
it's
gonna,
get
ugly
with
annotations,
but
that's
gonna
be
a
necessary
evil
to
make
it
practical
for
people,
because
a
lot
of
consumers
of
this
stuff
are
going
to
be
they're,
going
to
be
using
it
in
a
specific
environment.
So
they
all
they
care
about.
They
don't
care
about
the
fact
that
this
thing
is
nicely
portable.
No
I
just
wanted
to
work
in
my
environment
and
I
want
all
the
goodies
that
come
along
with
it.