►
From YouTube: 🖧 IPLD Every-two-weeks Sync 🙌🏽 2023-02-27
Description
An every two 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
B
Welcome
everyone
to
this
week's
ipld
syncing
community
meeting
and
as
every
two
weeks
we
go
over
the
stuff
that
people
have
worked
on,
but
also
discuss
any
open
engine
items.
People
might
have
or
questions
or
project
they
work
on
and
so
on.
So
we
need
to
go
to
the
notes,
but
I
don't
have
any
updates.
Therefore,
it's
probably
Rod's
turn
if.
C
C
The
only
notable
thing
I
think
since
last
time
is
go
ability,
Prime
had
a
zero
twenty
zero,
zero,
twenty
Zero
release
and
it-
and
it's
it's
not
huge,
but
it's
got
some.
It's
got
a
lot
of
little
roll-up
fixes
and
a
couple
of
editions
so
mostly
won't
be
felt
by
people,
but
it's
a
good
upgrade
to
do.
That's
that's
about
it
for
me.
C
Otherwise,
I've
been
doing
plenty
of
stuff
around
I'm,
actually
deep
in
selectors
at
the
moment,
having
some
doing
some
really
interesting
stuff
with
with
with
ibrd
selectors,
which
is
exposing
some
issues
which
is
good.
C
So
if
the
current
selectors,
but
really
novel
versions
of
them,
so
right
now,
there's
an
effort
to
if
folks,
listening
and
not
tuned
in
this
might
be
interesting
or
might
not
be,
but
there's
an
effort
to
replace
some
of
the
IPL
ipfs.io
Gateway
traffic
with
and
actually
over
time.
C
C
How
do
they
get
fetched
and
so
we're
fetching
data
from
both
bit
swap
the
classic
ipfs
client
nodes,
but
also
farcoin
storage
providers,
so
so
we're
doing
both
at
the
same
time
trying
to
get
the
data
wherever
it's
possible
and
that
we're
we're
building
a
retrieval
client
that
does
these
things
and
will
retrieve
a
CID
and
a
path
into
a
car.
So
you
get
so
you
can
run
the
thing
separately
and
you
just
you
just
retrieve
and
you
get
a
car.
C
So
it's
like
it's
a
little
bit
like
using
ipfs
or
Kubo
and
using
ibfs
dag
export,
but
it
also
fetches
from
SPS,
and
it
doesn't
do
all
the
rest
of
the
stuff
that
Kubo
does
it's
just
purely
retrieval.
So
the
the
interesting
challenge
at
the
moment
is
I'm
doing
the
pathing
bit,
which
is
and
there's
two
separate
modes
that
we're
building
into
it,
which
is
because,
right
now
we
can.
We
can
fetch
a
whole,
a
dag
from
a
CID.
Give
us
a
CID
we'll
get
you
all
of
it.
C
But
sometimes
people
request
big
CID,
big
graphs
like
Wikipedia,
you
don't
want
all
of
Wikipedia.
Usually
so
what
we're
going
to
do?
Is
you
get
your
CID
and
then
a
path
to
some
resource
and
then
the
two
modes?
Are
we
want
to
give
you
everything
under
that
path
which
is
common?
C
If
you're
after
a
like
you're
after
a
web
page
on
on
ipfs,
then
you
want
all
the
resources
that
are
page
links
to
or
and
the
other
mode
is
shallow,
where
it's
a
path
to
a
a
block,
and
you
just
want
that
block.
But
the
tricky
thing
is
when
Unix
FS
gets
involved,
because
when
you
want
so
there's
two
reasons
why
Unix
first
makes
it
tricky.
C
First
of
all,
is
pathing,
so
pathing
in
Unix
first
is
different
to
passing
in
just
pure
ipld,
so
we're
taking
the
approach
like
Kubo
does
that
you
want
Unix
the
first
pathing
if
they're
Unix
FS
blocks,
so
we're
doing
that.
So,
if,
if
it
finds
you
in
xfs
data
it'll
pass
it
according
to
Unix
for
semantics.
That's
fine!
Then,
when
it
gets
to
the
end,
what
does
it
do
because
unixfest
has
a
couple
of
problems?
One
of
these
files
can
be
shattered
across
many
blocks.
C
So
if
you
want
a
path
to
a
file,
you
probably
want
the
whole
file,
which
includes
a
lot
of
blocks.
So
if
you
do
a
Shell,
let's
call
it
shallow
and-
and
you
go
so
that's
why
I'm
calling
anyway
shallow.
So
you
want
path
and
I
want
a
shallow
effect
and
I
want
you
to
go
more
than
that
path.
I
just
want
the
thing
that
the
path
goes
to,
but
if
the
path
just
goes
to
a
file,
you
want
the
whole
file.
C
Regardless
of
whether
you
said
shallow
or
not
so,
and
then
the
other
problem
is
directories,
so
if
you
go,
if
you
just
want
to
do
an
LS
Unix
FS
LS,
but
then
you
get
to
a
Unix
first
directory
that
is
sharded
across
many
blocks.
You
need
all
the
blocks
to
be
able
to
do
any
less.
C
So
get
me
get
me
all
the
blocks
from
the
root
crd
down
the
path
because
I
want
to
be
able
to
I
want
to
be
able
to
have
a
a
verifiable
fetch,
so
I
can
verify
my
cids
from
the
one
I
requested
all
the
way
down
the
path,
then
the
full,
dag
or
the
path
all
the
way
down,
and
then
just
the
resources
that
make
up
the
final
thing.
So
so
what
we
do?
What
we
do
is
we
we
build.
C
We
turn
that
into
a
selector,
but
then
you
have
to
do
these
things
with
selectors
to
do
with
Unix
first,
so
you
have
to
invoke
this
thing.
That
was
built
into
selectors
one
of
the
LA
one
of
the
latest
features
that
was
added
to
selectors
in
go
anyway.
Is
this
interpret
ads,
so
you
can
tell
a
selector
at
each
point
to
interpret
this
block
as
a
an
ADL.
So
what
we
can
do
is
say,
and
during
the
past
steps
each
step
I
want
you
to
interpret
this
step
as
unixfs.
C
So
when
it
goes,
you
know
slash
Foo.
Instead
of
doing
it
as
the
sort
of
the
dag
PB
block
semantics
like
going
down
into
the
ipld
pathing
it'll,
say:
oh
well,
I'm
going
to
load
this
block
and
assume
it's
unixfs
and
then
go
slash
Foo
in
the
Unix
of
his
path,
so
that
works
but
then
the
other.
The
other
problem
is
when
you
get
to
the
end,
you
either
want
to
get
everything
which
is
easy.
Like
it's
easy,
when
you,
when
you
get
to
a
final
point,
you
want
to
get
everything,
that's
an
easy
selector!
C
The
first
selectors,
where
what
we've
called
Unix
Fest
preload,
which
is
when
I
get
to
a
directory
I,
want
you
to
get
all
the
blocks
of
that
directory,
and
so
what
we
do
is
we
say
we
interpret
the
final
thing
as
Unix
FS
give
me
just
that
thing,
and
no
more
so
it
has
to
when
it
gets
to
that
it
has
to
either
read
the
whole
file
and
find
the
blocks
for
it,
or
it
has
to
read
the
whole
directory
and
find
the
blocks
for
that.
But
don't
follow
the
directory
links.
C
So
this
mostly
works.
It
says
selectors,
but
there's
a
yesterday.
I
was
stumbling
over
a
a
bargain
graph.
Sync
that
was
not
doing
the
interpreters
properly,
but
you
know
we're
sort
of
shaking
out
the
bugs
of
this
by
doing
particularly
Advanced
selectors,
compared
to
most
of
the
selectors
that
are
done
around
the
place.
So
yeah,
that's
what
I'm
up
to
interesting
work
and
yeah.
It's
just
a
shame
that
it's
all
it's
only
go.
C
There's
there's
not
really
mature
stuff
in
the
other
languages.
There
is
some
there's
some
selected
work
in
JavaScript,
but
yeah.
It's
mostly
mature
and
go.
C
Yeah
yeah,
that's
that's!
What
I
keep
on
saying
is:
is
the
primary
two
modes
of
traversal
in
IPL,
the
single
block
or
everything,
but
there
is
this
gray
area
in
between
where
things
get
really
subtle
and
and
that's
what
we're
dealing
with
right
now,
because
we
we
want
to
be
able
to
fetch
efficiently
and
for
the
Gateway.
C
You
have
to
make
assumptions
about
what
people
want
and
what
people
are
going
to
want.
Next,
that's
the
other
thing
is
you
can
make
fairly
safe
assumptions
that
people,
if
somebody
shows
up
for
because
we're
dealing
with
it,
often
HTTP
clients,
so
they
want
an
index.html
they're,
probably
going
to
want
all
the
resources
associated
with
that.
So
there's
all
this,
this
weird
behavior
that
you've
got
to
take
into
account.
So
if,
if
we
can
get
selectors
in
there
to
make
some
smart
decisions
up
front
and
the
other
thing
we're
doing
is
we're
populating
a
cache.
C
So
that's
why?
What
what
we're
doing
is
when
somebody
shows
up
to
the
Gateway
and
they
say
I-
want
this
resource,
we'll
get
them
that
Resource
as
quick
as
possible,
but
at
the
same
time
we're
going
to
populate
a
large
cache
of
all
these
low.
All
these
nodes
in
the
make
up
a
Saturn
Network
we're
going
to
populate
the
cash
with
with
stuff,
that's
likely
to
be
fetched
next,
but
not
too
much
stuff.
C
So
that's!
That's
a
that's
a
bit
of
a
tricky
problem,
but
that's
sort
of
what
we're
doing
so.
C
A
an
interesting
version
of
that
is
range
requests,
because,
surprisingly,
videos
are
something
that
people
what
You
Know
download
a
lot
on
ipfs.
So
you
want
the
gateway
to
be
able
to
handle
video
plays
and
video
does
a
lot
of
range
requests.
So
the
Gateway
will
get
a
request
for
a
CID
and
a
path,
but
then
a
range
of
bytes
within
that
and-
and
surprisingly,
we
can
actually
use
selectors
to
do
that
as
well.
So
we
can
do
Unix
office
interpret
the
file
as
Unix
FS.
C
So
it's
a
sharded
file
across
many
blocks,
but
I
only
want
this
range
of
bytes
and
you
can
actually
do
that
with
with
selected,
but
it's
a
tricky
one
and
and
then
the
question
is:
do
we
just
fetch
those
bytes
for
them
those
blocks,
or
do
we
populate
the
whole
cache
with
the
video
that
they're
looking
at
so
that
when
they
want
the
next
bit,
it's
it's
ready
to
go
so
they're.
The
interesting
challenges
we're
dealing
with
at
the
moment.
B
I
guess,
if
you
need
to
get
the
the
buy
Offset,
you
probably
need
to
know
that
chunking
size
right
and
you
don't
really
know
I
mean,
can
probably
get
the
first
block
and
look
how
big
the
chunk
is
and
then
expect
the
chance
to
be
the
same
size.
The
rest.
B
C
So
this
is
unfortunately
with
unfortunately
as
well.
Tea
size
in
the
dag
PB
does
come
in
handy
here
where,
if
you've
got
a
sharded
file,
you
can
use
t-size
to
to
figure
out
where
the
block.
B
C
C
Whose
problems
you're
allowed
to
use
it
they're
allowed
to
lie:
yes,
that's
right,
yeah
and
it,
but
and
if
they
lie
okay,
you're
doing
a
range
request
and
you
get
the
wrong
bite
to
the
file
whose
problem
is
that?
Ultimately,
it's
interesting
to
think
about
user
Behavior
here,
because
if
I
produce
bad
video
content
and
then
somebody
does
trusty
range
requests
on
my
video
files
and
it
fails,
are
they
going
to
like
diamond
technology
or
the
person
that
produced
it?
C
Hey,
that's
an
interesting
question
because
I
mean
sometimes
the
answer
is
either
but
just
produce.
Good
content
is
the
answer.
B
Cool
has
anyone
anything
else
to
discuss
or
to
chat
about,
or
questions.
A
A
I
can
imagine
you
have
something
that
is
a
chain
going
back
to
the
beginning
of
time
and
then
there's
a
bunch
of
thing
transactions
hanging
off
the
chain
or
something
and
you
might
want
to
have
requests
that
say:
oh
go,
get
me
the
entire
chain,
but
not
necessarily
go
get
me
everything.
That's
hanging
off
of
every
Merkle
tree,
that's
hanging
off
of
the
chain.
A
In
terms,
are
there
any
way
to
distinguish
the
kinds
of
links
that
are
in
your
blocks
to
be
like?
These
are
the
kinds
of
links
to
go
follow,
and
these
are
the
kinds
of
links
not
to.
C
Yes,
in
fact,
this
is
a
there's.
The.
C
Get
me
the
previous,
the
old
workers
infinitely
there's
some
really
interesting
integration
tests,
or
maybe
the
unit
tests
in
in
the
graph
sync
code
base
that
actually
models,
there's
a
whole
test,
fixture
setup
thing
that
will
Model
A
A
blockchain,
like
structure,
so
you've
got
the
backbone
of
parent
links
and
then
you've
got
things
hanging
off
them
and
there
are
tests
in
there
that
test
the
ability
to
just
fetch
those
the
parent
links
versus
going
down
and
the
way
you
do
this
with
selectors
is
just
by
Fields.
C
So
you
say,
navigating
to
this
block
and
I
want
you
to
explore
these
fields
either
by
name
or
by
the
index,
if
they're
an
array,
and
so
typically
with
a
blockchain
structure,
you
will
have
a
a
field
that
says
this
is
parent
or
root
or
whatever
it's
called
that
links
to
the
previous
block.
So
you
can
actually
the
selected
language
has
the
ability
to
say
only
explore
further
on
this
name
link
and
that's
the
pattern
that
is
used
there.
C
C
A
C
I'd
love
to
get
you
a
link
for
it,
but
because
I
was
actually
writing
some
tests
using
just
this
the
other
day,
but
I
was
using
selectors
to
do
a
limit
of
only
go
back
because
you
can
do
other
things
like
I
only
want
the
last
five
blocks.
C
So
that's
another
thing
you
can
do
with
selectors
I
want
you
to
follow
parent
links,
but
only
five
deep,
so
that
I'll
just
rank
some
tests.
That
did
that
just
to
make
sure
I
could
control
depth
in
the
stuff.
I
was
working
on.
A
A
Yeah
I
might
want
to
go
back
five
blocks.
I
might
want
to
say
well,
I
know
that
this
hash
was
one
of
the
blocks
in
the
chain,
so
file
the
chain
back
until
you
get
to
the
beginning
of
the
world
or
sometimes
which
in
theory
bit
swap,
would
notice
and
stop
syncing
once
it
got
to
blocks
I
already
had
anyway,
they
would
all
be
in
the
local
store,
yeah.
C
So
there's
one
of
one
of
the
limitations
of
interesting
limitations
of
of
selectors
is
selectors
were
written
to
be
to
treat
blocks
as
just
a
thing
that,
like
this
transparent
thing,
so
it's
the
selectors
are
written
to
in
this
sort
of
you
know
thousand
foot
view
of
graphs
where
graph
is
just
made
up
of
nodes
of
things.
C
You
know
arrays
and
maps
and
and
and
selectors
are
designed
to
go
through
those
things
and
then
just
jump
over
links
transparently,
so,
which
is
an
mostly
good,
but
then
you're
going
to
see
these
problems
of
you,
where
the
block
boundaries
become
critical.
For
your
logic,
you
say
I
want,
because
what
one
thing
you
can't
do
with
selectors
right
now,
which
is
really
frustrating,
is
I,
want
to
I
want
to
only
fetch
a
dag.
That
is
three
blocks
deep
at
maximum.
You
can
say:
I
want
three
nodes
deep,
but
a
block
might
a
block.
C
C
But
there
is
a
there
is
a
feature
in
selectors
called
stop
at
where
you
can
set
a
stop
condition
so
keep
on
going
until
you
find
this
condition
is
true,
and
that
might
be
like
this
field
is
something
but
but
this
CID
is
not
I,
don't
think
that's
one
of
the
stop-out
conditions
I
can
imagine
it
could
be,
though
you
could
like
go
until
you
find
this
link
that
matches
this
CID,
that
that
could
be
something
that
could
be
built
into
it.
C
But
we
are
at
a
point
where
selectors
are
not
selectors
are
heavily
used,
but
it's
mainly
this
get
me
all
or
get
me
apart.
You
know
it's,
it's
not
these
really
Advanced
uses
so
Yeah.
The.
B
B
Yeah
like
when
I
worked
on
them,
like
my
goal,
was
to
be
able
to
Traverse
through
Unix
FS
kind
of
with
the
selector,
so
that
you
don't
need
an
ADL
which,
like
like
this
kind
of
works,
but
only
if
you
don't
use
hands.
Obviously,
because
then
you
like
you're,
lost,
because
you
don't
know
up
front
how
to
Traverse
them.
So.
C
B
Powerful
enough
to
kind
of
be
able
to
Traverse
something
like
during
yourself,
for
instance,
was
kind
of
me.
My
idea,
but
yeah.
C
C
What
I'd
really
like
to
do
is
be
able
to
stack
anything
else.
I
would
like
to
say
interpret
it
first
as
this
and
then,
as
this
that's
a
little
bit
tricky
at
the
moment,
but
also
we
don't
have
concrete
use
cases,
although
I'm
I'm
tinkering
with
a
use
case
for
that,
but
not
for
me
to
use.
B
All
right
any
other
questions.
B
As
always,
we
have
an
after
party
for
things
that
people
don't
always
be
discussed
publicly
publicly
or
streamed
on
YouTube,
so
feel
free
to
hang
out
but
yeah.
That's
it
then,
for
the.