►
From YouTube: 🖧 IPLD Every-two-weeks Sync 🙌🏽 2022-05-24
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
A
It's
may
the
23rd
2022
and
as
every
two
weeks
we
talked
about
it
leavings
and
go
over
the
stuff
that
we
have
worked
on
and
then
discuss
any
open
gender
items
there
might
be.
A
B
On
my
side,
I've
been
working
on
some
of
the
wasm
ipld
things
when,
when
I
can
I've
added
support
for
directories
using
like
the
bittorrent
b1
directory
as
an
example,
because
it's
like
it's
just
a
little
bit
miserable
like
it's,
not
super
easy,
but
but
not
as
miserable
as
as
it
might
be.
If
you
were
doing
some
of
like
you
know,
the
bitcoin,
stuff
and
yeah
seems
to
work.
So
this
gives
us
like
recursive.
So
we
have
large
bytes
and
we
have
large
directories.
B
A
Thanks
next
on,
my
list
is
tau
xing.
I
hope
I
said
the
name
correctly.
C
Okay,
because
I'm
from
kinabs
teams
kind
of
teams-
we
have
studied
the
poetry
for
for
the
past
month
and
we
have
a
discussion
meeting
with
move
for
iprd,
trunkity
and
ipfd
poetry,
even
that
we
have
studied
this
poetry
last
year.
But
but
now
we
are
studying
the
politics
again
and
we
wanted
to.
C
Or
indexing
for
the
ipld
data
structures
and
we
have
studied
the
learning,
hashi
and
and
the
re
and
the
opportunity,
the
staffs,
and
we
want
to
find
a
solution
on
how
to
build
indexing
on
the
iprd,
and
we
also
need
help
and
the
need
advice,
supervision
on
how
to
proceed
on
the
iprd
indexing.
For
example,
we
can
build
the
iprd
specification
based
on
poetry
from
scratch
and
all
we
can.
C
C
D
A
A
A
E
Okay,
so
a
bunch
of
things,
the
the
high
the
main
highlight
is
this:
first
one
which
is
pull
request,
number
four
one
four
and
go
out
build
prime,
and
it's
a
custom
typing
thing.
So
the
the
challenge
with
bind
node
that
we
keep
on
bumping
into
is
the
it's
a
it's
a
fairly
typical
golang,
martial
and
marshall
problem
of
you.
You,
you
have
a
basic
type
that
you
wanted
martial
and
unmarshall,
but
it's
not
the
type
that
you
want
to
use
internally.
E
It's
it's
it's
something
it
that's
specific
for
marshalling
and
unmarshalling,
and
so
you
end
up
with
these
multiple
layers
of
data
structures
to
get
to
what
you
want,
and
it's
particularly
chronic
inside
some
of
these
more
nested
data
structures.
Where
you
you
can't
like
something
down
very
deep
in
the
data
structure,
is
the
piece
that
you
can't.
You
can't
use
the
native
the
the
by
node
thing.
E
For
so
you
have
to
then
rewrite
the
whole
data
structure
and
then
have
a
whole
mapping
thing
that
that
deeply
nests
it
all
it
copies
it
back
and
forth
and
that's
kind
of
frustrating
and
it
just
makes
the
api.
E
You
know
it's
it's
nice
to
be
using,
go
types
and
not
have
to
have
the
the
node
interface
will
do
the
code
chain,
all
that
sort
of
stuff,
but
it's
it
ends
up
being
very
verbose
in
having
to
use
it,
and
so
you
end
up
having
to
have
this
separate
little
package
to
do
your
conversions
anyway.
So
this
this
first
pull
request
here.
The
414.
E
There
was
two
pull
requests,
that's
merged
into
one
now,
but
the
idea
behind
this
is
that
you
can
define
custom
type
converters
for
for
specific
types
within
your
bind.
Node
usage.
So
then
the
intention
is
that
you
would
do
that
for
types
that
don't
naturally
that
do
something
a
little
bit
extra
above
the
sort
of
the
base
data
based
data
type.
So
when,
when
you're
looking
at
something
like
the
classic
one
is
a
byte
slice.
E
So
when
you're
you
have
some
bytes
and
you
want
to
convert
to
a
a
big
int,
that's
not
something
that
bind
mode
can
do
by
itself,
because
it
doesn't
know
how
you
want
to
do
the
beginning.
Conversion
there's
multiple
ways
to
do
it
and
in
fact,
far
coin
has
multiple
ways
of
doing
big
conversions,
and
so
you
would
define
a
converter
that
says
this
is
how
this
is
a
function
that
says
that
that
when
you
give
it
bytes
will
give
you
the
thing
that
I
want
and
then
the
reverse.
E
When
you
give
me
the
thing
that
that
I'm
converting
from
I'll
give
you
bytes
and
when
you've
got
those
two
functions,
you
can
register
it
as
a
type
and
then,
whenever
by
node,
encounters
that
type
it'll
invoke
your
little
converter
function
and
then
that
also
works
now
for
for
any
so
in
in
by
node.
When
you,
when
you
encounter
an
any
it,
it
gives
you
the
whole
data
model
node
with
whatever's
hanging
off
it
like
it
could
be
as
large
or
as
complex
as
as
it
need
be.
E
But
you
can
do
the
same
thing
now
for
any.
So
you
can
use
this
to
wrap
all
sorts
of
custom
things
behind
in
any
behind
a
data
model
node,
which
is
useful
for
a
couple
of
awkward
bits
in
the
way
that
seaboard
gen
is
currently
used
inside
filecoin.
E
So
anyway,
long
story
short
is
that
this
gets
us
really
close
to
being
almost
sea
board
gen
compatible.
There's
there's
only
one
little
awkward
area
that
makes
it
difficult,
but
the
any
conversion
makes
that
so
that
the
change
is
minimal.
So
what
you
can
do-
and
I've
got
in
that
second
pull
request
on
go
fill
markets
to
demonstrate
the
use
is
to
when
you're
doing
a
conversion
from
sibo
gen
to
bind
node.
E
You
can
actually
run
simple
jam,
binode
on
the
same
types
with
minimal
adjustment,
and
you
can
test
on
marshalling
and
marshalling
between
them
so
that
you
actually
have
binary
compatibility
so
anyway,
that's
I
spent
a
lot
of
time
on
that
last
week
and
I'm
I'm
pretty
happy
with
that.
I
think
the
performance
is
not.
The
performance
impact
is
fairly
minimal.
On
top
of,
like
onenote's
got
some,
it
does
some
hard
work
anyway,
but
yeah.
E
So
I
might
merge
that
soon,
it's
all
marked
as
as
experimental,
so
liable
to
change
but
yeah.
So
the
next
thing
is
pull
request.
Four
one
four
on
go
up:
ld,
prime,
let
me
just
see
is
that
the
one
I
was
thinking,
no,
not
for
one.
Four.
Sorry
give
me
a
second
I've.
Gotta
find
this.
I
was
writing
this,
as,
as
I
was
okay,
the
it's
pull
request.
Number
413
is
worth
noting.
E
Now
this
one
is
the
one
of
the
problems
that
ipld
prime
has
is.
Its
use
of
integers
is
n64,
which
means
that
you
don't
get
the
full
uint64
range,
which
you
can
do
in
cbore
and
json.
E
So
our
encoding
formats-
and
I
think,
even
presumably
you
could
do
it
in
dag
pp,
not
that
that
would
be
useful,
but
you
miss
out
on
that
little
bit
of
range
and
currently
there's
it
either
does
a
there's
a
couple
of
different
places
in
kansas:
it
either
doesn't
overflow
or
it
just
it,
either
errors
or
it
actually
just
overflows
and
wraps
around.
E
So
you
get
a
negative
number,
and
this
is
a
problem
in
where
we're
encountering
some
real
data
structures
that
use
that
range,
particularly
in
the
file
coin
chain,
where
that
full
range
is
used.
So
this
is
a
a
way,
a
proposal
for
how
to
how
we
can
get
access
to
it
in
the
places
that
we
need
it.
So,
where
you
know
you
need
it,
this
is
a
means
by
sort
of
hiding
it
in
the
data
structure.
E
So
if
you
know
that
in
this
position
I
need
a
unin
64
and
I
know
I
need
the
full
range
you
can
actually
get
access
to
it.
So
it's
wired
up
to
the
dag
cbo
codec
and
I
haven't
done
the
dag
json
one,
because
that
requires
some
deeper
work
in
the
jason
decoder.
But
yeah,
that's
there's
a
couple
places
a
couple
of
places.
I
might
need
this
so
for
now
it's
marked
as
draft,
but
it
may
end
up
being
used.
E
But
if
anyone's
got
feedback
on
that,
that'd
be
great
and
that's
me
I
think
thanks
and.
A
B
The
so
it
sounds
like
like
part
of
what
you're
trying
to
do
is
expose
like
sort
of
these
optional
ways
of
getting
like
a
few
extra,
more
bits
that
weren't
there
before
I'm
wondering,
if,
like
there's,
either
an
interest
or
like
a
pattern
where
we
can
do
this
for
like
each
time,
someone
wants
a
few
more
bits.
We
don't
it's
not
like.
Oh
can
I
have
like
a.
I
want
to
use
64
in
code.
Can
I
have
like
a
u72
in
code
and
like
a?
B
U
like,
90
inc,
like
I
start
expanding
the
number
of
bits
I
want,
because
people
want
larger
and
larger
like
big
end
sorts
of
things,
how
we
do
that,
like
maybe
in
this
case
it's
like
this
was
just
an
oversight
beforehand
and
we're
just
like
fixing
an
oversight,
but
it
feels
like
the
data
model.
Doesn't
the
data
model
support?
You
know
in
theory,
supports
like
unbounded,
integers
and
negative
integers.
E
I
think
the
the
data
model
is
is
heavily
infl,
even
though
we
probably
even
though
eric
might
deny
it
it's
heavily
informed
by
the
codex
and
both
the
codex
and
the
programming
languages,
and
so
cbore
numbers
are
64..
You
they're
unsigned
64.,
both
positive
and
negative,
which
is
interesting
and
there's
no
there's
no
means
of
with
in
our
daxybor
spec.
E
We
don't
allow
the
use
of
begin
of
any
of
those
extensions
that
you
would
use
tags
so
currently
we
don't
have
a
means
by
which
we
can
encode
and
decode,
but
we
do
we
get
around
that
in
far
coin
by
using
the
the
bigint
stuff
with
bytes.
So
I
I
would
say
right
now:
there's
not
a
practical
means
to
exposing
more
unless
we
had
a
codec
that
would
allow
us
to
encode
more.
B
B
E
D
E
Well,
in
the
the
and
then
there's
some
code
bases
like
the
bitcoin
code
base
that
defines
a
uint
25256
for
the
hashes
in
theory,
you
could
do
that
too.
I
know
we're
working
within
constraints
of
programming
languages
as
well.
They
have
to
be
practical
about
that
like
go.
Has
you
in
64.?
Oh
you
went,
64
is
its
biggest
thing
and
go
ipld.
Prime,
is
a
go.
Link
gives
a
go
binding,
so
I
mean
the
question's
interesting.
Can
you
expose
something
that
is
a
bit
more
generic
than
this.
B
E
I
don't
I
don't.
I
don't
think
it
is
because
this
one's
a
very
specific
case
of
there's
a
few
bytes
that
we
don't
have
access
to
right
now
that
we
kind
of
need
to,
but
cbogen
will
do
it.
Iple,
prime,
won't
that's
a
gap,
but
I
don't
think
that
like
and
then
this
is
really
informed
by
the
codex
too.
So
good
point
on
the
adls,
though
worth
a
thing
thanks.
A
Yeah,
I
think
it
might
come
up,
at
least
in
the
rust
side
of
things
when
we're
doing
what
I
do
more
of
the
lurk
work
because
like
in
cryptography,
you
have
begins,
like
you
always
have
begins
and,
as
I
have
no
clue
like,
I
actually
haven't
thought
about
like
how
they
currently
represent
those
things,
because,
like
ideally
yeah
it
is
in
their
data
model,
it's
an
integer.
So
it
should
work,
but
practically
will
be
interesting.
D
B
A
Yeah
all
right
next
one
is
now
is
musee.
F
Thanks
yeah,
I
have
made
some
more
progress
on
the
the
update
implementation
trying
to
fix
the
bugs
that
I
knew
of
finding
more
fixing
them.
Rod
gave
a
comment,
so
I
have
reworked
that
implementation
as
well.
F
I
should
be
close
to
having
all
the
fixtures
the
current
set
of
fixtures
pass
and
then,
hopefully
I
can
add
more
and
I
have
a
few
ideas
on
how
to
make
it
more
generic,
so
that
someone
else
can
add
their
own
implementation
based
on
the
template
if
they
want
to
replace
it
whatever.
So,
I'm
gonna
keep
working
on
that.
A
B
B
E
So
michael
rogers's
implementation
is
probably
the
most
interesting
to
look
at
in
terms
of
implementation.
Yeah,
that's
right!
The
prolly
trees
it
that
we
do
have
the
parallels
of
stuff
that
we
do
have
that
he's
currently
used
is
the
the
hamped
work
and
you'll
find
a
js,
ipld
hemp
library?
E
Don't
know
where
it
is.
That's
interesting!
E
Oh
no,
I
called
it
a
hashmap,
that's
right,
but
nobody
agrees
with
their
name.
Okay,
I'm
going
to
put
a
link
in
the.
E
So
this
this
library
is
a
usable
data
structure
that
some
people
are
using
now,
that
is
in
javascript
that
implements
a
hampt
and
there's
a
there's,
a
second
library
behind
it
called
ia
map.
It's
a
the
nesting
of
the
libraries
is
a
little
bit
complicated.
If
I
was
to
redo
it
again
today,
I'd
probably
flatten
it
a
bit
more,
but
this
was
very
much
a
research
phase.
When
I
was
first
doing
this,
the
you'll
want
to
present
an
interface
either,
something
like
that.
E
Some
cross
between
that
and
michael's
probably
trees
interface,
to
make
it
usable.
We.
We
have
this
problem
in
javascript
of
not
having
a
clearly
defined
api.
That's
consistent
across
libraries.
Unlike
in
go,
so
it's
really.
What
can
you
present?
That
is,
that
is
practical
and
usable
and
that's
probably
gonna
be
a
matter
of
experimentation
using
what
other
people
are
using
and
then
considering
what
people
want
to
how
people
want
to
consume
it.
E
E
So
they're
nice,
if
you
are
dealing
with
purely
random
data,
but
as
as
soon
as
you
allow
users
anywhere
near
the
ability
to
define
your
keys,
you
get
into
this
problem
of
having
potential
overflows
of
block
sizes
or
underflows
of
having
time
lots
of
tiny
blocks,
which
is
a
perverse
case
that
you
don't
want.
E
So
that's
been
my
hang
up
with
probably
trees
that
that
I
keep
on
coming
back
to
whenever
I
think
about
this
problem,
but
I
know
some
people
are
using
them
in
practical
ways
to
and
and
hiding
it
behind,
a
bit
of
randomness
but
yeah.
When
you
want
sort
of
data
structures
you
kind
of
want
them,
you
also
want
them
to
be
safe.
So
I
don't
know
it'd
be
interesting
to
see
more
practical
use
and
considering
some
of
the
potential
attacks
on
them
that
hasn't
been
not
much.
Work
has
been
put
into
that.
C
Yeah,
thank
you
for
the
specific
use
of
poetry.
C
We
we
think
we
want
to
build,
for
example,
the
reading
the
reading
side
of
the
apid
data.
We
need,
you
know
apid,
I
I
mean
you
know.
Poetry
is
using
the
ruling
hashi
for
on
the
blocks.
C
E
C
E
I'm
not
sure
exactly
what
the
question
is,
but
the
other
resource.
I
should
point
you
to
is
a
link
in
the
doc
a
specification
for
the
hampt,
which
is
the
which
is
implemented
by
that
hashmap
library,
and
we
have
a
similar
one
in
go.
We
have
a
couple
in
goes
go
actually.
E
I
didn't
just
put
the
note
in
the
chat
as
well
that
if
you
go
through
that
specification,
that's
the
kind
of
thing
we'll
we
will
need
for
the
prolly
trees,
implementation,
and
maybe
that's
what
your
because
I
know
move
was
talking
about
getting
that
written
up
in
some
way,
so
that
that
description
tells
you
how
to
implement
or
how,
how
the
the
hemp
data,
struct
multi-block
data
structure
is
implemented
and
how
what
the
interface
looks
like
for
various
operations
of
it.
E
C
Okay,
okay,
I
think
we
need
to
look
into
that
and
go
back
to
you
and
discuss,
for
example,.
E
C
E
You
read
that
spec
that
it's,
the
probably
trees
is
the
same
kind
of
process
of
this
is
how
you
build
the
data
structure,
underneath
this
is
how
the
blocks
lay
up.
So
when
you're
adding
things,
this
is
how
it
shakes
out
and
then,
when
you're
reading
things.
This
is
how
you
would
get
access
to
them
so
that
that
doc
tells
you
how
to
do
that
for
a
hampt
and
the
prolly
trees
is
a
fairly
similar
in
in
the
patterns.
E
Will
would
be
the
best
person
to
answer
that
question?
I.
D
E
Yeah,
there's
the
go
version
of
that
and
and
just
for
completeness
I'll
put
in.
E
There's
also,
this
is
there's
a
second
one
that
got
specked
out
called
vector,
which
is
like
a
large
array.
It
now
doesn't
have
any
currently
practical
use,
but
it's
the
same
kind
of
thing
for
a
raise.
Did
that
spec
make
it
across
it's
a
good
question.
E
No
there's
an
fbl
okay,
yeah,
there's
another
spec,
that's
similar
that
it's
just
not
in
practical
use
of
the
moment,
but
it
does
a
large
array
rather
than
a
map
structure.
So
that
might
be
interesting
to
look
at
it
too.
If
you
wanted
that,
but
yeah
not
as
clean
as
the
ham
stuff,
they
have
the
hand
is
we
use
hampton
a
lot
of
places
in
in
various
forms
and
it's
a
really
solid
data
structure.
E
What
we
need
from
an
ordered
data
structure
is
something
as
solid
as
the
hampt
and
probably
trees
gets
us.
I
I
think
it
gets
us
most
of
the
way
there,
just
not
not
quite
as
solid
as
a
hampton
but
you'd
be
interesting
to
see
a
speck
written
up.
That's
in
the
same
vein
that
maybe
we
can
then
all
have
a
discussion
about
whether
that
we
can
make
it
better.
B
E
No,
I
don't
think
anyone's
using
the
go
one.
E
I
know
I
know
people
are
using
the
the
javascript
one.
I
think
the
javascript
one,
I
think,
is
even
being
used
in
the
the.
What
is
that
the
twitter
bluesky
prototype
that
they
put
out
recently.
So
that's
really
interesting.
B
Yeah,
I'm
wondering
because
one
of
the
shortcuts
I
took
with
the
or
I
don't
know
better
for
worse
shortcut
parts
of
the
bittorrent
directory
adl,
is
that
like
unix
fs,
it
like
it
like,
eats
the
rest
of
the
traversal
like
once
you've
like
with
unix
fs,
once
you've
started,
you
can't
stop
being
in
unix
fs
once
you're
in
a
bit
current
directory.
You
can't
like
stop
being
in
a
bittorrent
directory,
whereas,
like
the
hemp
adls
allow
you
to
get
out,
it's
like
you
did
your
hampshire.
F
D
From
ken
labs,
following
up
on
this
question,
can
we
say
that
so
like
ipfs?
Is
I'm
sorry
now,
if
you
have
ipod
the
specification
and
the
the
goal
or
intention
is
that
we
use
try
to
use
43
to
to
build
based
on
the
ipod,
node
or
the
bytes,
so
that
we
give
the
different
indentation
so
that
probably
from
stability
or
performance
point
of
view,
we
can
see
something
different.
D
I
mean
the
rpod,
the
poetry
or
the
chunky
tree.
The
goal
of
the
this
idea
is
that.
D
For
for,
I
think
that
hold
everybody
anyone
can
answer
or
okay,
I
think.
D
B
E
It
what
they
they,
the
the
the
the
thing
that
we
really
want,
is
an
ordered
data
structure
that
is
solid,
that
is,
that
works
well
with
content,
address
data
and
that's
the
sort
of
the
the
you
know,
the
the
golden
thing
that
we're
searching
for
that
when
we
get
that
when
we
have
a
sort
of
data
structure
that
sorts
by
the
keys,
it
unlocks
a
lot
of
potential
for
building
really
sophisticated
tools
upon
ipld,
because
that
sort
of
data
structures,
sort
of
key
data
structures
are
they're
the
basis
of
databases.
E
You
can
start
to
build
indexes
and
then
you
can
start
to
build
a
database,
and
once
we
have
that
you
can
combine
these
data
structures
together,
hamps
and
a
sort
of
data
structure
in
different
ways.
You
can
resort
things
you
can
have
them
in
different
ways
to
put
them
together
and
build
really
sophisticated
tools
on
top
of
ipld,
so
yeah
that,
as
I've
been
said,
the
hamster
to
get
us
so
far.
They're
really
solid,
but
we
can't
do
anything
in
terms
of
ranges.
We
can't
say
for
this
range.
E
D
E
Michael
and
they
had
a
hack
week,
the
dot
storage
team
had
a
hack
week
a
couple
of
weeks
ago
and
michael
put
up
a.
Let
me
just
see
if
I
can
find
it
they
had.
They
had
a
an
experimental
thing
here.
E
I
know
he's
been
working
a
bit
more
on
probably
trees,
but
this
and
they're
going
to
put
this
in
the
dock,
and
I
haven't
looked
at
the
code
yet,
but
I
know
michael,
has
been
playing
in
different
different
times
and
different
approaches
to
this
problem
of
databases
on
top
of
content,
addressing
this
is
from
a
hack
week
that
they
did
where
they
did
a
sprint
on.
How
do
you?
How
can
build
a
database?
It's
not
the
first
time
that
michael's
tried
to
do
this.
E
He
tried
to
do
one
with
sql,
which
was
really
interesting
as
well,
so
you
can
find
that
in
his
github,
but
this
is
trying
to
use
this.
This
uses
probably
trees.
Once
you
have
that
sorted,
a
bit
indexing
ability,
you
can
build
all
sorts
of
interesting
things.
D
D
F
E
Yeah
we
would
be
cool,
although
if
we,
if
we
could
get
something
that
is
reusable,
that's
well
specified,
then
a
lot
of
potential
there.
A
Cool
I
actually
haven't
heard
of
than
the
next
generation
or
like
the
database,
that
that
michael
is
building
and
from
the
commits
together
with
jcris,
that's
interesting,
so
I
should
probably
also
join
yeah
yeah.
It
just
is
a
background
like
both
of
them.
We
created
a
database.
We
were
working
on
a
database
company
together
like
10
years
ago
12
years
ago,
so
yeah.
I
should
probably
join
them.
E
D
Sorry
all
right
probably
have
one
last
question
so
before
we
stop
and
okay
in
terms
of
the
the
user
point
of
view
so
say
that
we
have
ipod
data
stored
in
on
the
internet
on
the
network.
So
how
can
user
do
the
query?
For
example,
if
we
want
to
do
some
range
query
say
from
to
the
between
this
range,
we
want
to
fetch
some
data,
so
what's
the
best
way
to
build
the
interface
to
the
user,
we
know
in
web
2
world.
D
E
That's
a
really
good
question
and
I
think
that
that's
going
to
require
some
experimentation
and
if
you've
got
ideas
about
nice
interfaces
and
that's
great
the
in
go.
We
have
this.
We
have
these
developing
standards
in
the
go
ipld,
prime
library,
about
how
you
access
data,
but
it
doesn't
have
anything
for
range
queries,
so
we
we
don't
even
have
that
in
go
yet
for
when
we're
building
these
adls
advanced
data
layouts
on
top
of
multi
blocks.
E
So
I
I
think
that's
going
to
require
people
coming
up
with
proposals
for
how
you
would
how
you
would
expose
that
it
might
be
interesting
to
talk
to
michael
actually
see
if
you
can
grab
some
time
with
him
to
talk,
have
a
meeting
with
him
and
and
see
what
his
ideas
are.
Because
he's
been
experimenting
with
this
a
lot
because
it
will
vary
between
javascript
and
go
as
well.
Will
you
put
your
hand
up?
Is
it
you
got
to
comment
on
it?
Yeah.
G
I
mean
I
would
maybe
argue
that
selectors
is
where
the
that
fits
in
terms
of
how
you
query
and
get
subsets
of
of
these
things
we
do
have
some
amount
of.
G
I
think
there
is
in
a
selector
a
range
to
get
a
subset
of
something
that
looks
like
a
list,
and
so
if
the
adl
makes
it
look
like
a
large
list
yeah,
you
could
imagine
that
the
selectors
for
them
the
range
within
that
large
list
can
give
you
a
subset.
E
That's
true
yeah
and
we
could
we
could
amend
that
and
have
the
starts
out
and
stop
that
for
proper
range
queries.
That
would
be
really
interesting,
but
again
we
don't
have
a
good
selector
story
in
javascript,
so
so
it
really
depends
on
language.
It
would
be
the
ideal
is
that
we
would
get
good
selective
support
in
javascript,
because
we
need
it
for
a
bunch
of
places,
but
yeah.
G
But
if
it's
an
adl
over
the
data,
the
server
that's
going
to
be
doing,
that
is
going
to
be
and
go
possibly
so.
You've
got.
E
Yeah,
it
depends
on
who
you
talk
to,
but
yes
it
would
be
nice
to
have
it
consistent.
So
we
didn't
have
to
worry
about
these
things,
but
right
now
it
really
is
a
there's.
A
difference
in
language.
B
But
you
don't
have
to
think
too
much
about
them,
then
that
may
make
it
a
little
easier
like
a
lot
of
the
code
that
has
been
ported
from
one
language
to
another
in
our
ecosystem.
So
far,
right
like
round
two
is
much
much
faster
than
round
one
because
round,
one
you're,
like
figuring
out
what
to
build
and
round
two
you're
just
like
how
do
I
take
your
idioms
in
your
language
and
make
them
idioms
in
my
language,
which
is
less
hard
normally.
B
It's
sort
of
interesting
with
the
using
using
like
a
list
approach,
because
then
it
really
does
show
like.
Oh,
yes,
these
are
sort
of
using
the
adl's
in
like
a
lens
sort
of
way
or
like
it's
the
same
data,
and
I
can
look
at
it
as
like
a
map
and
get
map
semantics,
and
I
can
look
at
it
as
a
get
lit
as
a
list
and
get
like
list
semantics
out
of
it.
E
Yeah,
that's
the
ideal.
The
node
interface
gives
you
that,
but
it
doesn't
give
you
the
it
doesn't
give
you
the
the
range
website.
D
E
E
Yeah,
maybe
the
idea
with
these
multiple
data
structures
is
you
want
to
present
it
to
the
user
programmatically
as
if
they
are
using
a
local
data
structure,
as
if
it's
just
reaching
into
memory
and
all
the
you
know
the
fetching
of
blocks
and
stuff?
You
need
to
abstract
that
away,
because
that
can
either
be
handled
by
fetching
them
out
of
car
files
or
fetching
them
off
a
cdn
or
fetching
them
through
ipfs
dht.
E
A
All
right
any
further
questions.
A
F
A
Thanks
right,
cool
thanks,
yeah
also
also
thanks
for
the
questions
because,
like
yeah,
it's
always
great
to
get
in
touch
with
people
and
talking
about
those
things,
because,
like
many
people
in
here
have
already
put
some
thought
in
many
different
things.
So
it's
good.
If
we
start
the
discussion
all
right,
cool
yeah,
then
I
would
say
we
close
the
live
stream
part
of
the
meeting
and
if
you
still
want
to
hang
out
so
after
the
live
stream,
we
still
hang
out.
A
If
there's
any
questions
that
you
want
to
ask
privately
and
not
live
streamed
feel
free
to
keep
it
to
stay
in
the
room,
but
for
the
live
stream
yeah.
I
say
goodbye
and
see
you
all
in
two
weeks
again
goodbye
everyone.