►
From YouTube: 🖧 IPLD Bi-Weekly Sync 🙌🏽 2019-01-07
Description
A bi-weekly meeting to sync up on all IPLD related topics. It's open for everyone and recorded. https://github.com/ipfs/team-mgmt/issues/720
A
B
A
A
Let's
see
what
we
have
on
the
crypt
pad
I'll
paste,
the
URL
in
case
someone
isn't
on
the
crew
period,
it
just
yeah
and
we
need
a
note-taker
any
volunteers
for
note-taking.
This
week's
is
probably
pretty
easy
because
there
isn't
that
much
I
guess
so.
Anyone
here,
if
not
I,
can
wait,
but
then
someone
else
has
to
lead.
The
meeting
because
do
both
is
really
not
in.
A
D
D
So
I'm
trying
to
reduce
what
I
learned
into
some
notes
about
ways.
We
can
refine
open
versus
closed
dichotomies
in
enumerated
types
into
like
or
productive,
like
what
is
a
behavioral
treat
for
what
we
want
to
do
when
we
encounter
problems
with
the
closed
tightly
so
yeah
I've
been
trying
to
do
some
writing
on
that
and
getting
something
ready
to
share,
not
sure
if
it's
there
yet,
but
maybe
soon
and
so
going
forward.
I'm
gonna
try
to
finish
that
up,
get
something
ready
to
share
and
then
poking
more
implementation
on
the
go
side.
D
C
But
I
I'm
I'm
I'm,
not
sure
if
I
understand,
oh,
go,
IPO
d-prime
kind
of
like
like
like
builds
or
sorry
I'm,
I'm,
not
sure.
If
I
understand,
I'll
go
I
peel
the
prime
feet
seemed
I
peel
the
puzzle
that
we've
been
thinking
about
about
graphs,
inking
and
I,
kill
the
API
is
and
the
revamped
ipfs
etc.
Can
you
just
like
a
quick
description
of
like
what
go
IPO?
The
price
is
it's
the
revamped
it's
the
whole
breed
up.
Yeah.
D
C
B
C
B
D
Spiritually,
it's
going
the
exact
same
place,
practically
it's
a
new
repo,
so
that
I
can
write
new
code
without
friction
with
existing
projects,
depending
on
the
current
interfaces
when,
in
some
cases
the
current
interfaces
are
wrong
and
several
things
need
to
be
adjusted
all
at
once.
So,
like
all
sorts
of
things
that
are
well
documented
in
the
existing
repos
like
links,
have
these
two
other
pieces
of
metadata
that
nobody
ever
uses
and
they're
on
set
in
practice
and
all
implementations
just
skipping
those
things
in
a
simple
imitation.
D
C
Good,
my
my
specific
question
on
the
does
it
touch.
The
HDTV
part
is
because
the
the
Jeff
sign
keeps
like
struggling
with
like
just
dealing
with
IPL
the
when
using
do
ipfs
the
demon,
because,
like
api
right
now
in
the
way
it
works
like
sterilize
everything
to
Jason,
and
so
it
has
been
a
struggle
to
make
the
client
library
just
because
API
to
work
with
a
dagger
API
of
go
a
BFS.
C
Because
of
that
to
the
point
where
we
have
to
use
the
block,
API
and
deserialize
things
on
the
client
side
and
do
the
resolve
of
the
pads
on
the
client
side
in
order
to
make
it
work
because
we
cannot
just
go
directly
otherwise
go
will
mess
up
with
the
types
by
sterilizing,
everything
to
Jason
and
so
cool.
Okay,
I
understand.
Now
it's
not
touching
this
part.
C
B
The
solution
there
is
still
going
to
be
sent
back
to
my
data
and
have
a
teacher
like
my
client
ID,
because
we
can't
like
give
an
arbitrary
objects.
We
can't
care
to
do.
We
can
convert
it
to
Jason,
but
what
we
should
do
is
at
least
like
Mable,
either
padding
to
the
Jason
API
or
like
not
like
somehow
avoid
0
I
think
was
the
yeah
I
get
that.
But
that
was
a
tricky
question
and.
D
B
Can
but
at
some
point,
you're
always
going
to
have
an
issue,
we're
like
just
something
you
just
can't
convert
certain
formats.
It's
like.
We
should
totally
make
your
try
to
make
it
possible
convert,
but
that,
if
you
want
to
fully
like
basically,
if
you're,
using
this
from
like
a
Ivy,
League
library,
use,
implement
Sarah
the
utility
services
locally
and
then
get
the
raw
bytes
instead
of
like
trying
like
to
work
in
format
yeah,
but
that's
just
my
take
on
it.
A
All
right
there
any
further
questions,
all
right,
and
so
next
is
me-
am
I
worked
on
so
I'm
still
working
on
the
JavaScript
side
of
API
is
I.
Basically,
as
I
haven't
heard,
any
any
bad
things
about
the
new
API
I
just
started
to
implement
it
to
see
if
it
actually
works,
looks
pretty
good,
so
far,
I
hope
to
really
get
it
wrapped
up
in
one
or
two
weeks,
you'll
see
in
there
we
can
start
integrated
properly
and
yeah
next
yeah.
Any
questions
on
this
nope.
C
The
other
thing
is:
why
do
you
think
it
takes
like
two
weeks
to
finish
the
base
implementation
to
then
go
into
the
integration
to
the
rest
of
the
code,
but
it's
like
what
is
the
the
big
chunk
of
work
that
that
on
the
IP
LD
module
that
will
take
two
weeks
and
is
there
anything
that
we
can
do
to
help
you
achieve
that
sooner?
It's.
C
A
A
Right,
all
right,
and
but
but
as
so,
yes
so
I
will
edit
to
my
to
my
notes
that
so
far
it
looks
good.
So
basically,
the
tunings
FS
part
works
with
the
new
API
and
that
that's
promising,
because
that's
the
huge
part
of
so
this
could
be
the
biggest
user
in
Chase.
Ipfs
is
a
five
Cody
is
the
tuning
safest
part,
and
that
already
works.
So
the
other
part
should
be
hopefully
be
simple
policy
all
right.
A
B
Mostly
get
on
the
review
discussion,
I
believe
last
week's
interactive,
the
constraint
document,
the
next
more
the
same
and
hopefully
deal
with
the
job,
except
all
the
comments
basement
fix
document
based
on
review
comments,
yeah
and
potentially
documents
in
the
definitions,
I'm,
not
sure.
If
I
understand.
C
E
F
Yeah
so
terms
actually
doing
stuff.
Just
trying
to
you
know
get
used
to
using
are
kill
day
so
I
switched
the
stuff
I
was
using
tease
out,
kill
D
instead
of
using
protobufs
and
live
on
the
right
direction.
I'm
happy
to
be
a
go.
Ipl
D,
prime
guinea
pig,
if
required,
given
that
it's
just
like
another
set
of
eyes
and
it
doesn't
really
affect
anyone
if
it
breaks
and
then
I
just
said,
a
couple
of
questions
which
I
just
either
get
people
thinking
or
I
just
get
feedback
from
people
who
thought
about
this.
F
More
than
I
have
so
I
have
two
issues.
One
is
I'm
trying
to
synchronize
a
set
of
commits,
basically,
and
in
order
to
be
able
to
do
that,
you
need
to
have
a
shared
route
so
that
you
can
actually
synchronize
and
combine
the
two
graphs
together
and
the
graph
the
route
might
just
be
a
name,
but
names
aren't
really
things
you
should
be
throwing
around
as
commits
so
I'm,
not
really
sure.
If
anyone
has
thought
much
about
this
or
whether
you
know
how
these
types
of
things
work,
I
have
something
that
does
works.
B
B
Object,
that's
commit
object,
it
points
to
previous
commit
Beckham,
it
points
to
parents
and
parents
and
parent,
and
they
all
point
to
different
roots
and
then
like
you
would
start
it
like
the
the
to
fork
roots
or
said,
if
you
for
commits
who
walks
back,
and
so
you
find
a
common
commit
and
then
try
to
some
babies,
do
it
gif
does
that's
at
least
what
I
would
do.
Is
that
answer
your
question?
Is
that
totally.
F
Not
not
quite
because
I
guess,
maybe
think
of
it
like
this.
Every
time
you
start
a
new
get
repo
and
github
they
have
like.
It
has
like
the
same
empty
object
in
which
means
that,
in
theory,
every
object
on
every
object.
Every
repo
on
github
has
the
same
parent.
Not
quite
actually
it
doesn't.
It
was
simply
they
dumped
right
because
there's
like
a
name
that
differentiates
them
I,
don't.
B
F
B
G
Yeah,
no
students,
bang
on
you
to
people
committing
the
same
stuff
and
get
because
the
commit
message
itself
includes.
Timestamp
you.
Even
if
you
you,
the
same
person
write
the
exact
same
commits
at
different
points.
Instances
in
time,
you'll
get
different,
commits
hashes,
and
so
they
won't
be
the
same
action.
So
any
get
commit
references,
a
root
of
a
tree
which
is
the
actual
file
hierarchy
that
will
be
the
same
see
and
you
can
use,
gets
plumbing
tools
to
actually
pull
out.
G
That
graph
base,
which
kit
does
to
do
comparison,
work
but
there's
a
separate
section
that
contains
sort
of
the
information
which
will
always
change,
and
so
when
get
tries
to
resolve.
And
so
that's
where
the
get
naming
system
comes
into
place.
And
that's
where
you
see
like
rats
and
refs
are
all
all
just
pointers
to
commit
hashes
and
so,
as
Steven
had
been
saying.
B
Guess
the
difference
here
is:
we
don't
have
that
other
brand
of
entropy
like
we're?
Not
you
were
probably
not
going
to
always
like
have
like
date,
stuff
like
that
I
think
you
may
be.
This
is
one
of
the
things
trying
to
make,
but
I
think
what
actually
makes
sense
like
you
make
it
like
the
idea
and
ASCII
or
something
like
that,
like
the
root
object,
I
think
all
the
branches
say
like
this.
This
thing
at
the
bottom
is
like
the
gorillas,
gonna
notice.
A
yeah
I
can
just
keep
it
some
policies.
B
It
describes
how
emergency
should
be
done
and
how
this
object
should
like
behave.
That
would
actually
be
a
reasonable
route,
but
yeah.
F
B
So
like
that,
actually
because
it's
reasonable
person
I,
would
have
a
more
complex
object
that
describes
like
you
could
even
name
it
or
whatever
you
want.
Somebody
like,
like
I,
have
somehow
named
this
thing,
and
then
you
put
that
it's
rigged.
It's
kind
of
weird,
like
the
name,
doesn't
point
to
anything.
It's
everything
that
points
in
the
name
but
I
think.
G
B
You'll
be
also
done
washing
rivers
because
it
actually
has
to
be
a
route
either
so,
like
you
have
like,
because
the
bottom
one
doesn't
actually
immerse
in
the
bottom.
Entry
doesn't
have
a
parent,
it
just
is
no
parent,
but
in
every
single
commit
can
point
to
the
same,
like
name
and
the
means.
Every
single
object
was
like
this:
okay,
okay,
like
I'm
a
part
of
this
universe,
and
that
guarantees
you
have
uniqueness,
lovely.
G
G
B
F
Any
thoughts
on
what
happens
when
we
want
to
when
we
want
to
sort
of
break
our
links,
so,
for
example,
if
I
want
to
squash
my
previous
hundred
commits
into
a
single
state,
I
should
probably
allow
like
providing
both
options.
Like
say,
the
link
is
here:
if
you
want
to
verify
it,
but
like
I
I
think
II
promise
you
it's
actually
this
thing
well
yeah.
You
can
check
both
okay.
B
B
But
the
trick
people
heard
new
hashing
algorithms
I
think
wind
up
like
we
have
large
tables
like
that's
like
the
the
end.
Like
final
thing,
you
can
do
or
basically
have
a
large
trusted
table,
didn't
absol
the
new
hashes
I
hope
we
never
have
to
get
there,
but
with
Collinsville
someday.
Eventually,
we
could
do
that
later.
D
Some
quick
mentions
on
compressing
stuff
into
checkpoints:
I,
don't
know
if
you've
heard
of
the
Google
trillion
project,
but
they
have
some
really
nice
short
terse
white
papers
about
their
a
log
oriented
mapping.
Data
structure
like
a
like
a
blockchain
and
I
can't
remember
the
technical
term,
but
they
have
some
good
write-ups
on
ways
to
do:
checkpoints
with
bounded
rechecking
time.
There
might
be
some
good
reference
material.
You.