►
From YouTube: 🖧 IPLD weekly Sync 🙌🏽 2019-09-09
Description
A weekly meeting to sync up on all IPLD (https://ipld.io) related topics. It's open for everyone and recorded. https://github.com/ipld/team-mgmt
A
A
Thanks
rod
and
yeah
so
I,
as
always,
I
start
with
myself
so
I've
been
the
I
think
past
two
meetings
I've
been
at
phosphor
G
conference,
which
is
the
free
and
open
source
for
geospatial
conference.
It's
a
global
conference
every
year
with
about
1,000,
attendees
and
I,
gave
two
talks,
one
about
Jillian
ipfs
and
one
about
steak
on
ILD.
B
We've
done
a
lot
of
talking
about
details
for
configuring,
advanced
data,
layouts,
and
one
thing
we've
also
tried
to
formalize
more
is
the
idea
that
we
probably
need
some
sort
of
any
concept
in
the
schema
system
once
turned
out
to
be
a
little
elusive.
We've
had
some
sort
of
placeholder
references
to
it
scattered
around.
B
We
took
a
stab
at
drafting.
What
an
any
would
look
like
that's
described
within
the
current
system
and
I
think
we
found
that
it
doesn't
fit.
So
that's
a
little
dissatisfying
and
I
don't
know
if
we've
come
up
with
the
idea
of
what
we
do
want
to
do.
It
might
go
back
on
the
backburner
to
stew
for
a
while
go
like
no
deep
run
has
gotten
more
code
in
it.
B
There's
some
some
nice
free
factors
like
path
segment
is
now
a
rarified
concept
and
it
is
either
a
string
or
an
int,
and
the
implementation
does
reasonably
efficient
things
with
this
as
much
as
you
can
and
go,
and
some
of
those
reef
actors
will
probably
have
performance
improvements
to
selectors
already,
because
what
it
was
doing
previously
I
found
out
after
a
lot
of
benchmark
assembly
read.
Is
there
were
some
parts
of
the
selector
system
that
would
cause
really
excessive
amounts
of
small
allocations
to
make
these,
like
wrapper
objects
and
the
new
path?
B
Let's
do
that,
so
it's
a
nice
improvement
koujun
has
started
to
get
some.
Don't
repeat
yourself
thing
of
the
health
is
all
very
belatedly,
because
it's
sometimes
hard
to
guess
where
the
correct,
not
repeating
yourself
will
be,
but
some
patterns
it
started
to
I
started
doing
it.
Last
week,
I
was
looking
at
the
system
for
the
note
builder
being
able
to
return
more
node
builders
for
child
fields.
B
This
was
something
that
I
didn't
see
coming
super
early
on,
but
became
a
lot
there
as
the
system
progressed.
Basically,
recursion
is
necessary
on
the
node
builder
side
alone.
Not
just
on
the
node
side,
because
when
you
are,
for
example,
doing
D
serialization
into
a
system
with
any
sort
of
constraints
on
the
values
it
can
accept,
you
need
to
provide
a
node
builder
for
your
child
values
that
carries
those
constraints
through,
so
he
had
a
schema
system.
B
This
would
need
to
contain
logical
constraints
if
you
had
something
that
was
just
bound
to
native
typed
code
at
all,
okay,
those
constraints,
so
this
turned
out
to
be
necessary
and
it
also
shouldn't
have
to
be
easier
than
I
thought.
So
that's
in
and
so
last
week
after
that
gotta
know
is
thinking.
G
serialization
VOCs
that
work
across
the
holster
this
system
might
be
in
reach
and
they
work.
Those
are
now
done.
I
simultaneously,
don't
want
to
oversell
this,
but
oh
my
gosh
I'm
really
excited.
B
There
is
now
a
small
POC
of
code
generated
structs
and
a
D
serialization
system
that,
just
once
fairly
transparently,
still
reusing
all
the
Codex.
Nothing
non
cogent
stuff
was
using.
So
that's
nice
and
basically
it
worked
with
no
abstraction.
That's
blowing
up
in
an
unusable
way,
so
so
that
milestone
basically
seems
like
everything
is
on
track
and
it's
I
don't
want
to
oversell
it,
because
it's
a
very
small
fraction
of
the
amount
of
work
to
do
in
Cochin
overall
in
the
future.
But
so
it
worked
so
yeah.
It
was
a
good
week.
B
It
will
be
in
a
branch
and
it'll
land
on
master
and
go
I
feel
I'm.
Probably
pretty
quick
I've
just
been
doing
all
that
stuff,
it's
in
the
the
schema
package,
and
then
we
Jen
going
package
inside
of
that
and
I'm
keeping
that
thing
tab,
but
sort
of
a
desperate
way
like
the
feature
completeness
and
stuff
and
mastering
those
packages.
B
C
Answers
your
question
so
like
we're
just
wondering
what
what
form
it
is
is
it
is
it
like?
Is
this
a
thing
that
you
can
run
is
I
think.
Well,
how
can
you
look
at
it?
What
is
it
is
it
tests?
Is
it
just
code,
a.
B
B
B
C
So
I
had
some
time
off
last
week
at
my
sister
in
town
and
I
was
having
a
beretta
breather,
but
so
from
that
the
last
most
of
the
last
two
weeks
has
been
all
about
schemas
in
three
areas.
There's
the
specs,
the
Jaya
sponsor
and
the
go
passer
so
on
the
spec
front,
been
trying
to
pull
everything
into
a
unified
place.
C
So
that
kind
of
thing
that
puts
reunification
activity
trying
to
finalize
advanced
layout,
basic
advanced
layout,
syntax
and
the
ampersand
link
shorthand
syntax
as
well
in
the
spec
that
that
the
latter
one
is
done
as
as
Eric
said,
we're
still
circling
around
this
anytime,
which
is
sort
of
required
for
this,
but
I
think
we've
can't
with
a
whale
a
special
case.
It
in
this
case
I,
think
but
in
respects.
Here
they're
in
the
specs,
the
any
type
is
still
loose,
but
that
can
be
that
can
be
hunted
to
later.
C
I
have
a
test
suite
now
that
is
usable
across
languages,
so
that
was
the
original
tension
intention
when
I
started.
Writing
all
these
fixtures
for
testing
basic
usage
and
I
I
spent
a
lot
of
time
in
in
go
in
goal,
and
you
know
mainly
getting
used
to
it
all,
but
also
seeing
if
I
could
put
pull
Jeremy's
stuff
into
line
with
the
rest
of
the
stuff.
I've
got
and
so
I've
got
a
test
framework.
Now
around
Jeremy's
work,
I
haven't
put
a
pull
request
into
there.
C
So
I
don't
know,
I,
don't
know
yet
how
well
it's
gonna
suit,
what
he's
using
it
for
now
or
whether
we
need
to
fork
it
and
and
Joe
in
a
slightly
different
direction,
because
he's
using
a
some
code
and
stuff
director
Seymour
not
connected
to
IPL
d-prime,
so
I'll
have
that
conversation
with
Jeremy
in
the
next
couple
days,
I
hope
via
pull
request
yeah.
But
hopefully
the
aim
is
to
get
this
advanced
and
link
stuff
sorted
out.
C
B
I
sneak
back
in
first,
you
reminded
me
what
I
was
trying
to
remember
to
disclaim
earlier
there's
one
more
big
part
of
the
dependency
tree
and
go
IPL
D,
prime,
for
the
co
gem.
That
is
extremely
placeholder
E
right
now,
and
it's
actually
the
data
structures
for
representing
the
schema
types
itself.
They
are
currently
hand-rolled
and
I.
B
Think
that's
going
to
be
fine,
because
I
want
those
to
be
like
natively,
very
they're,
gonna
lookin
yeah,
but
the
Constructors
for
those
are
currently
a
bunch
of
functions
which
are
called
temp.
Do
not
use
me
sort
of
they're,
just
very,
very
sharp,
edged
constructors
and
the
only
way
to
create
these
values
currently
is
in
go
code.
So
the
go
IPL
D
prime
codebase
is
missing
any
parser
of
schemas
or
direct
loader
of
those
and
all
the
code.
Gen
is
currently
powered
by
those
values
that
you
can
only
create
my
those
placeholder
functions.
B
So
it's
a
big
obvious
in
one
place,
sort
of
placeholders
at
least
but
another
though
kind
of
the
good
news
around
this
is.
Hopefully
we
can
take
a
bunch
of
that
stuff
from
Jeremy's
projects
that
Rob
is
now
working
and
that's
going
just
fit
it
in
this
lot.
But
at
the
moment
I've
been
pumping
on
that,
assuming
it
will
fit
nicely.
D
Okay,
so
unique
52
made
a
ton
of
progress.
We
now
can
like
encode
files
and
directories
recursively
in
JavaScript
and
spit
out
blocks
and
all
that
to
the
stuff
and
there's
a
little
camera
and
utility
for
debugging.
It
I'm
still
lacking
tests
and
just
electing
like
I've,
read
interface,
and
we
will
file
system
and
all
that
stuff.
So
there's
more
work
to
do,
but
that's
not
coming
together.
You
never
see.
One
changes
are
like.
This
is
just
like
the
issue
that
never
goes
away.
D
There's
now
like
just
a
general
conversation
about
like
which
properties
do
we
actually
need
to
have,
but
hopefully
that'll
get
resolved
soon.
Enough
and
I
heard
at
this
point.
We
need
to
have
a
conversation
not
only
about
what
properties
that
want
to
have
the
whole.
We
want
to
do
by
default,
which
is
probably
no
change
from
what
we
have
today
but
anyway,
and
then
oh.
D
Yeah,
okay,
ours.
There
is
an
issue
that
or
sorry
I'll
pull
request
that
everybody
should
comment
on
for
okay,
ours
for
next
quarter,
which
we
need
to
finish
up
this
week,
there's
also
an
issue
in
the
roadmap
repo
we're
reaching
out
to
our
dependencies
to
try
and
surface
what
they
need.
So
please
look
into
that
and
there's
an
issue
in
the
new
repo
called
auto
around
automating
some
team
permissions
and
there's
a
bunch
of
permission,
changes
that
need
to
land.
It
will
land
once
that
gets
nerfed
in.
A
C
And
in
ignore
the
angle
bracket
bit
in
the
X
coming,
that's
the
that's
the
current
proposal,
broad
proposal
for
defining
advance
layouts
in
your
schemas
and
then
using
them.
So
the
angle
brackets
are
not
in
play
here.
That
may
come
later,
but
the
way
you
would
do
it
is
you
would
use
the
keyword
advanced
you
give
it
a
name.
C
A
C
Okay,
well,
I
mean
if
we,
if
we
do
that,
so
we
advance
and
you
give
it
an
arbitrary
name
and
then
our
giz,
where
you
could
use
it
to
connect
it
to
logic
or
connected
to
a
scene
somewhere
some
something
that
does
the
logic
the
params
stuff.
Can
that's
not
like
that's
sort
of
future
work.
It's
not
necessary
to
move
forward
right
now
and
then
to
use
them
you
you
would
have
to
use
this
representation
thing.
C
The
shorthand
version
is
a
little
more
complicated
and
I
think
we
should
punt
on
any
shorthand
for
now
and
that's
the
tenor
of
the
discussion.
That's
right
as
well.
So
I
just
wanted
to
just
see
if
we
can
make.
If
we
could
get
some
basic
progress
on
this,
because
once
we
can
and
I
can
merge
some
stuff
and
start
making
all
the
code
pull
in
the
direction.
B
So,
for
what
it's
worth,
I
do
I'm,
gonna
only
angle
brackets
I,
don't
know
if
I
really
believe
that
will
have
a
strong
desire
for
template
mechanisms
later
either.
But
that's
my
belief
of
that
is
of
the
weak
form
where
I'm
not
sure
that
trade
offs
make
sense
rather
than
the
strong
form
of
I
think
this
is
morally
valid
from
some
sort
of
important
first
principle
so
and
the
rest
of
your
argument
around
that
stands
so
yeah
and
I'm
also
convinced
but
yeah
trying
to
have
an
inline
shorthands.
B
C
D
C
They're
meant,
and
then
you
defer
to
the
HAMP
to
decide
how
to
deal
with
it's
been
scheme
and
stuff.
There's
this
discussion
about
saying,
making
assertions
about
the
route
block
and
being
able
to
traverse
all
the
way
in
but
kind
of,
agree
with
Eric
at
the
moment
that
it's,
the
utility
of
that
is
probably
limited
to
the
point
where
the
complexity
gets
out
of
hand,
and
maybe
it's
not
worth
even
going
down
that
rabbit
hole.
Just
you
I.
D
It
would
already
do
all
the
schema
validation
for
you
so
and
and
I
mean
the
difference
between
having
like
hooking
it
up
after
the
fact
from
a
different
file
and
having
it
in
file
just
means
that
it's
a
less
compelling
design
language,
because
now
I
have
to
have
a
separate
file
for
every
index
layout
that
I
ever
created,
which
is
just
annoying
and
I,
really
don't
know
what
the
parameters
are
for.
I
really
don't
understand
that,
like
these
are
gonna
have
to
be
encoded
into
the
actual
block
structure,
so
they
belong
and
schema.
C
This
is
usage,
though
this
is.
This
is
not
on
declaring
the
advanced.
Now
this
is
heavy.
You
have
a
highly
user
defensemen.
So
in
this
case,
rot13
is
some
advanced
layout,
that's
defined
elsewhere,
and
it's
it's
got
its
own
place
with
the
logic
and
the
ended
schema
lives,
and
this
is
a
user
saying.
I
want
to
pull
that
thing
off
the
shelf
and
use
it
so.
D
Well,
like
even
then,
okay
all
right
so
like
what
I
don't
like
about
this,
isn't
it
we're
we're
taking
some
kind
of
parameter,
defining
it
here
and
it's
not
actually
being
encoded
in
the
data
necessarily
which
is
problematic,
like
it's,
my
instinct
to
just
say
like
if
it's
not
in
the
data
than
it
doesn't
exist,
and
if
you
want
to
set
up,
if
you
want
to
pass
a
parameter,
you
pass
it
in
when
you
create
the
data
structure.
So.
C
I
I
think
we
gotta
be
careful
with
the
whole
premise
thing:
let's
not
get
caught
up
on
it,
because
it's
still
that's
a
separate
issue
that
I
think
we
can.
We
can
punt
on
because,
but
you
know
it
is
questionable
whether
they
even
useful
my
the
way
I
was
conceiving.
It
was.
This
would
solve
the
some
of
those
concerns.
The
far
quantum
had
about
those
parameters
and
not
wanting
them
to
go
into
root
blocks
because
they're
always
fixed.
So
you
could
say
in
the
file
coins,
Beck,
I'm,
using
hampt
and
the
parameters.
C
Aren't
this
always
this,
whereas
in
our
use
cases
you
could
say
you
could
leave
that
concern
to
code
layer
or
perhaps
there's
an
option
in
the
in
the
in
the
logic
Falls
of
the
advanced
layout
that
always
encodes
it?
No
matter
what
you're
providing
there
like,
you
might
provide
big
width
of
13
and
it
still
write
bid
with
of
13
into
the
block,
but
your
schemer
is
the
thing
that
is
directing
the
logic
to
do
that
it
rather
than
doing
it
via
code.
D
D
If
they
don't
want
the
params
to
be
encoded
into
the
data,
then
they
just
need
to
come
up
with
some
sane
defaults
that
we'll
assume,
and
that
will
be
part
of,
like
the
bitter
part
of
the
schema,
like
the
schema
for
the
advanced
layout
rather
than
a
parameter
of
each
asana
like
that,
should
be
a
fixed
thing.
It
should
not
be
like
yeah
if
you
want
it
yeah.
If
you
want
to
set
an
arbitrary
default
for
a
parameter,
then
do
it
in
the
schema
for
the
advanced
layout.
D
B
The
thing
we
Rob
wants
to
narrow
in
on
I
think
in
order
to
figure
out
what
to
do
with
parsers
is:
is
there
more
than
literally
one
unit
of
information
like
more
than
one
scalar?
That
is
going
to
go
into
the
definition
of
an
advanced
layout,
because,
if
there's
more
than
one-
and
we
won't
have
a
block
syntax
like
this,
so.
C
So
my
example,
in
my
examples,
I
had
the
name
of
the
advanced
layout
being
the
thing
that
would
tie
that
thing
to
the
logic
or
as
Erik's
suggesting
we
go
back
to
this
idea,
where
you
have
some
name
that
identifies
it
and
that
you
could,
like
I,
just
put
a
little
expression
there,
just
for
example
that
this
is
an
arbitrary
string
that
is
some
somewhere
is
in
some
registry
or
mapping.
That
says
this
thing:
it's
the
code,
it
you
can
connect
it
with
code
here
and
maybe
in
in
go.
C
D
C
Alternative
is
to
like
I,
don't
think
I.
Don't
actually
don't
think
that
that
is
required
at
all
for
now
like
we
could.
Let
me
just
do
another
comment
there,
which
is
just
completely
remove
that
block
and
the
name
advance
is
what
you're
connecting
so.
The
name
of
the
behind
advance
is
what
you
can
evening.
So
you
know
map
rot13
and
then
point
it
to
a
place.
It's
just
when
you
do
that.
Now
you
still
have
flexibility
when
you
do
that.
We're
gonna
have
something
that
maps
that
nap
string,
rot13
logic,
yeah.
D
Well,
I
mean
like
so
when
you
shove
this
through,
like
the
semi
code,
anything
that
I
have
like
all
of
the
api's
that
come
out
of
it
are
named
the
type
names
and-
and
you
would
also
end
up
with
like
a
class
called
rot13.
That
was
the
advanced
layout
class,
and
so
you
would
basically
hook
into
that
to
add
any
logic
to
it.
For
the
time
being
or
I
guess
you
would
also
have
to
use
give
that
in
order
to
attach
more
schema
to
it,
but.
A
C
D
Yes,
I
mean
yeah,
it
would
be
like
one
line
like
I
didn't,
pour
your
hash
map
library
and
then
I
would
take
my
code
so
like
right
near
your
schema,
you're
referencing
hand,
the
thing
that
I
spit
out
would
give
you
a
hand
class,
and
then
you
would
call
a
method
on
it
and
pass
in
whatever
module
thing.
You
wrote
to
actually
implement
that
yeah.
So
it's
like
one
line,
the
user
has
to
just
configure
that
and
yeah
well.
D
D
Probably
better
yeah
I
mean
I
I
would
at
some
point
in
the
future
like
to
be
able
to
define
the
schema
for
an
advanced
layout
in
the
same
file
as
another
schema
just
for
simplicity
of
design
language,
but
I
mean
for
right
now.
I
can
just
make
them
separate
files.
It's
fine,
because
I'm
gonna
have
to
ask
them
all
and
independently
anyway.
So
okay
make
sense.
Yeah.
B
I
think
the
one
thing
that
I
care
about
for
the
syntax
here-
that's
just
a
lot
of
this
whole
discussion
is
as
long
as
the
word
advanced
is
a
keyword
and
it
starts
all
the
way
on
the
left
side.
I'm
happy
about
that,
and
as
long
as
something
also
appears
in
the
vicinity
of
that
representation
thing,
so
it
doesn't
have
like
a
namespace
in
collision
with
the
built
in
representations
and
I'm,
and
that
last
suggestion
has
those
two
major
boxes
checked
in
the
rest.
I'm.
It's.
A
D
Honestly
too
weak
yeah
I
mean
the
weird
thing
to
me:
actually
is
just
seeing
representation
on
the
same
line
as
the
rest
of
it,
because
usually
the
representation
is
coming
after,
like
an
angle,
bracket
somewhere
because
usually
using
it
like
in
a
union,
but
no
it
does
make
sense,
though,
do
we
need
do
we
actually
need
the
advanced
keyword
in
that
line,
though?
Yes,.
D
D
C
And
that,
and
this
this
gives
us
that
flexibility
again
like
I,
still
don't
I'm,
not
that
comfortable
with
not
when
you
define
advanced
rot13,
saying
that
that's
what
kind
it
is
I
still
would
rather
have
a
kind
there,
but
but
it
does
remove
any
duplication
and
it
allows
you
to
reuse
an
advanced
layout
as
different
kinds.
If
it
could
do
like,
you
could
use
a
a
HAMP
to
say
as
a
list
an
unordered
list.
If
you
wanted
to
you,
know,
I
have
been
where
yeah
yeah.
D
I
mean
so
when
you
think
about
the
usage,
once
you
have
these
in
multiple
files
and
you're
sort
of
passing
them
around.
The
type
that
comes
out
of
one
schema
will
end
up.
You'll
actually
end
up,
attaching
them
the
here's
how
to
treat.
This
is
a
screen
logic
to
that
type
and
then
probably
passing
that
type
into
the
next
schema
Potter's
that
uses
that,
as
in
the
back
layout,
so
you'll
probably
even
end
up
with
some
symmetry
in
the
naming,
as
well
just
for
convenience.