►
From YouTube: 🖧 IPLD weekly Sync 🙌🏽 2021-02-15
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
I
think
we're
on
hello
everyone
and
welcome
to
this
week's
ipl,
the
weekly
sync
meeting,
it's
february,
the
15th
2021
and
as
every
week
we
go
over
the
stuff
that
we've
worked
on
on
the
past
week
or
weeks,
because
we
haven't
had
proper
meetings
for
a
while
and
then
the
stuff
that
we
will
work
on.
So
I
started
myself
and
I
don't
have
that
much
to
report
actually
so
done.
A
I
have
nothing
really
hypoderated,
but
what
I
will
do
is
perhaps
interesting
for
some
people
is
that
I
will
work
on
getting
the
js
multi
formats
stuff
into
js
ipfs
yeah.
So
this
is
what
I
want
to
do
till
the
end
of
the
quarter,
part
time
and
we'll
see
how
this
goes
and
yeah
just
I'm
still
like
last
week.
A
B
Shoot
I'm
still
typing,
so
it's
been
a
very
chaotic
week
or
so,
but
there
are
some
pr's
up
if
anyone's
interested
in
reviewing
go
code.
I've
done
a
bunch
of
attempts
at
reworking
how
linking
works
in
go
ipld,
prime,
so
that
is
something
that
we've
had
a
couple
issues
open
for
a
very
long
time
saying
this
interface
doesn't
feel
good.
Can
we
make
it
feel
good?
I
think
there's
now
draft
available
that
actually
improves
this
pretty
drastically.
B
The
short
story
is
that,
instead
of
the
link
type
carrying
a
ton
of
logic
attached
to
it
now,
instead,
there
is
a
concept
called
link
system
and
all
of
the
logic
is
over
here,
and
it
has
nice
little
plugins
for
how
you
select
the
codec
and
how
you
select
the
hasher
and
stuff
like
this
and
now
the
link
interface
is
expected
to
just
carry
information
and
do
and
contain
no
logic,
I'm
hoping
that
this
is
going
to
make
a
bunch
of
code
a
lot
clearer
and
a
lot
less
circular
in
its
connections.
B
It
also
means
that
these
go
libraries
get
to
move
away
from
strictly
depending
on
some
of
the
stuff.
In
the
go
multi
hash
libraries,
which
wasn't
a
dragon
that
I
intended
to
slay
at
the
start
of
this
refactor,
but
it
turned
out
to
be
so
much
on
the
path
that
I
went
straight
for
it
anyway.
B
There
had
been
a
little
bit
of
a
concern
with
the
go
multihash
libraries
before
I
actually
didn't
even
realize
how
big
of
an
issue
this
was
until
I
started
poking
it,
but
where
that
library
had
a
bunch
of
hashing
functions
as
direct
dependencies,
and
so
if
you
wanted
to
add
any
new
multi
hashes
and
be
usable
in
the
go
libraries
you
had
to
patch
this
library,
you
couldn't
register
them
yourself.
There
wasn't
a
registry
concept
like
that,
and
and
also
all
of
its
apis,
didn't
allow
streaming,
which
is
just
like
wrong.
B
B
B
B
B
So
and
that's
everything
that's
been
on
my
mind
lately.
C
Yeah
sorry,
I
put
some
code
on
top
for
discussion
that
it
doesn't
look
as
good
as
I
thought
it
would
right
so
not
much
to
report.
Ipod
is
wise.
Aside
from
the
thing
that
I
have
been
working
on
on
off
for
like
like
two
months
now
is
an
actual
library.
Now
that
hasn't
been
pushed
yet,
but
I
just
need
to
go
one
more
pass
on
the
docs
on
it.
It
should
appear
and
be
usable
relatively
soon
this
week
it
is.
C
It
has
a
funny
name
because
it
kind
of
does
expect
to
have
you
know
a
chain
attached
to
it,
but
actually
can
be
used
as
a
general
general
boxer
as
well.
A
lot
of
interesting
things
were
discovered,
one
of
which
I
want
to
talk
about
later
today.
We
have
time-
and
that's
pretty
much
it
from
me-
updates.
D
Okay,
yeah
now
mine's
mine's
very
minimal,
been
pulled
into
new
things,
as
I
think
we
all
are,
but
I've
been
trying
to.
I
really
would
like
to
get
this
spec
actors,
v3
def
stuff
done
for
this
specs
repo
we've
got
the
we
described
the
the
format
of
the
blocks
and
spec
actors
for
far
coin
and
there's
we've
got
version
zero.
Two
and
now
three
is-
is
in
the
process
of
being
rolled
out.
So
will's
already
done
that
work
in
state
div
and
I
need
to
I'm
gonna.
D
Do
it
as
well
and
then
and
then
I
can.
I
guess
sanity
check
his
work
and
help
over
there,
but
I
just
assume
it'll
be
fairly.
E
D
D
That's
that
was
the
goal
originally,
but
it
was
just
too
hard
to
think
about
how
to
do
it,
but
I
think
I
think
it's
time
to
do
that
and
describe
the
different
formats
of
the
adls
and
then
and
then
how
they
use,
because
the
problem
is
that
mostly
they're
used
with
inline
values
and
some-
and
I
think
in
a
couple
places
there's
links,
but
I
want
to
because
they're,
ideally
they're
adls
in
documentation
too,
but
right
now,
it's
like
it
just
destroys
describes.
D
If
the
values
were
in
line,
it
was
just
a
link,
you
could
say
sort
of
like
you
do
in
state
diff,
where
you
just
sort
of
fudge
it
and
you
just
say,
there's
a
thing
here
and
go
there
and
then
come
back
again.
But
it's
just
not
as
easy
in
documentation
to
do
that.
D
It's
yeah,
but
in
when,
when
we're
describing
block
layout,
it's
not
that
easy,
but
no
you're
right,
maybe
maybe
that's
all
I
need
to
do,
is
because
we
originally
with
adls.
We
had
this
idea
of
of
describing
the
adl
as
it's
just
it's
like
a
map
representation
than
the
adl
name,
and
we
we
balked
on
that
because
of
various
reasons.
But
that's
the
ideal
is
to
have
something
like
that.
Where
you
could
say
you
use
the
map
syntax
but
say
this
is
actually
you
find
this
elsewhere?
D
It's
just.
We
don't.
E
I
think,
from
an
intuition
perspective,
it
would
be
super
useful
to
start
out
by
saying
you
should
think
of
this
as
a
map
and
then
here's
the
internals
of
how
we're
actually
representing
that
and
go
into
the
detail
like
at
a
first
pass
when
someone's
trying
to
understand.
What's
going
on
that
first
bit,
which
we
don't
have
anywhere
is
you
should
think
of
this
as
a
key
value
map
or
dictionary?
E
D
D
D
Maybe
I
should
just
go
with
that
and
fix
it
later
if
it,
if
we
get
to
something
better
anyway,
that's
that's
me,
I
don't
think
I've
got
anything
else
meaningful
just
a
little
bit
of
a
little
bit
of
maintenance
on
javascript
stuff,
but
yeah
we've
got
the
we've
got
some
typescript
stuff
coming
through
the
javascript
changes,
and
it
seems
that
each
one
of
the
typescript
pull
requests
to
add
types.
D
It
also
includes
breaking
changes
to
each
of
the
libraries
that
it
touches,
which
is
odd,
so
we
have
to
deal
with
we.
I
I
think
it
comes
from
people
trying
to
use
stuff
in
new
ways
and
finding
that
the
interfaces
that
we're
exporting
are
not
optimal,
particularly
for
types
for
the
old
language,
older
libraries
and
for
the
newer
ones,
they're.
Finding
that
the
interfaces
maybe
could
be
more
intuitive
for
how
they
want
to
consume
them,
and
so
that's
that's
feedback.
It's
just
yeah.
Anyway,
that's
going
on
too.
E
I
guess
the
main
thing
that
has
that
I
started
on
last
week
with
others
is
trying
to
get
down
a
set
of
design
docs
of
what
it
looks
like
to
upgrade.
The
current
go
ipfs
code
base
to
make
use
of
go
ipld,
prime
throughout.
E
Currently
it's
using
a
older,
go
ipld
format,
library
and
it
sure
would
be
nice
to
not
have
that
happen
and
would
allow
for
some
better
representations
of
some
things,
so
that
is
coming
together
and
should
end
up
in
a
polar
request.
Slash
issue
slash:
the
world
is
evolving
around
me
location
later
this
week
for
broader
consumption,
and
hopefully
that
translates
into
then
a
bunch
of
people
actually
making
that
happen
and
become
a
reality
which
would
be
good
for
go
ipld,
prime
and
for
ipfs.
A
F
Yeah,
I
don't
know
I
mean
all
I
think
I
mentioned
this
may
even
two
weeks
ago,
but
I
discovered
that
there
is
a
codec
here
at
aws
called
ion,
which,
when
I
went
through
it,
it
just
seemed
very
thoughtful.
They
kind
of
thought
through
some
of
the
issues
that
we
or
did.
F
I
guess,
designed
and
addressed
some
issues
we've
burned
into
like
with
json
and
seymour
and
whatnot,
and
I
actually
am
using
it
for
my
own
metal,
imaging
thing
I'm
doing
here
and
actually
not
because
it's
aws,
but
but
just
because
I
thought
it
was
actually
I
wanted.
I
thought
it
was
fun.
I
wanted
to
try
this.
F
You
know
as
you,
you
see
new
technology
to
work,
and
so
I
did,
it
seemed
pretty
cool,
so
I've
stuck
with
it,
but
I
think
my
ideal
world
would
be
is
that
there
would
be
ipld
would
have
support
for
ion.
Well,
actually,
I'd
like
to
use
all
your
guys's
opinion
on
it.
F
If
you
had
a
chance
to
look
at
it,
but
it
seems
like
something
that
might
be
a
good
match,
and
I've
worked
with
it's
kind
of
interesting
because,
like
you
know,
I
guess
compare
like
taken
from
a
javascript
point
of
view,
but
compared
to
javascript,
like
with
the
other
ipod
codecs,
they
kind
of
return
the
javascript
object
and
which
is
nice.
But
then
you
run
into
some
issues
like
what
happens.
A
F
So
I
don't
know
how
that
would
map
to
the
ipld
interface,
because
I
know
these
may
be
correct,
I'm
wrong,
but
it
seems
like
the
javascript
one
is
intended
to
be
very
that
the
codex
guy
exposed
and
tend
to
be
a
very
like
native
javascript,
but
you
know
there's
some
of
those
issues
or
with
I
guess,
javascript
and
I'm
not
sure
how
you'd
expose
some
of
those
features
of
ion,
but
but
anyway,
so
that's
that's
what
I've
been
playing
with,
and
I
know
I
I
asked
michael
what
he
thought
about.
F
D
I
had
a
look,
but
it
was
not
an
in-depth
look.
I
just
it
was
that
when
I
saw
the
number
of
types
it
was
I
booked
at
that,
but
michael
went
further
and
michael's
really
positive
about
it.
He
thinks
it
looked.
He
looked
pretty
good
and
even
raised
some
internal
discussions,
and
it
turns
out
that
that
it
was
considered
by
peel
back
in.
D
I
don't
know
when,
when
they
eventually
decided
to
go
with
dag
with
with
seaboard
as
a
foundation
for
taxi
board
like
ion
was
a
candidate
for
for
a
a
better
format.
So
that's
really
interesting
and
I
don't
know
the
context
of
that
of
or
why
they
flipped
onto
sibor.
Maybe
it's
to
do
with
the
linking
type.
I
don't
know
how
extensible
ion
is
for
introducing
a
linking
type.
This
might
be
a
problem
but
yeah.
D
It
is
it's
positive
and
and
and
the
fact
that
there's
this
little
json
variant
of
it
or
something
you
can
represent
them
nicely
in
json
too,
and
this
seems
like
there's
some
nice
properties
of
it,
that
we
should
consider
yeah.
F
Yeah,
it
actually
has
two
encodings.
It
has
a
text
format
that
looks
like
json
as
well
as
a
binary
format.
I
think
the
rationale
is
that
you
know
the
binary
one's
efficient,
but
if
you
want
something,
that's
human,
readable
and,
like
you,
support,
prototyping
or
like
to
go,
look
at
without
having
a
tool
it
kind
of
it's
kind
of
built
in
so
I
don't
know
what
that
would
mean
from
a.
I
guess.
I
build
the
codec
point
of
view.
F
D
To
be
too
codex,
but
it's
this
is
the
reason
I
want
to
get
jason
finalized
exactly
that
use
case.
Where
you
you
want
to
be
able
to
see
the
data
you
want
to
be
able
to
manipulate
it
manually
and
doing
that
with
civil
is
not
good
and
so
having
the
duality
is
really
nice,
and
especially
when
there's
bi-directionality
between
them.
Where
it's
you
can
you
know
you
can
exchange
one
for
the
other
without
any
problem,
and
it'll
be
nice
to
get
jason
closer
to
that.
D
That's
still
a
mission
that
I
have
it's
just
it's
going
to
be
hard
to
fit
that
in
unless,
unless
we,
our
project,
org
structure
really
helps
us
to
deal
with
some
of
these
things.
I
don't
know
how
much
you've
heard
about
our
reorg
crisp.
D
We've
had
a
bit
of
a
shuffle
and
there's
a
some
of
us
are
not
going
to
be
as
focused
on
ipld
as
a
single,
singular
thing.
F
D
It
should
it
should
mean
more
people
touching
ipld
and
it's
becoming
more
integrated,
which
I
think
would
be
the
the
upside
of
this
particularly
ipld,
prime.
So
possibly
the
downside
will
be.
This
group
will
be
less
focused
on
just
these
efforts,
even
though
we're
all,
I
think,
we're
all
passionate
about
these
things
and
the
fact
that
we
will
probably
keep
on
showing
up
to
these
meetings,
even
if
our
work
is
somewhere
else.
It's
probably
an
indicator
of
that.
F
C
Yeah
yeah,
absolutely
I
was
going
to
say
for
the
purpose
of
the
live
stream.
This
is
actually
kind
of
like
in
the
air
still,
and
there
are
all
indicators
that
this
particular
meeting
will
continue
going
forward,
at
least
for
the
foreseeable
future.
So
yeah
more
more
people
joining
would
be
would
be
awesome.
B
So
a
couple
of
things
that
occurred
to
me,
while
chris
you
were
telling
us
about
ion,
do
people
pronounce
it
eon
or
ion
by
the
way
I've
always
wanted
to
pronounce
it
eon
in
my
head,
but
maybe
I'm
weird.
B
Fair
enough,
so
the
thing
you
mentioned
right
at
the
beginning
about
how
the
libraries
for
it
in
javascript
worked.
B
That
is
probably
really
interesting
to
us,
because
I
think
at
least
some
people
have
been
talking
about
if
we
should
try
to
make
javascript
libraries
with
a
bit
more
of
that
vibe.
I
think
rod
and
iraqi
both
come
to
that
thought
at
various
points,
and
sometimes
we've
talked
about
that
as
making
a
prime
like
library,
because
it's
moving
closer
to
the
ast
like
sort
of
headspace,
that
the
go
libraries
are
written
around
so
seeing
examples
of
how
the
ion
libraries
did.
B
This
could
be
really
interesting,
especially
if
people
benchmarked
that
I
suspect
that
could
be
really
fascinating,
because
sometimes,
when
we've
had
our
discussions
about
this,
we
haven't
done
the
thing
we
haven't
made
a
lot
of
prototypes
of
this.
B
B
F
Well,
I
I
have
implemented,
I
mean
I
should
talk
about
actually
using
their
apis
like
you're
talking
about
yeah
yeah,
so
I
have
some
exposure
to
it,
and
but
I
mean
I
can
certainly
show
what
I
know.
But
it's
it's
not
a
lot.
I
mean
if
I
I'm
gonna,
keep
on
working
with
it,
so
I'll
have
more
in
a
couple
of
weeks,
but
one
actually
so
yeah
and
it's
it
really
kind
of.
I
would
say,
through
my
head
through
a
bit
of
a
spin
when
I
started
running
into
because
it
was
not.
F
I
wasn't
prepared
for.
I
was
expecting
to
just
be
the
javascript
object
and
it's
got
like
layers
of
stuff
and
things
you
have
to
do
to
like
access
the
data
properly
so
yeah.
I
can
show
what
I
know
but
give
me
a
couple
weeks
of
playing
with
a
bit
more.
I
can
speak
more
intelligently
about
it,
but
one
other
kind
of
related
thing,
which
really
got
me
interested
that
you
guys
might
want
to
think
about
is
that
they
have
this
whole
philosophy.
F
That
says,
you
should
be
able
to
do
like
a
streaming
parse
of
the
data
and
then
put
the
stuff
that
you
want.
That's
that's
most
interesting
near
the
front
of
the
file,
so
you
can
basically
do
an
early
terminate
and
get
out
and
not
to
pay
the
cost
for
parsing
the
entire,
like
structure
and
so
ion,
and
because
I
think
they
I
think
they
use
internally,
who
knows
for
what?
But,
but
that
makes
sense
right.
F
If
there's,
if
you
have
a
thousand
data
items
and
like
ten
of
them,
you
need
most
of
the
time
and
the
other
ones
you
rarely
need.
Then
you
put
the
in
the
front.
You
already
turn
it.
You
save
yourself,
compute
storage,
you
know
whatever
network
costs
and
I
don't
know
how
to
apply
the
ipld,
but
I
think
the
principle
it
I
don't
know
if
ipld
will
work
where
you
could
do
like
a
streaming
decode
or
not
or
if
it
basically
forces
you
to
do
full
decode
of
a
block
and
then
operate
out.
F
But
I
thought
it
was
a
really
interesting
principle.
I
mean
I'm
like
I
was
kind
of
excited
about
because
actually
within
medical
imaging,
we
run
this
case
all
the
time
we
have
thousands
and
thousands
of
actions
like,
but
of
them
right
and
it's
nice
to
put
those
in
the
front
and
order
things
that
way.
B
I
wonder
if
we
should
try
to
so,
I
think
there's
a
document
to
be
written
somewhere
in
that
vicinity,
that
we
have
not
written
yet
and
is
tricky
to
write,
because
there
are
some
very
fundamental
trade-offs
in
that
which
any
serialization
format
will
eventually
rediscover,
and
I
think
the
inevitable
trade-off
is
streaming
right
versus
streaming
read
they
almost
pull.
You
in,
like,
I
think,
explicitly
contradictory
directions
at
some
point.
If
you're
doing
streaming
rights,
then
you
cannot
do
length
prefixes,
because
you
can't
stream
it
right.
F
B
I
don't-
have
the
earliest
notes
of
what
other
people
at
pl
might
have
thought
about
this,
but
I
think
some
of
the
if
there
was
a
transcoding
from
this
into
json.
That
would
also
be
interesting
to
look
at,
but
I
guess
you're
saying
it
has
a
human
readable
textual
representation
that
looks
like
json,
but
probably
isn't
it's.
It's.
F
I
think
it's
a
super
set
of
json,
so
they
json
does
encode
in
this
format.
But
then,
if
you
want
some
of
those
advanced
features
and
other
things,
I
think
you
use,
so
you
do
something
different
for
you.
It
doesn't
it
wouldn't,
of
course,
the
json
right.
B
So
I
think
if
we
were
to
make
bridges
between
the
ipld
data
model
and
this
ion
format,
it
would
be
kind
of
similar.
If
we
wanted
to
be
morphing
the
ion
format
into
the
ipld
data
model
because
ion
has
more
kinds,
we
would
have
to
define
that
morphism
somewhat
carefully,
but
otherwise
it
should
be
fairly
doable
to
do
that.
B
D
Okay,
I
think
I
think
both
our
stacks
now
javascript
and
go
are
in
a
position
where
it
wouldn't
be
too
hard
to
make
them
do
the
bail
early
thing
with,
if,
if,
if
you
didn't
match
a
schema,
so
not
pass
the
full
thing
so
that
we've
got
a
new
back-end
passer
for
the
javascript
library.
D
Now
that
does
does
it
sort
of
a
step
through
parsing
that
you
could
insert
something
like
a
schema
checker
into
it,
so
you
or
or
even
something
else
where
it's
you're
reading
a
block
and
you
can
bail
early,
but
I
think
I
think
the
the
ipld
focus
on
the
smaller
blocks
like
we're.
Just
we
just
don't
do
massive
blocks.
A
All
right
should
we
go
on
with
the
gender
items.
I've
put
an
item
there,
because
we
still
have
this
software
heritage.
Multi
coding
pull
request.
Open,
I
mean
it
kind
of
like
is
yeah
the
discussion
dried
out
and
yeah.
So
I
think
we're
at
that
point.
A
We
we
should
do
something
and
yeah
a
question
like
what
should
we
do
next
so
so
I
personally
would
say
that
so
I
still
propose
that
they're
using
the
get
raw
object
for
for
all
the
types
except
for
the
country
for
which
one
it
was
snapshot,
I
think,
or
something
for
the
special
type
and
have
for
them
registered
one
special
type.
So,
basically
you
have
one
special
type
and
for
all
the
other
types
they
use
git
raw.
A
This,
I
still
think,
is
what
I
would
prefer
and
I
they
seem
to
be
okay
with
it.
I
yeah.
A
B
Anything
I
was
just
gonna
observe.
I
think
some
of
the
people
in
that
discussion
have
got
some
sort
of
grant
or
something
to
work
further
on
this
and
they're
probably
going
to
test
their
theories
with
code
at
some
point,
and
so
I
wonder
if
we
can
just
ask
them
where
that
progress
is
and
let
them
kick
us
in
the
shorts
when
they
need
a
decision,
and
maybe
we
can
make
one
at
that
point
with
more
information,
I
think
the
last
time
I
saw
any
discussion
about
that
they
were
saying
yeah.
A
It's
a
good
point,
so
I
get
so
I'm
like
also
like,
if
we
could
totally
just
like
ask
them
like.
Is
this
like?
Is
this
an
urgent
thing
or
is
it
like?
So
I
I
just
like?
Can
it
feel
so
so
unfinished
like
it's
not
clear
like
where
this
is
going,
but
if
we
like,
I
can
also
like
totally
say:
what's
the
current
state?
Is
it
okay
to
keep
it
open?
A
C
Yeah
yeah,
I
was
going
to
say
I
I
actually
didn't
say
this
on
the
on
the
tickets
because,
like
it,
I
I
feel
like
I'll
derail
it.
If
I
chime
in
but
again
like
going
back
to
what
we
talked
about
last
last
week,
that
we
might
be
losing
an
opportunity
here
by
being
stingy
on
codex,
because
the
annotation
by
a
codec
is
valuable,
because
what
they
are
doing
is
good,
but
it's
good
that
can
be
interpreted
in
a
certain
way
and
I
don't
know
it.
C
It
feels
to
me
that
saying
oh
this
thing,
you
know
this
new
disney
codec.
You
can
treat
it
also
like
a
good
thing,
is
cheaper
and
better
long
term
than
just
saying.
Oh
no,
this
this
just
like
git,
and
if
you
actually
need
to
note
it's
something
else,
you
go
and
you'll
look
up
in
some
other
registers
or
something
like
that.
C
But
that's
my
two
cents-
and
I
guess
I
guess
this
is
a
more
fundamental
problem
like
is-
is
the
codec
table
just
for
you
know
for
basic
decoding,
or
it
is
also
for
identification,
and
perhaps
the
maintainer
group.
Can
you
know,
during
their
work
upcoming
work
on
knight,
bld
prime,
can
clarify
this
because
right
now
we
have
no
clarity
on
this.
Essentially,
what
is
this
table
for.
B
Have
one
random
thought
I'll
share,
that's
been
just
floating
around
in
my
head
is
the
degree
to
which
I
don't
care
about.
This
is
actually
just
intensified
over
time.
I
looked
at
some
javascript
code.
It
was
actually
michael's
kicking
around
on
the
encryption
stuff.
That
made
me
realize
that
maybe
I
just
don't
care
so
much,
because
he
had
this
snippet
of
code,
where
he
just
had
a
bunch
of
multi-codec
numbers
and
he
assigned
them
all
to
the
output
of
some
factory
function.
B
That
made
a
thing
and
associated
it
with
the
number,
but
like
the
amount
of
variation
between
them
in
code
was
like
one,
and
I
was
like
oh
yeah
yeah.
We
can
do
that
and
so
the
idea
of
having
a
bunch
of
multicodec
numbers
that
functionally
probably
map
to
the
same
encode
and
decode
functions
while
just
being
a
different
number.
That's
persisted
in
the
cid.
D
D
D
B
C
C
The
rules
are
simple:
you
basically
have
no
no
takes
his
boxes
and
you
know
it's
unique
ids,
that's
it.
D
D
It's
a
small
category
of
codex
and
these
things
are
claiming
to
be
codecs
and
that's
our
that's
our
thing
and
we
are
trying
to
define
what
it
means
to
be
a
codec
and-
and
there
is
this
space
where
the
codec
identifier
stops
being
helpful,
and
you
need
something
else
and
it's
that
something
else
we
haven't
solved
for
we
haven't
given
a
solution
for,
and
we
just
say
this
is
something
else
that
you
need
to
deal
with,
and
we
can't
help
you
just
now
and
so
either
we
say
either
we
fudge
on
the
codec
and
say:
oh,
you
can
use
it
for
other
things
as
well
or
we
we
push
them
to
solve
it
in
different,
better
ways
or
we
come
up
with
solutions
for
it.
D
To
be
honest,
and
then
the
the
thing
that
does
make
me
slightly
open
to
well
open
to
compromise
on
this
is
is
the
fact
that
these
codecs
are
a
spectrum
anyway,
because
you
can
start
from
raw
and
any
of
these
codecs
could
be
raw
like
they're,
just
bytes,
and
I
can
read
them
as
raw
and
as
you
as
you
step
up,
you
add
layers
of
meaning,
and
so
we
go
from
raw
to
you
know,
dag
pb,
and
then
you
know
you
and
you
could
even
go
from
dag
bb
to
you
could
possibly
be
making
a
codec
that
says
unix
fs
I
mean
we're
adding
on
layers
of
meaning
in
different
ways.
D
But
the
thing
about
the
get
one
is
that
they're,
adding
on
a
layer
of
meaning
where,
by
their
instantiated
data
it
could
potentially
have
other
things
in
it.
That
are
only
there
because
the
codec
told
them
that
it's
there
like
there's
a
there's,
a
string
in
the
in
there
in
their
instantiated
data
model,
that
that
tells
them
their
identifier
of
this
data
and
that
only
exists
because
the
codec,
let
them
see
that
through
there
and
it's
like
the
actually.
The
other
example,
is
the
the
binary
merkle.
D
I
think
we
call
it
is
one
of
the
codex
where
it's
just
two
like
it's
64
bytes
of
two
sha256s
jammed
together
as
a
generic
binary
merkle,
and
you
can
just
you-
can
interpret
that
as
two
32
byte
32-bit
32
byte
hashes
squashed
together
into
a
64-byte
binary
thing,
or
you
can
view
it
through
the
what
is
it
bitcoin
tx
codec,
which
decodes
it
the
same
way.
But
you
see
something
different
and
then
you
could
look
at
the
z,
tx
codec,
which
is
the
same
thing
again,
but
you
see
something
different
in
it.
D
C
Stuff,
so
yes,
the
bottom
line
to
worker's
question
is
yeah,
let's
just
check
with
them
where
they
are
and
yeah
unblock
them,
because
this
this
small
you
know
segway,
shows
me
that
we
are
not
going
to
agree
on
what
to
do
at
the
table
anytime
soon.
D
Well,
the
other
it's
come
up
recent.
I
think
dean
has
been
pushing
on
this
too,
that
that
there
is
a
there's,
a
lot
of
misunderstanding
about
our
primitives
across
the
board
and
people
come
come
to
us
and
say
I
want
this
new
feature
when
this
thing
added
and
and
very
often
it
turns
out
to
be,
they
have
a
misunderstanding
of
the
primitives
that
we're
offering,
and
we
see
that
in
the
multi-codec
table
very
frequently
where
people
say.
D
A
All
right,
just
just
one
more
comment
about
the
p
that
the
the
primitives
are
not
like
relevant
across
the
board,
there's
also
from
the
research
and
department
group.
There
is
an
rfc
whatever
rsc
stands
for
in
this
case
about
some
ipod
stuff
and
I'm
like,
oh,
my
goodness,
is
to
review
it.
But
it's
also
like
there.
It's
like
it's
like
half
of
it
is
just
like
yeah,
the
like,
not
ipld,
how
we
talk
about
ipld.
A
So
it's
just
like
misconceptions
about
like
how
ipod
works
and
just
like,
like
yeah,
so
just
like
to
bring
it
up
again
like
it's
something
I
will
review,
but
it's
also
like
yeah.
I
agree
that
there's
some
misconceptions
or
we
need
to
be
clearer
or
yeah,
make
sure
that
I
build
the
that
the
understanding
of
ipod
d
is
the
same
across
the
board
as
we
have
sap
ip,
because
there
seems
to
be
a
huge
mismatch
between
yeah
how
we
talk
about
ipod
and
how
other
understand
italy,
yeah
yeah.
A
C
Yeah
this
one
looks
scary,
but
it's
actually
really
quick.
So,
while
writing
my
thing
with
with
a
database
based
block
store,
I
needed
a
certain
primitive
that
could
do
more
than
block
format.
C
C
So
I
basically,
if
I
have
a
block
and
I
get
its
raw
data,
I
get
a
slice
which
I
can
then
modify
at
will
and
the
block
will
be.
You
know
something
completely
different.
I
can,
for
example,
append
to
it
and
things
like
that,
which
basically
I
mean
not
a
pen
to
it,
but
prepends
stuff
to
it,
which
will
basically
write
right
over.
What's
already
in
there.
C
I
sold
this
myself
with
with
basically
having
global,
which
is
always
on,
but
this,
I
guess,
is
something
to
clarify,
either
with
docs
or
in
general,
when
you
guys
are
moving
to
more
appeal,
the
premise
stuff.
What
are
the
ownership
rules
for
all
this
data
because,
right
now
it's
basically
like
whatever
somebody
wrote.
B
G
C
Totally
fine,
we
basically
don't
say
any
of
this
anywhere
in
our
stack
right
now
is
what
I'm
basically
bringing
up
that
either.
We
should
just
say
that
we're
going
to
start
copying
things,
because
there
might
be
a
good
reason
to
do
that
in
april
depend
in
the
ipld
prime
world,
or
we
have
to
basically
annotate
everything
like
you
cannot
touch
this.
B
H
C
Yeah
yeah,
I
I
basically
wanted
to
basically
bring
up
that.
You
know
right
now.
It's
not
documented.
The
other
point
is:
do
we
even
want
to
go
down
the
path
of
implementing
what
I
implemented,
which
is
basically
that
you
can
make
this
copy
for
you?
It
will
wear
global
slack
or
something
like
that.
B
I
would
rather
not
the
wildest
thing
that
you
could
do
in
go
that
we
could
consider.
Is
you
can
use
build
tags
to
do
something
like
this?
I've
seen
people
make
packages?
Yes?
Well,
yes,
you
can
I've
seen
people
make
packages
for
debugging
where
they
use
a
build
tag
to
by
default
it's
going
to
compile
in
a
debug
printf
function.
That
is
just
literally
the
empty
function
block.
So
there's
nothing
and
then,
if
you
use
a
build
tag
to
enable
the
alternative
mode,
it
actually
puts
some
debug
printf
in
there.
E
But
I
was
going
to
argue
that
the
most
important
or
the
the
furthest
we
could
go
is
using
os
memory,
page
protection
to
have
the
memory
that
we
give
you
a
pointer
to
a
read-only
page.
B
B
B
And
so
the
the
aim
is
gotta
go
fast
and
if
you're
using
the
I
o
reader
and
I
o
writer
interfaces
in
go,
they
aren't
super
great
at
mechanical
sympathy.
Around
read
and
write
block
sizes
like
I
kind
of
try,
but
you
tend
to
end
up
with
at
least
one
copy
for
the
byte
slice
that
that
reader
interface
is
passing
around.
B
And
so
people
have
proposed
patches
that
let
us
use
some
feature
detection
to
say
like
oh.
If
this
reader
has
a
method
called
bytes,
that
gives
you
a
byte
slice,
then
just
like
cast
the
inner
face
and
then
use
the
thing
and
then
skip
all
the
other
copies
which
is
kind
of
cool
because
it
accomplishes
the
goal
of
gotta
go
fast.
B
But
it's
also
a
little
weird
because
it
completely
violates
the
I
o
reader
contract,
basically-
and
so
nobody's
made
bug
reports
about
that.
Yet,
but
I'm
borderline
surprised
because
it
means
in
practice,
if
somebody
hands
in
a
byte
buffer,
which
is
a
common
type
to
use
it,
the
reader
cursor
won't
advance
in
it.
B
A
A
What
were
those
read?
Only
things
called
because
I
tried
to
take
notes
and
forgot
the
name,
so
the
read
only
page
protection
memory
protection
things.
This
was
what
I
was
looking
for.
Okay,
thanks
for
filling
in
the
gaps.
Okay,
matv
is
the
call
yeah
yeah
thanks.
Okay,
I
think
we
are
through
the
agenda.
A
No,
then
a
closer
meeting
and
thank
everyone
for
attending
and
see
you
all
again
next
week,
goodbye
everyone.