►
From YouTube: 🖧 IPLD Every-four-weeks Sync 🙌🏽 2021-05-22
Description
An every four weeks 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
Welcome
everyone
to
this
week's
ipld
community
and
sync
meeting
it's
May
22nd
2023
and
as
every
four
weeks
these
days
we
go
over
stuff
that
people
have
worked
on.
But
now
what
is
new?
We
also
have
some
talks
and
we
I
think
we
should
start
with
the
talks
first
and
then
we
get
into
discussions
and
any
yeah
as
we
talked
about
and
then,
if
we
have
time,
we
can
still
talk
about
things
that
people
have
worked
on,
because
usually
these
days,
it's
not
that
much.
A
That
people
work
on
Direct
on
iPad,
but
it's
exciting
to
see
what
people
use
I
believe
for
so
yeah
I
guess
I
hand
over
to
move
because
yeah
you
have
some
interesting
I,
believe
things
to
share.
B
Yeah
right
my
name's
Smith,
my
pronouns:
are
they
them
or
it's
for
those
that
are
not
in
the
know,
I've
been
doing
some
ipld
stuff
for
a
while,
formerly
I
was
kind
of
working
for
the
ipld
team,
but
now
I'm,
just
in
the
ecosystem.
Doing
stuff
I
didn't
prepare
any
fancy
slides
today,
I
wanted
to
mostly
just
talk
about
this
tool.
I
made
called
car
two
dots
and
maybe
look
at
how
I
did
it.
B
B
So
hopefully
my
client
doesn't
crash,
but
it
probably
will
so
first
thing:
I'm
going
to
do
is
show
off
just
the
end
result.
B
Great
so
here
we've
got
a
large
car
file
representing
a
Unix
FS
dag,
and
this
got
generated
using
a
couple
of
steps.
So
there's
this
cool
format
called
graph
biz,
which
folks
may
or
may
not
have
heard
of,
and
it's
usually
used
for
creating
diagrams,
specifically
flow
charts
or
like
uml
type
things,
but
I
generally
like
to
use
it
for
just
showing
things
in
a
graph
format.
B
So
the
most
popular
well
as
far
as
I'm
aware
engine
for
actually
doing
layouts
is
this
format
called
dot
where
it's
kind
of
like
an
ASCII
text.
Format
for
making
graphs
where
you
can
have.
Oh,
am
I
still
sharing
how
do
I
there
we
go
where
you
basically
Define
some
nodes
and
have
like
these
little
ASCII
arrows
pointing
between
them
and
then
you
can
add
extra
formatting
if
you
want
so
the
way
that
gets
turned
into
oh.
B
The
way
back
we
turn
car
files
into
this
is
by
or
wait
should
I
get
into
what
car
files
are.
First,
I,
don't
know
what
the
context
is
for
folks,
I
might
as
well,
so
car
files
are
content,
addressable
archives,
that's
right.
The
r
stands
for
archive
and
it's
a
way
to
group
a
bunch
of
blocks
in
a
single
file.
B
Usually
people
use
this
to
export
entire
graphs
of
ipld
or
unixfs
data
where,
as
they're
traversing
through
a
graph,
they
will
take
each
block
in
their
traversal
and
write
it
in
an
append,
only
fashion
to
a
file
and
then
at
the
end,
there's
a
little
index
that
says
hey.
This
is
all
of
the
blocks.
If
you
have
a
given
CID
here's
the
index
where
the
block
starts
and
ends-
and
this
is
how
you
can
quickly
do
random
access
into
file
to
treat
it
almost
as
a
read-only
block
store.
B
So
people
use
this
a
lot
Mel.
Do
you
think
you
could
mute
your
mic
for
now?
I
hear
a
lot
of
clackity
clocks?
Oh
sorry,
no
worries.
Thank
you.
So
this
is
used
a
lot
for
exporting
files
and
data
sets
to
something
like
filecoin
or
downloading
a
bunch
of
data
at
once
from
a
trustless
Gateway,
where
you
can
verify
data
as
it's
coming
in
or
kind
of
like
get
a
bunch
of
data
at
once,
rather
than
a
single
block.
B
So
personally,
I
use
it
in
stuff
like
web
recorder
where
we're
doing
custom
chunking
and
we
can
take
like
a
web
archive-
do
some
custom
chunking
on
it
and
then
export
it
as
a
car
file,
which
can
then
be
imported
into
someone's
unixfs
node
or
published
on
filecoin.
B
So
sometimes,
when
I'm
doing
this
custom,
chunking
stuff,
I
get
bugs
and
or
I'm,
not
sure
whether
something
is
working
exactly
as
I
wanted
to,
and
so
sometimes
I
wanted
to
just
visually
inspect.
What
data
looks
like
so
what
the
car2.
Library
does
is.
It
will
iterate
through
each
block
inside
a
car
file
and
Traverse
any
links
it
has
to
other
blocks
and
add
them
in
this
dot
format.
B
So,
for
example,
I'm
going
to
edit,
rather
than
doing
slides,
I'm
just
going
to
add
text
directly
inline,
because
it's
easier
for
me.
So
bam
over
here
is
this
horrible
monstrosity
of
a
DOT
file.
So
this
is
that
diagram
I
saw
earlier.
So
if
you
look
into
the
details,
oh
wait
is
this.
B
It's
basically
impossible
to
see,
but
there
is
a
CID
that
represents
each
node
in
that
graph
and
then
I
either
have
a
label
having
like
a
short
form
of
the
CID,
along
with
the
size
of
the
Block
in
question.
So
this
one
is
151,
which
is
a
pretty
typical
for
Unix
FS
directory
or
file,
which
is
metadata,
and
so,
for
example,
this
one
is
a
lot
bigger
so
that
one's
probably
a
raw
leaf
for
a
chunk
in
this
archive.
B
B
Where
a
lot
of
tools,
just
support
and
graph
is
out
of
the
box,
so
if
I
do
graph
is
one
sec,
I
can't
yeah
I
can
paste
my
DOT
format
and
it
will
actually
take.
Oh
it's
really
struggling.
B
That's
a
classic
me
moment.
Thank
you,
okay
bam,
so
this
just
rendered
that
entire
graph
in
this
little
preview.
B
So
this
is
something
that
I
use
a
lot
for
debugging
or
say:
I'll
have
a
bunch
of
little
graphs
that
I'm
viewing
in
parallel
to
kind
of
compare
between
what's
expected
and
what's
existing,
and
here
you
can
see
oh
yeah.
This
is
just
like
a
huge
graph
with
like
lots
of
stuff
where
I'm
testing
deduplication,
but
you
can
see
how
each
level
in
the
dag
kind
of
gets
grouped
on
its
own
level.
So
here
we
have
the
root
of
the
mutant
xfs
file.
B
D
Visit
always
strictly
do
the
the
levels
so
that
anything
3D
will
always
appear
appear
in
that
third
column.
B
Yeah
so
I
mean,
if
someone
has
any
car
files
for
me
to
test
out
that
have
like
weird
connections
in
between
them.
That
would
be
great.
I
personally
have
like
very
organized
tree
ones,
but
when
you
have
deduplication
in
place,
that's
where
you
can
have
things
kind
of
like
pointing
to
each
other.
B
Another
thing
is,
you
might
have
multiple
Roots
inside
a
car
file,
all
of
the
ones.
I'm
testing
usually
have
a
single
root
with
a
bunch
of
data,
but
you
can
kind
of
see
how
the
deduplication
works
for
multiple
routes
will
point
to
the
same
content,
sometimes
yeah.
If
someone
even
has
like
an
ipfs
URL
for
me,
I
could
turn
that
into
a
car
file
on
the
fly,
but
maybe
this
could
be
a
good
time
for
me
to
segue
into
showing
off
how
the
CLI
works.
B
If
I
can
there,
it
is.
Is
this
legible,
yep
cool
so.
B
I
am
contemplating
post
publishing
just
binaries
for
the
different
platforms
on
the
GitHub
releases,
but
for
now
you
should
be
fine
with
just
setting
up
npm.
It's
not
that
hard
or
you
can
import
this
as
a
JavaScript
library,
so
to
run
stuff
straight
from
npm.
You
can
use
npm
and
use
dash
dash,
yes
to
Auto,
accept
installing
or
just
type
the
name
of
the
package.
B
So
the
package
is
called
car,
two
dots
and
if
I
run
it
with
no
arguments,
it
just
kind
of
sits
there
because
it
needs
some
sort
of
input.
So
what
I'm
going
to
do
is
use
cats
to
start
reading
this
tree
Dot
card
I'm
going
to
feed
it
into
npx
card
two
dots.
B
And
this
will
take
the
STD
in
car
file,
start
parsing,
it
out
parsing
out
the
blocks
in
it
and
then
start
spitting
out.
The
dots
file,
so
so,
what's
handy
here
is
that,
regardless
of
how
your
car
file
got
written
or
what
headers
do
and
don't
exist
in
it,
this
program
will
parse
it
on
the
Fly
using
streaming
data.
So
say
you
have
like
a
car
file.
That's
like
a
terabyte
in
size
or
something
horrific.
B
You
can
have
a
multi-terabyte
DOT
file
which
good
luck,
turning
that
into
an
SVG,
but
maybe
you'd
want
to.
But
this
means
it's
it's
pretty
faster.
When
this
this
is
like
I,
don't
know
what
the
command
line
arguments
were
forgetting
file
sizes,
but
it's
like
a
megabyte
so
from
there.
I
can
feed
that
into
the
dots
command
line,
tool,
utility
or
I
can
take
the
dot
file
directly.
So
here
I
fed
it
into
dots
and
it
generated
this
nice
SVG
I
can
save
it
to
a
file.
B
So
now,
if
I
go
back
to
my
screen,
share.
B
I
have
a
lot
of
stuff
open.
So
now,
if
I
go
back
to
my
screen,
share
I
can
just
like
paste
the
SVG
oh,
never
mind
it
can't
handle
that
much.
I,
don't
know.
Okay,
bye.
A
B
Cool
so
now
you
can
see
this
is
a
prolly
tree
with
like
a
huge
amount
of
data,
but
this
actually
has
named
links.
So
let
me
zoom
in
I
need
to
actually
send
it
there's
a
weird
thing
where
you
can't
zoom
in.
If
you
set
your
SVG
file
to
be
like
inside
the
body,
whereas
if
you
set
it
as
the
entire
HTML,
you
can
actually
zoom
in
properly
I.
Don't
know,
HTML
is
weird,
but
here
rather
than
using
the
weird
like
links
from
dagpd,
we
have
actual
names.
B
So
this
is
a
prolly
tree
and
that
uses
IPL
these
schemas
to
encode
everything
as
tuples.
So,
sadly,
you
don't
get
to
see
that
structure
very
well,
but
if
this
were
like
strings
or
some
sort
of
dag
Seaboard
data
with
like
human,
readable
values,
I
guess
see
it
there
yeah.
So
one
last
thing
I
wanted
to
do
is
just
kind
of
like
dig
into
the
code
of
how
car2
dot
Works,
because
I
think
it
could
be
useful
for
people
getting
into
jsipld.
B
So
one
of
the
things
with
JSI
pld
is
it's
kind
of
very
spread
out
right
now,
where
there's
a
bunch
of
old
code,
there's
a
bunch
of
new
code,
and
it
might
not
be
obvious
how
to
say:
go
from
the
multi-formats
repo
to
something
actually
usable.
B
B
So
one
thing
that
I
see
a
lot
which
we
really
need
to
have
the
library
for
that
standard,
but
don't
have
yet
is
to
have
some
sort
of
registry
for
codex
and
a
way
to
interact
with
them.
So
I,
usually
just
keep
keep
track
of
a
map
and
just
set
a
map
from
the
codec
code
that
you'd
see
in
a
CID
to
the
codec
itself
and
I
use
that
later
here,
where
I
actually
parse
out
data.
B
So
there's
a
library
called
ipld
car,
and
so
this
is
how
you
can
parse
out
car
files
and
it
has
a
handy
function
called
car
block
iterator,
where
you
can
feed
it
in
async.
Iterable
of
bytes
and
it
will
parse
it
as
blocks
on
the
Fly
and
it'll
it'll,
yield
ipld
blocks
for
you
to
actually
consume
in
your
application.
B
So
here
I'm
going
to
create
a
car
block
iterator
from
sddn
or
whatever
iterable
you
have
and
then
as
I
iterate
through
it
I
fetch
out
the
CID
and
the
bytes
from
the
block.
B
Then
I
check
whether
the
CID
is
using
a
codec
that
I
recognize
or
not,
and
then
I
parse
out
the
decoded
value
From,
the
Block,
using
the
codec
from
there
I
construct
an
actual
block
interface,
because
sometimes
you
want
to
Traverse
the
data
in
a
block
in
a
high
level
way
where
you
don't
have
to
actually
worry
about,
like
what
specific
data
type
it
is,
and
the
block
interface
gives
you
that,
in
the
form
of
the
links
method.
So
with
this
I
can
Traverse
any
arbitrary
block
and
yield
out
data
for
my
dot
file.
B
So
this
is
just
kind
of
like
a
useful
thing.
I
feel
like
some
folks,
don't
use
the
block
interface
to
actually
Traverse
data
inside
ipld,
and
this
is
just
like
a
small
reminder
that
they
probably
should
yeah,
but
the
entire
file
is
like
less
than
100
lines
of
code
and
the
ipld
stuff
is
maybe
like
a
few
dozen.
So
honestly,
you
might
want
to
just
copy
paste
this
for
yourself
in
your
own
projects.
B
If
you
want
to
render
out
more
custom
views
over
Docs,
so
we
do
have
some
basic
CLI
options,
namely
you
can
either
specify
the
direction
that
you
want
the
graph
to
be
rendered
in.
Sometimes
it's
easier
to
watch
to
read
it
when
it's
top
down
with
the
root
at
the
top
and
then
leaves
going
to
the
bottom.
B
B
You
can
do
I
added
a
default
style
because
I
think
it's
cool,
yeah
and
then
there's
just
a
JavaScript
interface
for
this,
where
you
can
import
the
car
to
dot
function
or
the
blocks,
iterator
two
dot
function,
and
then
you
can
just
pipe
it
into
readable
streams
or
async
iterators.
B
A
Things
I
think
it's
great
to
see
kind
of
like
a
small
example
on
how
to
put
all
those
like
commodity
formats,
codecs
whatever
into
something
useful,
because,
like
that's
really
the
hard
part
about
yeah,
currently
using
iPod,
so
I
think
yeah.
It's
a
it's
a
great
example
to
have
yeah.
D
I
can
say
this
lot,
you're,
adding
lots
of
features
over
time
and
it
becoming
and
less
useful
in
terms
of
pointing
people
to
it
going.
You
want
to
have
a
look
at
that
at
this,
like
one
page
of
code
of
how
to
put
it
all
together,
but
right
now,
that
page
is
actually
really
good,
because
we
do
have
people
showing
up
playing.
D
You
know
what
do
I
do
with
this
stuff,
to
being
able
to
point
to
active
examples
of
things
that
are
that
is
compact,
but
use
all
is
really
good.
B
Yeah
thanks
I
mean
honestly
I'm,
probably
not
going
to
be
adding
that
much
more
features-wise,
like
maybe
I'll,
add
some
sort
of
metadata
on
like
what
type
of
node
is
in
the
graph.
So,
like
maybe
say,
this
is
dags
Keyboard
Note
with
like
this
is
the
property
at
the
top,
but
this
is
mostly
just
for
traversing
links
inside
the
graph
just
to
see
how
the
blocks
link
together
so
I,
don't
think
it'll
get
too
complicated.
B
One
other
thing
that
I
think
is
useful
is
just
to
like
expose
people
to
the
idea
that
maybe
you
don't
need
all
of
like
an
ipfs
node
in
order
to
do
stuff.
That's
like
ipfs
related
because
car
files
and
some
codecs
and
like
just
reading
them
from
somewhere
can
get
you
actually
really
far
so
before
you
even
get
to
lib
P2P
or
like
Kubo
or
like
whatever
other
fancy
features.
You
want.
C
Do
you
have
any
mode
where,
like
that
deals
with
a
ruthless
cars,
because
that's
something
that
I
will
encounter
a
couple
of
times
which
makes
it
tricky
to
visualize?
Because
where
do
you
start
from.
B
Yeah,
so
that's
the
cool
cool
thing
here
because,
like
usually
people
think
of
reading
car
files,
so
like
just
for
a
context
for
anyone
watching
this,
it's
not
aware
car
files
usually
have
a
set
of
root
cids
in
their
header
or
footer.
One
of
those
where
this
kind
of
says
like
oh,
this
is
the
dags
that
we're
representing
here
and
services,
like
I,
think
web3
storage,
I
think
they
require
having
Roots
set
on
your
car
and
usually
that's
what's
used
to
Traverse
the
data
within
it.
B
However,
in
this
case,
since
I'm
just
iterating
over
the
blocks
in
the
car
file,
rather
than
traversing
the
dag
itself,
you
can
have
whatever
data
you
want
and
in
fact,
if
you
have
a
node,
that's
linking
to
a
block
that
isn't
in
the
car
file.
It
actually
doesn't
matter
because
the
node
will
just
get
represented
as
like
a
virtual
thing.
B
Just
do
due
to
the
way
dot
works,
so
you
can
have
as
many
or
as
few
routes
as
you
want.
It
doesn't
really
matter
because
it
just
looks
at
it
one
block
at
a
time
and
just
uses
the
links
function,
From
the
Block
interface,
to
get
a
list
of
edges.
D
B
Yeah,
exactly
graphis
is
a
super
useful
tool.
One
thing
I
also
want
to
experiment
with
is
other
formats.
That
graph
is
supports,
so
dot
is
really
used
for
more
hierarchical
data
or
like
float
diagrams
diagrams.
However,
graphis
also
supports
ways
where
it's
like
more
of
a
physics,
directed
thing
where
you
can
just
have
a
swarm
of
nodes
and
it
uses
physics-based
layouts
to
kind
of
like
position
them
in
space.
B
So
rather
than
like
a
top
down,
it's
just
like
a
inside
out
and
that
can
be
useful
for
finding
clusters
or
say
you
have
like
a
very
large
data
set
with
very
complex,
interlinked
data
between
it.
This
is
how
you
can
kind
of
visually
inspect
where
stuff
is
grouping
or
not
grouping,
but
that's
like
a
maybe
later
feature
that
that
might
be
like
a
separate
library,
because
I
think
graph
is
has
different
names
for
the
different
layout
engines.
D
So
I
I
talked
on
on
the
channel,
we'll
call
it
the
channel
called
it's
bridged
everywhere
about
Unix.
D
The
first
names
would
be
great
in
here,
because
the
majority
of
the
data
they're
going
to
be
putting
through
here
is
it's
gonna,
have
links,
slash
numbers
hash,
but
I
think
it
should
be
pretty
straightforward
to
just
you're
going
to
detect
whether
a
it's
dag
PB
and
it-
and
it
is
UNIX
at
this
and
then
B
for
each
of
the
those
links
just
replaced,
replace
it
with
a
name
but
then
I,
guess
I,
guess:
you'd
want
a
separate
mode,
then
like
Dash,
Dash,
ipfs
or
unixfs,
or
something
so
that
you
explicitly
opt
into
sort
of
obfuscating
the
ipld
nodes
with
with
names.
D
B
Yeah
I'm.
Actually,
this
might
also
be
part
of
the
implementation
of
the
block
interface
because
I'm
not
sure
whether
the
block
interface,
Handles
dagpb
in
any
sort
of
special
way
like
honestly,
Unix,
fs
and
dagpb
are
just
this
like
huge
elephant
in
the
room
whenever
anything
ipld
gets
mentioned
because,
like
just
today,
I
was
on
a
call
with
someone
and
they're
like
I'm,
so
confused
I'm
using
ipld
resolve.
B
D
Yeah
in
in
the
in
the
go
in
the
go
world
I'm
doing
a
lot
of
this
stuff.
It's
actually
solved.
C
B
Yeah
I
really
wish
there's
also
like
some
way
to
specify
lenses
or
ADLs
or
whatever
inside
the
car
inside
like
the
CID
or
the
block
metadata,
because,
for
example,
I
mentioned
that
probably
trees
example,
it
looks
horrible
because
it's
like
what
is
this
slash
zero
slash
one
like
what
does
that
mean.
D
You
could
potentially
do
that
if
you
smash
this,
the
if
you
take
the
daughter
on
this
and
this
gamer
and
you
smash
them
together
in
your
your
utility.
It
could
probably
make
sense
of
some
more
of
the
data,
so
you
take
the
the
tuples
and
turn
them
into
structs
and
you
can
give
them
names
and
things,
but
it
would
be
quite
a
bit
more
overhead
to
have
to
detect
where
you
are
and
what
you're.
Looking
at.
B
Yeah
so
yeah,
if
someone
desperately
needs
that
you
know
hit
me
up,
we
could
do
a
support
contract
for
this,
like
Enterprise
grade
utility.
D
D
Know
baffy
we're
ready,
Buffy
Bay
whatever
and
I
was
wondering.
If
was
that,
just
that
was
just
an
arbitrary
choice
or
do
you
mentally
identify
cids
from
the
left,
because
I
mentally
identify
them
from
the
right
and
look
at
the
last
bit
of
CID
when
I'm
trying
to
when
I'm
trying
to
remember
that's
the
ID
I.
Look
at
the
last
few
characters.
B
Yeah
I
mean
honestly,
it's
I,
I
think
from
both
sides,
because,
like
sometimes
depending
on,
where
I'm
scanning
from
so
I
like
to
have
both,
because
also
if
I,
only
do
on
one
side.
Sometimes
there's
like
collisions
and
I
get
confused
and
cry.
I.
B
But
yeah
I,
literally
just
like
looked
at
the
cids
I,
had
they
were
all
cidv1
so
for
CID,
b0
I
have
no
clue.
I
guess
this
will
make
the
formatting
super
confusing,
but
I
just
like
copied.
The
header
I
kept
seeing
I.
B
Yeah
I
I've
also
been
playing
around
with
Raw
cids,
more,
which
is
kind
of
fun,
because
then
you
can
just
like
read
the
data
in
the,
but
in
the
CID
itself,
if
you're,
if
you
like,
bash
your
brain
enough.
C
C
I
had
some
interesting
conversations
with
Fusion
team
and
we
kind
of
wanted
to
drive
some
effort
in
there,
but
I
think
nobody
actually
did
anything.
But
the
main
takeaway
for
me
was
that
using
these
inline
CID
is
really
messes
up
with
a
tree
because
Suddenly
It's
not
a
like.
It
really
prescribes
your
hashing
algorithm
now,
while
in
most
other
cases
it
doesn't,
and
it
would
be
nice
to
be
able
to
decouple
it.
C
B
Yeah,
so
in
the
web
recorder
custom,
chunking
stuff,
we
were
doing
we
actually
experimented
with
using
raw
blocks
inside
identity
cids
just
to
like
save
on
graph
traversal,
and
what
I
found
is
that
immediately
my
code
for
reading
from
a
car
file
like
broke,
because
it's
just
like
I
I,
don't
understand
what
the
hell
this
CID
is.
B
There's
no
data
cannot
read
like
undefined
of
whatever,
whatever
it
kind
of
puked
on
me.
So
I
had
to
add
this
like
extra
conditional,
where
it's
like,
if
the
codec
is
well
actually
the
codec
being
raw
doesn't
matter,
I
have
a
bug
more
more
of
this
being
confusing
but
yeah.
If
the
cid.multihash
dot
code
is
the
identity,
then
I
just
returned
the
Digest.
D
But
this
need
this
code
needs
to
be
in
every
every
layer
that
manages
blocks,
so
every
block
store
everything
that
the
where
blocks
flow
through
everybody
needs
this,
which
is
why,
which
is
why
they're
so
such
a
nightmare,
because
any
layer
that
skips
this
will
end
up
causing
you
problems,
because,
oh
I
don't
have
that
block?
Yes,
you
do
I
just
gave
it
to
you.
That's
the
situation.
D
I'm
asking
you
for
a
Blog
and
I
actually
give
you
the
block
to
give
me
back,
and
you
say:
I
can't
find
that
block
so
yeah
yeah,
but
as
long
as
you
handle
them
properly
and
the
thing
about
the
the
cards
is
that
they
don't
need
to
appear
in
the
cars.
So
if
you
ever
do,
if
you're
ever
creating
this,
you
don't
need
to
put
the
identity
Securities
as
a
separate
entity
in
the
car,
because
they're
already
in
the
block
that
they
are
referred
from
and
unfortunately
there's
no
that's
not
enforced
anywhere.
D
So
they're
already
they're
already
in
the
block.
That's
referring
to
them
because
by
referring
to
an
identity
CID
you
are
including
the
data
so
yeah,
just
it's
like
a
skip
within
the
block,
and
so
you
don't
need
it.
It's
it's
there
and
any
any
Block
store
that
that
you
go
and
ask
for
that.
Blog
should
be
able
to
say
to
you
here.
It
is
here's
what
you
asked
for.
You
gave
it
to
me
so
yeah
car
student
is
wasteful
and
it
makes
code
like
this
unnecessary
yeah.
B
Yeah
yeah
like
it's,
it
seems
just
like
anywhere
where
there's
a
block
store,
it
needs
to
handle
identity,
cids
and
everything
that
is
a
reader
of
block
should
have
like
a
block
store.
Spec
I
think
this
is
just
a
case
where
it's
like.
Oh
we're,
a
car
reader,
we're
not
a
block
store.
Someone
else
will
deal
with
that
at
the
Block
store
level,
which
I
guess
yeah
I,
don't
know,
I'm
glad
you've
complained
about
this
before
and
that's
why
it
was
easier
for
me
to
debug
this
when
it
happens.
So
thank
you.
D
That's
been
a
lot
of
the
last
year
doing
this
in
ball
coin,
so
just
just
basic
file
coin
stuff,
where
it
turns
out
that
we
weren't
handling
identity
ideas
properly,
and
so
all
these
bugs
kept
on
appearing
of
people
can
retrieve
data
people.
People
were
getting
mismatched
commitment,
cids
all
because
of
identity,
and
they
just
create
such
subtle
bugs
so
I'm,
not
a
fan.
D
And-
and
the
paint
is
I
also
did
last
year,
I
also
did
some
work
on
what
the
the
break-even
point
for
identity
IDs.
If
you
so
a
lot,
a
lot
of
the
use
for
identity
studies
is
I,
want
to
save
space
and
there's
a
break-even
point
depending
on
how
you're,
you're,
storing
or
transporting
them,
and
so
there's
a
hover
graph
somewhere
on
GitHub
of
like
cars
with
and
without
virginity
cids,
and
where
you,
where
the
trade-off
is,
and
it's
pretty
short
and
identity.
D
Ids,
don't
need
to
be
very
long
for
them
to
become
pointless
in
terms
of
space
saving
space.
C
C
B
B
B
D
B
D
If
they
make
it
like
no
I
mean
it's,
it
is
like
there's
the
certain
certain
amount
of
fun
in
having
to
handle
this
weird
Edge
case
that
has
legitimate
uses
like
it's
not
like.
This
is
you
know
hacker
stuff,
but
it
has
legitimate
uses,
but
you
have
to
handle
it.
Everybody
has
to
handle
it
properly
for
everything
to
work
nicely,
and
so,
when.
D
When
it's
all
working
it,
then
it
works
great,
but
it
also
creates
sort
of
these
cognitive
I
find
it
creates
cognitive
barriers,
especially
when
you're
trying
to
explain
it
to
people.
So
it's
hard
enough.
C
So
in
our
code
base
you
have
a
like
dog.js
module,
which
basically
does
a
creating
stuff
and
decoding
mostly
for
you,
and
that's
for
this
kind
of
little
sneaker.
If
we
have
there.
So
if
it's
identity
blocks
and
it
kind
of
does
a
shortcut
for
you
and
that
kind
of
removed
all
of
the
edge
cases
for
us,
because
everything
goes
through
that
dark,
Jazz
and
then
kind
of
deals
with
it.
D
B
Yeah
thanks
I
mean
thanks
for
everyone,
making
this
code
usable,
it's
pretty
good,
it
gets
the
job
done.
Folks
should
look
at
it.
A
Cool
yeah
thanks
I've
seen
that
Rod
has
a
few
updates
so
or
does
anyone
else
want
to
chat
about
other
things
before
we
get
into
news
from
the
core
development.
C
B
Yeah
sure
I
can
get
into
it
briefly,
so
the
tltr
is
I'm,
actually
not
using
the
chunker
interface
at
all,
because
it
just
is
not
flexible
enough
for
our
use
case.
What
I'm
doing
is
I'm
instead
using
the
what's
it
called
ipfs
unixfs
module
for
encoding,
Unix
FS
blocks
manually
and
the
ipfs
car
module
for
encoding
it
into
car
files
and
the
ipld
unixfs
module
for
creating
writers
or
Unix
FS
data.
B
So
the
web
recorder
use
case
is
like
kind
of
subtle
where
we
have
the
this
file
format
called
Web
archives.work
effectively
it's
a
zip
file
which
contains
sorry.
We
have
the
waxy
file
format,
the
web
archive
zip
file
format.
It
contains
a
work
file
which
is
a
bunch
of
HTTP
request
response
pairs
in
an
append
only
file
which
contains
like
the
archive
of
web
crawl
and
then
alongside
it,
there's
some
indexes
and
some
extra
metadata.
B
B
We
take
each
request,
response
pair
and
turn
it
into
its
own
Unix
FS
node,
where
we
can
use
this
to
Like
Remix
work
files
by
just
zipping
these
pairs,
in
whatever
order
we
want
or
like
adding
and
removing
them
between
archives
and
then
for
the
response
portion.
In
particular,
we
find
the
boundary
where
the
response
metadata
starts
and
ends,
and
we
take
that
chunk
of
bytes
and
we
feed
it
into
the
default
Unix
FS
chunking
algorithm.
B
So
this
ipld
unixfs
library
has
this
create
file
writer
method
and
that
takes
the
usual
like
chunker
options,
so
we're
just
using
whatever
the
default
is
in
ipfs
Unix
FS,
but
you
can
customize
it
so
it
aligns
with
Kubo
or
whatever
else.
But
the
idea
is
that
that
response
body,
if
there
is
any
other
response
that
has
those
same
bytes
they'll,
be
chunked
as
though
someone
uploaded
the
file
to
ipfs
so
say
it's
like
JavaScript
assets
or
images,
or
what
have
you
it?
B
It
means
that
we
can
have
very
aggressive
deduplication
of
content
between
everything.
So,
as
I
mentioned,
we're
not
using
the
custom
chunker
for
this
we're
using
just
like
pretty
close
to
the
metal
Unix
FS,
where
I'm
literally
just
assembling
Unix
FS
nodes
in
memory
and
then
writing
them
as
blocks
to
the
car
file
yeah.
So
I
I,
don't
know
if
that's
like
similar
to
your
use
case,
but
I
found
that
that's
way
easier
to
do
than
having
to
like
use
higher
level
level.
Libraries
like
the
chunker
interface.
C
B
B
I
I
think
the
chunker
is
great
for
when
you
have
just
like
a
file
you
want
to
have
into
like
even
chunks
or
whatever,
but
like
very
content.
Specific
stuff
I
found
it's
a
lot
easier
to
kind
of
as
you're
parsing.
Your
data
just
send
those
bytes
into
this
car
writer
using
like
regular
Unix
FS
writing
utilities.
A
D
B
C
B
Yeah
we're
doing
like
dark
magic
with
Unix
FS.
This
is
like
probably
folks
for
not
imagining
this,
because
the
other
thing
just
to
find
me,
that's
really
cool
here
is
the
entire
thing
is
just
one
unixfs
file
node
and
the
way
file
reading
works.
It
just
kind
of
like
automatically
gets
zipped
up
on
the
fly
as
you're
loading
data
and,
what's
more
one
of
our
apps
archive
web.page.
What
it
does
is
in
addition
to
taking
those
ZIP
entries
and
turning
them
into
a
ipfs
file
node.
B
D
B
B
It's
it's
pretty
hardcore,
but
it's
it's
not
super
hard
to
do
if
you
struggle
for
a
long
time
yeah.
So
if
folks
are
curious,
our
spec
is
published
on
GitHub.
This
is
actually
being
done
through
Grant
from
Falcon
Foundation.
D
C
Well,
my
mostly
my
interest
was
like,
if
there's
anything
about
IPL
unique
stuff
has
that
needs
to
be
improved,
to
make
base
easier,
I'd
love
to
do
that.
It's
kind
of
it's.
B
C
Yeah
because
it
has
under
the
hood
since
it's
building
the
Unix
surface
itself,
yeah.
C
D
It's
really
nice
to
stop
using
old
stuff
and
these
new
stuff,
so
I
I
want
to
segue
straight
into
something
that
I
at
least
one
of
the
things
I
had
on
my
list,
which
is
so
with
the
work
that
I'm
doing
on
data
retrieval
part
of
that
was
messing
with
unixfs,
because
we
do
a
lot
of
Unix
past
retrieval
and
so
one
of
the
things
I
did
a
while
ago
and
I
improved
recently
to
make
it
publicly
available.
D
It's
Munich
Fest
file
and
directory
test
data
generation
utilities,
and
so
I
put
them
in
they're
in
go,
but
it's
the
in
the
go.
If
you
go
to
the
GitHub
ipfs
org
slash,
go
Unix,
FS,
node,
there's
a
new
package
in
there
called
test
data
and
it
will
generate
for
you
all
the
variations
of
Unix
FS
trees
in
you
know
in
IPL
live
blocks,
so
you
can
ask
for
just
single
files.
You
can
ask
for
sharded
files,
you
can
have
directories.
D
Sharda
directories
and
it'll
it'll
it'll
create
these
synthetic
directory
trees
that
have
realistic
names
and
files
that
have
realistic
names
and
they
can
be
really
deep
and
then
you
can
do
stuff
with
them
like,
like
graphing
it'd.
Be
great.
I
actually
was
thinking
about
some
of
this
data
because
some
of
it's
really
deep
it'd
be
great
to
stick
them
in
the
graphing
tool
and
and
and
have
those
Unix.
The
first
names
come
through
so
like
one
of
the
reasons
things
I
did
was
actually
make
them
is.
D
Do
the
realistic
naming
thing
I
have
a
library
of
words
that
it
picks
from,
and
you
know
so
anyway,
so
that's
I
I,
think
that
could
be
relevant
here
for
anyone.
That's
messing
around
the
unixfs
I
found
it
really
helpful
in
order
to
test
some
of
the
edges
of
interpreting
your
xfs
graphs
and
doing
the
ADL
stuff
that
we're
doing
to
Traverse
them.
A
Thanks
yeah,
so
we
are
almost
at
the
hours,
so
I
guess,
if
there's
nothing
else,
urgent
I
will
close
the
meeting
and
say
that
the
next
meeting
is
in
four
weeks,
which
is
then
a
June
19th
and
yeah,
and
as
always,
so,
if
you
wanna
so
also
like,
if
people
are
watching
this
and
also
want
to
talk
about
things
or
present
things,
then
please
yeah
reach
out
to
us.
We
are
on
the
so
there
is
an
iPhone
channel
in
select
this
chord
and
Matrix
and
yeah
or
yeah.
A
So
you
will
find
us
and
then
yeah
reach
out
to
us
and
we
are
happy
to
have
other
people
present
and
yeah
all
right.
So
and
it's
every
time
we
still
at
least
one
minute.
We
have
an
after
party.
So
if
you
have
something
to
share,
I
want
to
say,
but
not
publicly
screened,
so
just
stay
on,
I
will
stop
the
live
stream,
and
then
we
hang
out
for
a
bit.
If
there's
anything
else
and
then
yeah
all
right
so
see
you
all
in
four
weeks.