►
From YouTube: 🖧 IPLD Every-two-weeks Sync 🙌🏽 2019-06-10
Description
A meeting every two weeks to sync up on all IPLD related topics. It's open for everyone and recorded. https://github.com/ipld/team-mgmt
A
I,
look
at
a
different
thing:
it
automatically
does
that
so
I
wasn't
trying
to
look
at
the
document,
but
anyway,
okay
I'll,
do
my
update
real
quick.
A
So
that's
like
most
of
what
I've
been
up
to.
Oh
and
I
wrote
the
generics
back
up
as
well,
which
is
like
I'm,
not
super
happy
with
the
spec.
Actually
after
talking
to
Eric
in
particular
like
just
a
huge
amount
of.
It
is
very
specific
to
how
we'll
implement
this
in
JavaScript
and
in
web
assembly,
and
so
I
think
I
might
break
off,
like
maybe
half
of
it,
into
a
document
that
was
just
about
to.
C
D
Don't
think
I
have
the
right,
but
that's
okay,
so
yeah
I've
been
thinking
a
lot
about
the
generic
C
stuff,
which
I
think
is
the
artist
formerly
known
as
advanced
layouts
and
I
just
pasted
some
new
gist.
It's
probably
belongs
as
either
and
if
you
were
turning
into
a
PR
or
something
but
still
there's
a
bunch
of
to
dues
in
it.
So
I
copied
and
pasted
it
a
guest
in
the
last
60
seconds
before
the
call
started.
D
D
Though
the
the
key
part
of
this
in
progress
right
up
is
going
back
to
me
determining
all
of
the
critical
decisions
that
need
some
thought
as
we
do
this
advanced
data
engineering
stuff
and
trying
to
give
those
a
couple
of
names
and
consider
like
how
many
of
these
things
are
orthogonal
to
the
others
are,
like
you
know,
make
progress
that
way.
So
I
think
some
of
this
is
stuff.
We've
actually
talked
about
in
person
before
and
a
smattering
of
times
and
I'm,
just
trying
to
like
put
names.
D
Referencing
is
the
problem
of
how
do
we
refer
to
a
particular
system
for
advanced
data
manipulation
and
then
having
the
implementation
is
where
we
get
into
like
okay,
what
what
is
was,
and
how
do
we
hash
will
Azzam
you?
How
do
we
refer?
How
do
we
get
other
code?
If
there's
a
native
implementation?
How
do
we
connect?
All
of
those
dots
is
slightly
different
than
the
referencing
problem.
Just
because,
when
we
get
to
concretely
having
the
implementation,
then
we
get
I
mean
just
where
the
rubber
hits
the
road
is
that
a
neck
yeah
thank
ya.
D
A
Yeah
I
think
like
I'd,
like
to
change
signaling
to
like
self
description,
because
I
think
that
it's
a
question
of
like
whether
or
not
these
are
self
describing
or
not
to
me
at
least,
and
then,
if
they're
not
self-describing.
If
we
should
have
cut
that
like
what
we
were
calling
him,
then
singling
then
your
think
particularly
like
skip
to
the
second
point
right.
B
So
just
just
tune
into
Jake
sorry.
This
is
a
little
bit
of
a
distraction,
but
I
did
I
did
put
some
of
the
notes
from
there
al
a
Berlin
meeting
into.
They
still
had
a
pull
request
in
the
IP
LD
repo
and
I
did
have
the
three
these
three.
This
is
where
you
first
started
outlining
those
three
problems,
but
they've
got
different
names
there.
If
you
scroll
down
to
just
search
for
signaling
actually
in
the
documents
there.
So
that's
the
history
of.
D
D
I'm
still
I'm
still
needing
to
write
a
bunch
more
about
that.
The
bar
to
clear
before
we
get
like
a
coherent
PR
out
of
it.
That's
worth.
Review
of
a
bunch
of
people
is
like
really
quite
high,
so
in
trying
to
to
figure
out
how
to
make
progress
on
that.
You
probably
saw
that
I
posted
a
comment
on
the
PR
that
I
have
outstanding
right
now,
which
basically
says
don't
review
this
anymore.
D
There
are
more
drafts
yet
and
yeah
so
I'm
sitting
here
with
like
five
different
drafts
on
my
local
host,
and
some
of
them
haven't
actually
like
reached
the
escape
velocity,
where
prepared
them
to
be
individually,
PR
and
I
kind
of
don't
want
to
spam
people
in
that
way
either.
So
what
I'm
trying
to
do
now
is
create,
like
a
systemic
review
of
all
the
different
directions
that
have
gotten
at
least
a
little
exploration.
D
We've
gone
from
like
the
three
older
drafts
that
are
all
issues
than
in
the
recent
generation.
Since
Volker
and
I
have
been
working
on
iterating
together,
we
can
flat
stack
those
with
our
iteration
that
was
recursive
draft.
There's
been
two
or
three
of
those
which
are
like
slowly
sussing
out
small
issues.
The
most
recent
ones
that
I've
been
trying
to
work
on
are
separating
Explorer
versus
natural
concepts.
So
one
of
the
little
bit
like
the
where
clause
in
SQL
and
the
other
is
a
bit
more
like
the
Select
Clause
itself
and.
D
Trying
to
figure
out
how
to
get
that
to
recurse
correctly
and
smoothly
and
pleasingly
has
been
really
tricky.
There's
all
sorts
of
questions
like
what,
if
I,
want
to
explicitly
match
and
get
a
callback
on
a
node.
That's
in
the
middle
of
an
exploration!
That's
going
to
continue
so
trying
to
figure
out
how
to
make
that
feel.
Good
has
been
really
really
big
and
tricky,
so
I
think
most
of
the
problems.
There
are
no
identified,
it's
just
a
matter
of
figuring
out
how
to
make
all
of
this
look
good.
D
One
of
the
most
recent
good
ideas
I
had
somebody
else.
Feed
me
during
some
conference
times
was
maybe
trying
to
hoist
the
idea
of
named
matches
from
the
Reg
X's
and
used
that
sort
of
concept
for
how
to
indicate
a
mat,
reverses
and
explore,
and
that
might
make
some
stuff
look
good,
still
working
on
that.
But
I.
B
D
B
D
Yes,
I
think
that
might
be
a
cool
idea
and
we
can
yeah
I,
don't
know
that
one
still
needs
a
little
more
iteration.
A
couple
of
the
more
complicated
examples
I've
been
throwing
at
myself
over
this
time
had
also
started
to
make
a
little
sense
with
that.
It
turns
out
I
think
the
latest
draft
now
has
Explorer
and
mattre
concepts
started
getting
closer
to
each
other
again
and
maybe
they'll
be
the
same,
because
the
matcher
is
just
when
you
got
a
name
to
it,
but
then
instead
there's
now
a
another
subsection
of
the
schema.
D
D
So
I
think
that
I
think
that
features
gonna
make
Steven
happy.
For
starters,
there's
a
couple
of
other
like
applications.
I
have
that
it
seems
to
be
in
useful
for
like
if
you
have
an
array,
and
you
want
to
recursion
to
objects
in
the
array,
but
only
one
there,
like
name
property,
is
set
to
the
bar
or
something
like
this.
D
D
A
One
thing
we
didn't
talk
about
it
now,
but
we
should
like
sort
of
put
the
thought
out
there
and
think
about
it
long
term.
It's
like
how
do
we
calculate
and
describe
the
cost
of
particular
selectors
as
you
go
along,
we
we
don't
have
any
of
the
nice
things
that
you
get
out
of
like
sepals
grab
you
out
to
do
this
up
front,
so
I.
D
B
D
A
D
E
A
Think
it's
like:
we
need
to
make
sure
that
were
mangles
together
and
I.
Don't
know
if,
like
there's
some
questions,
that
we
need
to
answer
in
the
future
like
if
you
get
a
map,
it's
on
order,
and
so
it
doesn't
have
a
range
thing
or
are
you
getting
an
array
for
that
matter
like
so
you
get
a
list
and
it
doesn't
have
an
ability
to
do
slices
on
it.
You
can
only
iterate
over
the
full
thing.
A
B
So
you
know
just
aiming
for
more
plug
of
ability
and
that's
leading
to
some
interesting
changes
in
my
original
assumptions,
and
they
were
the
biggest
one
being
the
traversal,
the
block-by-block
traversal.
Originally
the
way
I
built
it
was,
you
would
give
it
a
way
to
get
new
blocks.
So
you'd
say
here's
how
you
get
new
blocks
when
you
need
them
and
replace
that
with
a
a
traversal.
It
just
does
one
block
and
then
stops
and
says:
look
I've
done
this
block.
B
But
if
you
want
me
to
continue,
then
you'll
have
to
give
me
a
new
block
identified
by
this
thing
and
it's
up
to
you
whether
I
continue
or
not.
So
it's
this.
It's
just
breaking
down
the
algorithm
into
how
to
traverse
a
block
and
then
it's
up
to
the
the
interfacer
to
decide
how
far
to
keep
going
and
that's
coming
up
with
some
interesting
api's
I've
got
a
hashmap
sled
I'm,
calling
it
a
hash
map.
I'm,
just
I'm
just
done
with
him
to
K
I've
got
a
hash
map
spec.
B
It
does
say
that
it's
a
Hampton,
but
it
doesn't
say
that
in
the
title
and
it's
it's
nearly
complete
I'll,
probably
I
would
expect
up
having
him
today.
I
nearly
finished
on
Friday
I
I,
as
I
got
into
discussion
of
the
designs
design
decisions
I
started
second-guessing
some
of
the
choices
that
were
being
made
but
I
think,
instead
of
making
major
proposals
for
change,
I'll
just
go
ahead
with
what
I've
got
and
flag
at
the
bottom
offered
potential
future
areas
for
research.
B
So
right
now
what
I've
got
is
very
similar
to
what
Jeremy
originally
put
in
his
back.
So
this
it's
not
it
shouldn't
be
too
controversial,
so
shouldn't
be
I,
don't
imagine,
it's
gonna
be
hugely
difficult
to
get
to
consensus
on
it,
but
there's
there's
definitely
area
of
areas
for
research
in
how
these
things
perform
and
whether
some
other
decisions
we've
made
a
appropriate
and
I.
Just
don't
think
we
know
until
we
do
that
research
and
I
don't
think
that
research
is
going
to
be
done
any
time
soon.
B
So,
let's
put
that
off
into
the
future
and
take
the
best
guests
now
and
then
one
day,
I'm
sure
we'll
have
people
coming
along.
Using
these
things
doing
research
and
saying
hey
these
decisions,
you've
made
a
poor
so
may
as
well
flag
them
now
and
they're
interesting
areas
to
pursue
me
into
the
future.
So
that's
what
I'm!
That's
mainly
what
I'm
doing
and
the
other
thing
I
have
been
doing-
is
getting
into
other
data
structures.
I'm
really
keen
to
get
on
to
sorted
collections.
I've
been
toying
with
the
idea
of.
B
So
most
interested
about
in
in
red
black
trees
and
AVL,
trees
and
I
think
I
think
you
can
come
up
with
an
algorithm
that
actually
does
both
because,
like
a
red,
black
tree
can
be
an
AVL
tree
and
vice
versa.
There's
just
got
slightly
different
rules,
but
the
difficulty
with
those
two
collections
is
in
how
they
would
spend
blocks.
B
So
where
are
the
block
boundaries,
because
if
you
did
one
block
or
node
you'd
end
up
with
lots
of
tiny
little
nodes
which
would
just
be
garbage,
so
you've
been
thinking
about
the
possibility
of
packing
a
bunch
of
nodes
into
a
single
block
and
then
just
having
a
boundary
where
you
know
you
get
to
a
certain
layer
and
then
it
has
to
hop
out
of
the
blocks,
and
so
what
is
the
algorithm
for
deciding
how
to
do
that
packing?
What?
What?
How
do
you
decide
where
those
boundaries
are?
I?
B
B
But
again
it's
one
of
those
things
that
you're
making
really
potentially
big
trade-offs,
and
you
just
don't
know
where
those
trade-offs
are
good.
Without
really
in-depth
research
so
got
to
draw
a
line
somewhere
about
how
much
risk
I
do
versus
just
getting
to
something
that
works,
but
that's
that's
what
I
anticipate
doing
for
in
the
near
future,
depending
on
how
Michael
stuff
evolves
and
how
much
I
have
to
get
involved
in
that.
D
B
So
I
tried
to
deal
with
some
of
that
in
the
in
that
collections.
Multi-Block
collections
docked
in
this
Beck
repo
and
I
had
a
like
a
3,
a
3
by
2
table,
and
it's
got
those
three
things
as
the
completely
random
there's
the
ordered
black
instruction
and
ordered
by
key
I
think
I
called
them
and
they're
up
there.
B
D
A
I
mean
you
just:
you
have
to
pick
completely
different
structures
in
different
cases.
I
turn
oblique
trade-offs
for
a
lot
of
them,
like
after
I
built
this
array,
implementation
that
you
just
needs
all
up
front
I
realized
like.
If
you
know
that
you
need
all
the
data
upfront
you
can
make
it
really
efficient.
B
A
The
operations
that
are
incredibly
efficient
and
you
don't
have
to
do
scans
that
Burger,
so
there
are
really
big
advantages
to
doing
things
that
way
when
that's
accessible
and
then
the
case
of
UNIX
FS
we
effectively
like
always
have
to
do
it
that
way,
we're
like
a
chunked
for
like
a
big
piece
of
chunked
binary.
We
stick
that
into
a
multi-block
array.
We
always
have
all
the
data
up
front.
Like
you,
you
always
reach
hunk.
The
whole
data
structure.
B
B
But
it
leads
to
some
very
sophisticated
algorithms
that
can
do
serve
multiple
purposes
and
that's
why
I
think
the
Java
collections
library
is
a
rich
source
of
these
algorithms
because
of
that
challenge.
But
it
also
points
to
the
challenges
for
us
as
implementers
of
essentially
an
API
that
people
are
going
to
use
when
a
lot
of
our
users
are
not
going
to
care
or
even
want
to
understand
that
the
distinction
between
them.
So
we
have
to
give
them
things
that
just
work
and
then
cross
our
fingers.
They're
gonna
work
for
a
use
case.
I
mean.
A
Api
right,
like
even
looking
at
the
the
thing
that
I
just
did
the
woman
I
just
did
there's
that
array,
like
nobody,
actually
creates
that
array
directly
right
now,
like
you,
have
a
chunk
binary
type,
the
uses
that
when
the
set
is
big
and
so
like-
and
it
knows
that
like
that
is
being
when
it
knows
the
use
case
for
the
sort
of
chunked
binary
pipe,
and
it
knows
that
it
lends
itself
well
in
that
data
structure
right.
So
it
sort
of
covers
up
that
decision
and
says,
like.
A
B
But
the
challenge
of
good
API
design
is
making
sure
that
you
know
you
defer
that
process
whereby
somebody
in
the
future
has
to
come
along
and
uncover
all
of
those
layers
to
figure
out
why
their
stuff
isn't
performing
like
the
IPL
tjs
I,
peeled
ipfs,
which
is
which
really
was
that
process.
Let's
look
through
all
these
layers
and
see
where
all
the
bad
decisions
were
made
and
it
turns
out
that
there
are
ballplayers,
let's
try
and
defer
that
as
much
as
possible.
B
A
A
Ok,
so
let's
come
back
to
this
document,
real
quick,
so
one
thing
I
want
to
kind
of
make
clear
up
front.
I
do
see
all
the
work
that
we're
doing
right
now.
I
have
something
of
a
stopgap
on
the
way
to
this
being
and
webassembly
like
it
is
not
tenable
long
term
to
be
configuring.
The
implementation
of
every
one
of
these
data
structures
and
having
out
this
so
like
to
you,
know,
referencing
and
having
the
implementation
like
our.
So
let's
actually
get
rid
of
like
making
those
not
offend.
A
Not
a
factor
like
it
is
just
built
in
the
book
system
but
like
it
knows
how
they
go
and
look.
These
does
assuming
that
they
are
like
within
the
network,
so
yeah
like
that,
and
that's
one
of
the
reasons
why
the
self-description
mechanism
is
so
important,
because
eventually
the
self-description
mechanism
will
be
enough
to
do
everything
else
right.
You
won't
have
to
do.
You
won't
have
to
layer
on
knowing
out
the
implementation
actually
be
able
to
like
the
system
will
just
be
able
to
go
out
and
get
them
automatically.
D
And
you
couldn't
say
that
there
will
only
be
one
answer
to
each
of
these
things
eventually,
but
I,
don't
think
that
removes
them
from
the
design
space
now
or
indeed
ever.
It
just
means
at
some
point.
We
pick
one
space
in
the
design,
space
and
disregard
all
others,
but
we're
definitely
not
there
and
it
doesn't
make
it
right
to
pretend
they're,
not
a
factor
in
the
meanwhile,
no.
A
No
no
I
mean
I.
Think
they're
like
it
is
a
valid
concern
that
we
are
reserving
this
property
and
we
need
to
understand,
like
all
of
the
implications
of
preserving
the
property
right,
even
if
it's
just
at
this
higher
layer,
but
like
one
of
the
reasons
why
I'm
so
right
now,
the
identifier
is
a
string
and
then
we
go
to
web
assembly.
A
It
just
becomes
an
object
that
it's
specifically
so
that
it
just
clubbers
the
old
implementation,
eventually
that
we
thanks
impeccably
like
when
we
move
on
to
the
web
assembly
stuff
we're
like
just
not
doing
any
of
this,
but
eventually
more
and
it's
a
much
kind
of
cleaner
transition
that
it
doesn't
require
us
to
use
any
more
additional
namespaces
for
anything.
And
that
is
like
very
intentional,
like
that.
That
is
know
that
we
are
like
trying
to
get
to
and
yeah.
A
D
A
Yes,
so
so,
okay,
I
I,
think
I
said
that
incorrectly
right
now,
Eirik
you
were
we're
requiring
that
the
user
can
figure
something
upfront
that
helps
you
make
that
connection
right.
So
if
you
look
at
the
current
like
generics,
librarian
Jas,
you
say,
oh,
like
you
know,
I
have
an
implementation
of
this
particular
string.
That's.
C
A
We're
okay,
I
got
this
string
now,
I
need
to
figure
out
how
I
associate
that
string
with
an
implementation
and
then
I
need
to
go
and
get
the
implementation.
I
need
to
have
it
around
and
have
it
configured.
Those
are
like
those
are
tied
together.
Essentially
it's
the
same
problem
than
the
Jo
stack
right
now,
but
I
can
see
how
they
can
be
different
to
you.
What
do
you,
but
eventually
we
factor
that
out
like
that.
That
is
not
anything
like
that
is
one
implementation
of
how
to
like
do
this
thing.
A
D
A
So
they're
all
kind
of
connected
right,
but
I'm,
saying
say
there
is
a
signal
already
that
we
have
the
a
signaling
mechanism
of
some
kind
whatever.
A
If
you
want
to
change
it
from
the
one
that
was
configured
in
the
self-description
right,
so
itself
describes
that
I
am
this
thing,
and
if
you
wanted
to
change
that,
then
you
would
use
a
schema
to
chase
it.
But
but
they're
like
it
is
what
I'm
saying
is
that
it's
static
right?
The
only
way
to
mutate,
it
is
to
like
mutate,
the
state
of
the
actual
data,
which
means
using
this
key
in
the
future.
In
the
web
symbol.
A
Like
dirt,
so
here's
what
I'm
saying
there
is
no
API
and
like
for
you
to
say:
hey.
Here's
like
a
web
assembly
data
structure
for
this
particular
data
thing
like
that's.
No,
it's
part
of
the
self
description
period.
If
you
want
to
mutate
the
self
description.
Fine,
but
like
that's
the
only
way
where's
like
now,
because
we
have
to
get
these
implementations
out-of-band,
look
like
entirely
like
I
acted
I
have
to
hand
you
my
JavaScript
presentation
of
every
data
structure
in
order
for
the
system
to
work
like
we.
A
Like
okay,
this
is
this
is
sort
of
what
I'm
saying
if
we
haven't
expect
for
how
to
run
these
when
the
sembly
functions
right
and
how
to
how
to
do
these
operations
on
these
data
structures.
If
I
have
a
path
that
doesn't
even
need,
these
data
structure
is
but
goes
through,
multiple
walks.
You
are
going
to
have
to
have
some
kind
of
resolution
mechanism
to
go
out
and
get
those
blocks
right
and
and
traverse
your
way
through
the
structure.
A
If
you
support
this
generics
system,
you
need
an
implementation
of
this
engine
that
we're
talking
about.
They
can
run
the
globe
assembly
functions
and
nothing
else,
because
everything
you
would
need
in
order
to
go
and
get
all
of
the
data
to
do.
These
operations
is
attached
to
the
data
structure,
just
like
any
other
data.
A
D
A
Like
no
no
like,
like
look
at
the
JavaScript
invitation
now,
even
the
job
is
communication.
Now,
with
all
these
functions,
doesn't
get
a
link
loader,
it
doesn't
get
anyone
like
it
doesn't
like
you.
If
it
wants
more
data,
it
has
to
basically
pass
back
to
the
engine
a
reference
in
the
data
that
it
wants.
Then
it
gets
that
new
data
adds
in
continuation
into
the
same
function.
So
it's
like
every
function
calls
atomic
to
one
decode
and
that's
like
it's
designed
that
way,
so
that
we
can
just
pop
the
web.
Somebody
stuff
right
in
its.
B
D
D
So
I
can't
pop
my
own
stack
here.
What
problem
we
solving
with
this,
like
I,
guess,
I,
believe
that
I
think
whether
or
not
there's
a
link
loader
interface,
that
whether
somebody
can
call
and
whether
or
not
it
returns
continuations
is
the
commentation
detail
that
I
don't
super
care
about
either
way.
We
need
some
specification
what
those
things
are
and
will
inevitably
version
that
specification
itself.
B
B
A
A
Yes
and
the
the
the
problem
that
Eric
just
referenced,
which
is
like
we
need
a
version
of
that
spec,
but
the
version
of
the
engine
that
you're
using
web
assembly
is
also
encoded
in
the
data
structure.
To
talk
about
those
questions,
so
you
you
basically
need
an
implementation
of
that
and
remember
to
do
it
for
sure
for
that
version
of
that
spec.
But
that's
all
be.
D
A
D
A
C
D
D
D
For
example,
one
of
the
things
that
we
want
to
do
is
be
able
to
use
selectors,
for
example,
on
top
of
these
things,
but
conditionally
sometimes
I
might
want
a
selector
to
say
give
me
this.
No,
they
liked
what
they
were
doing
so
they
UNIX
efest
me
to
give
me
this
note
and
everything
underneath
of
it,
and
it
would
be
like
the
file
name,
is
what
I
asked
for
and
then
I
just
want.
D
The
whole
file
and
I
send
a
selector
and
says:
give
me
all
this
mm-hmm,
but
something
that
we
would
like
to
do
is
also,
let's
say
we're
going
to
be
good
and
cool
for
video
streaming,
which
means
we
want
like
functionally.
We
basically
want
the
left-leaning
tree
of
the
files
internals
first,
so
we
might
want
to
send
somebody
a
selector
that
says
that
so
then
it
would
have
a
bunch
of
path
segments
where
it's
gonna
use
the
fancy-pants
stuff
for
the
directories,
and
then
it
gets
that
file
note.
D
A
Yeah
yeah
the
clock:
that's
not
that
hard,
like
I,
do
a
bunch
of
stuff
them
like
right
now,
but.
B
I
think,
but
that
raises
the
point,
though,
that
you
still
you,
wouldn't
you
can't
use
webassembly
for
that
kind
of
thing,
if
you're
doing
it
more
manually,
so
you
need
to
fall
back
to
some
other
solution,
in
which
case
you
need
to
have
signalling
referencing
having
the
implementation.
You
come
back
to
those
three
distinct
problems,
because
you're
outside
of
you're
outside
of
the
webassembly
utopia,
and
you
need
to
then
go
and
fetch
some
other
piece
of
code
or
use
some
other
piece
of
code.
A
That's
implementation,
like
I
say
like
hey,
give
me
this
file
and
then,
when
I
get
back,
is
basically
like
the
note
implementation,
and
then
I
say
oh,
do
operations
on
this,
like
you
read
that
a
bit
stuff
like
that,
and
if
I
wanted
to
replicate
it,
I
was
literally
like
take
it.
Take
that
and
say,
like
hey
replication
structure
like
going
parts,
go,
replicate
all
the
data
underneath
it
and
then
it
would
actually
not
pay
any
attention
to
the
transcript.
They
would
just
like
you
straight
up
like
we're
looking
stuff.
A
So
that's
all
possible
now
because,
like
the
where
the
the
implementation
of
the
generic
stuff
lives
is
like
at
a
pretty
low
layer
where
you're
just
trying
to
perform
an
operation
on
something
and
if
you're
constructing
modes
of
operations
you're
actually
like
constructing
them
as
multiple
calls
into
that
system,
so
none
of
this
is
is
not
possible.
This
sort
of,
like
handing
off
between
paths,
traversal
that
sort
of
layer,
one
and
layer
two,
is
a
little
tricky.
A
In
particular,
we
have
this
issue
now,
where
were
using
the
speech
analysis
a
where
a
because
every
operation
can
return
like
a
target.
That
is
a
path
within
itself.
You
have
to
interpret
that
path.
Really,
interestingly,
where
you
take
the
current
decoded
data
and
you
traverse
it
basically
at
layer
1
until
you
break
out
of
that
block
until
you
hit
another
foreign
reference
and
then
you're
actually
traversing
like
at
that
higher
level,
because
now
you're
performing
operations
back
into
the
generic
system
and
I
mean
the
implementation
works.
A
B
B
I'm
sorry
can
I
just
reinterpret
what
you're
saying
to
see
if
we
can
do
right,
saying
that
that
these
concerns
go
away,
if
you
just
make
it
so
that
the
algorithms
can
be
powerful
enough
to
serve
all
these
needs.
So
if,
for
example,
we
needed
to
instead
of
doing
a
traversal
that
was
no
okay,
the
way
I
think
you're
saying
is
like
I
right
now
with
the
the
hashmap
stuff,
you
can
get
get
perform
get
operation,
but
you
might
want
to
do
something.
B
Maybe
there's
a
data
structure
where
get
is
significantly
more
expensive
than
it
has
so
you
know
you
could
either
fall
back
to
a
manual
looking
through
the
blocks
to
do
it
has,
or
you
just
extend
the
algorithm.
So
it
also
has
it
has
opera,
you
can
Dookie
Aki's
operation
to
iterate
over
keys
and
an
entries,
operation
or
values,
operation,
I!
B
Think
what
I
think
what
I'm
hearing
hearing
you
saying
is
that
you
don't
you
still
don't
have
the
problem
that
Eric
is
describing,
because
you
just
beefed
up
the
algorithm
to
perform
the
tasks
that
you
need
it
to
perform
in
all
these
cases,
and
if
you
need
to
do
synching,
then
that's
just
a
normal
blocks,
plus
plus
links
synching
operation.
Everything
else
goes
through.
The
algorithm
I
mean.
A
I
guess
I
had
one
more
question
about
that
particular
use
case.
So
in
this,
like
imaginary
data
structure,
like
I
mentioned,
it's
like
a
multi-block
array
of
all
of
the
data
right
like
to
make
this
an
actually
like
kind
of
complicated
replication
operation.
So
you
want
to
go
left
to
right
on
this
on
this
big
array.
D
A
Yeah
so
I
have
thought
about
this
problem
in
terms
of
I,
want
to
read
this
data
out
of
a
file
and
then
I
want
to
know
all
the
blocks
that
are
talking
so
that
I
can
just
replicate
that,
but
but
this
is
like,
assuming
that
I
actually
have
some
absolutely
or
that
I'm
gonna
do
the
flow'ry
operation
and
then
replicate
what
it
took
to
do
the
operations,
and
that's
actually
like
why.
This
is
one
of
the
reasons
why
everything
is
implemented
is
like
this
giant
recursive
generator.
A
That
does
everything
you
do
a
full
trace,
because
then
you
can
actually
see
all
the
block
lookups.
So
if
I
say
hey,
go,
do
this,
do
the
trade
operation
and
then,
like
I,
can
look
at
the
trace
and
they're
here
where
all
the
blocks?
Okay,
that's
my
replication
set
but
I,
don't
know
how
you
would
ya
figure
out
the
replications
that
without
just
performing
the
entire
operation,
which
so
what
what
you
do
in
Isis
is
that
you
would
not
send
a
selector
over
the
wire
to
replicate.
A
You
could
send
a
read
operation
over
the
wire
and
say
give
me
the
replication
set
for
it,
because
the
remote
and
already
have
set,
and
then
they
can
figure
it
out
quicker.
If
you
did
it
locally,
you
would
end
up
just
like
getting
the
block.
So
at
the
time
I
mean
it
would
still
be
relatively
efficient,
actually
to
do
the
operation
vector
because,
like
pretty
quickly,
you're
gonna
start
actually
streaming
data
out
and
then
by
that
point,
you're,
probably
getting
the
blocks
quicker
than.
B
Things
to
me
that
which
way
we're
heading
for
a
situation
where
that's
analogous
to
a
standard
library,
standard
library
with
collections
in
it
and
you
almost
never
in
these
download
libraries-
would
dig
into
the
data
structures
in
layout
in
memory
lay
out
underneath
them.
You
only
deal
with
the
interfaces
and
if
the
interface
has
only
give
you
certain
powers,
that's
all
you
get
yep,
that's
just
bad
luck!
B
Some
of
them
you
can
like
in
you
know,
say:
C++
you
could
you
can
sort
of
I
mean
C++
is
getting
more
difficult
now,
but
you
could
get
through
memory
pointers
and
actually
start
to
look
inspect
the
memory
than
the
way
things
are
laid
out.
But
mostly
you
just
never
would
do
that
because
you're
either
using
an
implementation.
That
does
what
you
need,
or
you
don't
have
all
you
have
to
write
your
own
essentially.
A
I
think
that
we,
you
do
have
a
set
of
important
concerns
that
I
do
want
to
capture
about
reserving
the
key.
The
keys
and
I
want
to
figure
out
like
what
are
methods
to
resolve
in
that
as
much
as
we
can
are
and
if
those
are
acceptable
or
if
we
need
to
try
to
find
some
other
method
of
self
description,
because
there
are
like
I
mean
I.
A
Don't
want
to
do
this
because
there's
a
another
huge
set
of
trade-offs,
but
we,
we
could
literally
say
like
okay
in
order
to
support
generics,
you
need
a
codec
that
allows
you
to
encode
data
that
is
transparent
to
the
data
model.
It's
like
not
in
the
data
model
and
that's
where
that
lives
right
like
I
mean,
if
that's
our
only
option,
that's
our
only
option
like
I.
Don't
want
to
do
that,
but-
and
we
can
explore
that
once
we
exhausted
sort
of
like
our
concerns,
if
we
can
remedy
them,
yeah,
yeah
I
think.
A
Yeah
I'm,
just
saying
like
we
have
space
to
explore
but
like
I,
think
that
the
self
description
stuff,
like
I,
hope
that
now
we're
somewhat
aligned
didn't
like
we
do,
need
a
method
of
self
description
and
it
needs
something
somewhere
and
and
if
it's
in
the
data,
if
we're
getting
it
out
of
the
decoder
block
data
and
that
effectively
means
that
we
end
up
reserving
some
kind
of
key
space.
I.
A
Don't
know
if
you
saw
my
last
black
message
so
that
I
did
realize
that
we
can
probably
get
out
of
having
to
reserve
that
key
space
anywhere
and
in
an
object.
So
it
would
only
be
at
the
root,
which
means
that
you
could
very
easily
just
implement
a
map,
generic
that
then
could
store
that
key
very
easily
yeah.
So
that
means
that
you
can
create
map
that
store
that
key.
B
D
This
schema
system
can
sit
on
top
of
the
data
model
layer
and
the
nose
face
at
the
data
model
layer
for
doing
all
sorts
of
these
single
stuff,
traversals
and
stuff,
and
the
interface
of
a
schema
node
are
the
same.
They
are
exactly
the
same
interface,
so
any
code
that
has
been
written,
which
is
generic
over
a
node
data
model,
is
still
generic
and
correct
over
node
at
the
schema
layer.
D
The
only
thing
that
the
schema
layer
does.
This
is
AG
more
logical
rules,
and
it
will
make
more
things
returning
errors,
but
the
structure
that
you're
programming
against
is
completely
identical
so
and
as
much
as
there's
any
more
rules,
it's
basically
the
ones
that
you
asked
for.
It's
all
intentional.
D
D
Okay,
there,
like
now,
if
I,
want
to
put
a
map
at
the
schema
layer
on
the
top
of
an
advanced
collection
that
shards
it
on
top
of
the
data
model,
and
some
user
wants
to
put
a
string
called
foo
in
it.
I
have
to
do
to
escaping
at
some
point
right
or,
let's
just
return,
an
error,
both
of
which
are
kind
of
awkward.
Where
does
me
escaping
them?
I,
don't
know
wherever
you
add
the
advanced
data
layout
stuff,
but.
A
D
D
A
A
D
C
A
D
A
So
anyway,
so
it's
slash,
then
an
object.
Then
a
type
robbery
would
be
how
it
would
break.
A
B
A
Mean
the
thing
about
already
somewhat
transparent,
like
there
are
a
bunch
like
there's
code,
all
over
the
place
that
will
just
miss
that
data,
in
fact
like,
even
if
we
cleaned
up
all
of
our
code
to
be
able
to
read
the
data
we
have
like
all
because
in
the
ecosystem
would
have
to
and
all
their
pathing
stuff
would
also
have
to
support
it
like
it's.
It's
just
incredibly
problematic
to
encode
data
into
that
key,
like
in
general,.
A
D
B
A
I
mean
I'm
already.
We
should
know
that
because,
like
yeah
I
think
that
we're
less
likely
to
have
into
a
slash
keys
and
then
we
are
into
understood
type,
so
it's
and
and
because
it's
already
problematic
in
a
number
of
ways.
Its
I
would
like
to
just
keep
that
as
an
interface,
where
we
reserved
things.
A
If
we're
going
to
reserve
a
key
inside
of
the
data
which
we
may
not
do
but
like,
then,
you
need
to
propose
something
else
that
is
within
the
data
that
actually
gets
encoded
in
the
block
somewhere,
even
if
it's
transparent
to
the
block
data.
In
order
to
do
the
self
description
like
we
need
another
option.
A
A
No,
this
is
like
if,
if
JSON
doesn't
work
and
there's
no
way
to
encode
it
into
valid
caissons
and
I've
got,
the
data
model
is
like
we
can't
say,
like
the
most
popular
encoding
mechanism
in
the
planet.
This
has
no
way
to
encode
the
state
of
this
ballad.
That's
crazy,
like
they're
I
mean
I
already
went
down
the
path
of
like
potentially
not
actually
using
JSON
in
big
JSON
and
putting
into
something
else
to
define
Airy
a
little
bit
better
and
the
place
that
you
end
up
at
is
like.
A
Oh
actually,
the
reason
why
you
want
the
block
of
JSON
is
it's
not
like
just
like
readability,
because
there
are
a
huge
number
of
API
is
out
there
cloud
and
otherwise
that
will
just
only
take
it
and
like
literally
some
in
the
binary
data
like
it
gets
all
of
it
gets
basics
before
it
anyway.
So
it's
actually
just
better
to
send
that
JSON
back
and
forth,
like
that's
the
that's
the
the
main
utility.
D
Of
having
it,
we
buy
all
the
utility
and
I
want
to
use
JSON
as
much
as
pop
I
am
a
fan,
but
it
is
not
an
IPL
d
native
codec
and
it
doesn't
matter
how
much
we
want.
The
point
of
the
data
model
is
to
define
the
I'm
going
to
use
the
C
word.
Rod
is
to
define
the
cardinality
and
the
set
of
things
that
are
representable,
and
then
we
can
talk
about
in
general,
and
all
of
the
other
products
are
like
hub
and
spike
thing.
D
A
D
A
D
A
No
there's
no
by
trade
support
at
the
moment,
but
but
there
is
space,
for
it
is.
A
B
B
A
B
E
A
A
Think,
like
yeah,
I
mean
like,
like
literally
like,
if
you
don't
have
a
solution
to
this
problem.
The
solution
is
to
take
this
back
like
and
just
say
like.
Okay,
now
we're
just
preserving
it
in
the
spec
at
the
data
model
layer
because,
like
there
has
to
be
some
way
to
accomplish
this
in
common
encoding
formats,
or
else
were
we
there's
no
point
in
even
having
a
data
model.
We
just
say
everything
needs
to
be
in
the
specific
implementation.
A
dead
fee
board
with
tagging.
D
A
D
D
D
A
A
A
D
A
D
D
Let's
say:
I
have
a
number
and
it's
going
to
mean
temperature,
but
I,
don't
know
what
kind
so
maybe
I'll
quote
a
C
or
an
F
with
it
right
and
then,
if,
but
then,
how
do
I
know
that
that
means
temperatures
see
what
if
it
means
like
credits
in
some
monetary
system
that
I've
never
heard
of
before,
and
they
answer
that
as
well,
then
you
look
at
the
bigger
context.
Like
is
this
in
a
field
and
a
bigger
object?
It's
called
temperature.
Well,
there's,
probably
temperature
right.
D
B
D
B
D
B
It
seems
it
seems
to
me
that,
isn't
that,
basically,
the
same
thing
is
what
Michaels
doing
where
the
root
block
is
the
special
thing.
It's
it's
one
layer
out
from
most
of
the
data
you're
just
wanting
to
push
it
yet
another
layer
out,
because
if
it's
in
the
root
block,
it's
it's
a
place,
usually
make
it
a
place.
That's
separate
from
them.
I
think.
A
That
Eric
is
proposing
that
the
two
things
are
applied
in
parallel,
so
you
have
the
graph
of
data
and
you
have
the
schema
for
the
data
and
the
application
is
applying
them
and
I'm
like
I.
Don't
think
like
that,
isn't
reasonable
that
doesn't
give
us
data
structures
that
stretch
the
internet,
because
you're
not
going
to
like
have
a
schema
for
like
that
much
data.
Like
the
data
like
once,
you
start
traversing,
you.
A
We
need
to
assume
that
the
data
that
you
parse
through
in
a
path
is
relatively
unpurchased
and
we
need
to
resolve
just
encode
automatically
in
the
engine.
This
is
this.
Is
why
I
like
don't
like
webassembly
stuff,
we
need
to
be
able
to
resolve
all
of
this
just
automatically
for
a
user,
because
without
that
then
we're
essentially
in
like
you
know,
this
is
like.
Like
goes
package
manager
versus
JavaScript
right,
we're
like
go
is
like
no
just
install
and
manage
every
package
by
hands.
A
D
Like
I
acknowledge
all
that
and
I'm
still
not
seeing
the
problem,
we
have
two
different
well,
okay.
We
probably
have
several
different
users
charts
for
what
links
and
traverses
you
do,
but
one
of
them
is
replication
and
that
needs
to
work
at
the
scale
of
the
Internet
and
your
infinity
terabytes
without
advanced
knowledge,
yeah.
B
D
D
B
D
D
A
A
A
So
it's
really
like
imbalance
of
the
what
you
would
think
of
as
immutability
guarantees
be
cut
because,
like
when
I
have
this
subtree
and
when
I
have
this
bigger
tree.
A
born
operation
here,
abscess
woman,
gonna
pass
and
here
the
here
at
the
same
thing,
I
should
get
the
same
thing
back,
but
this
what
would
allow
you
to
mutate
that,
because
you'd
be
able
to
apply
these
schemas
like
as
you
traverse
your
way
down,
like
that's,
that's
very
problematic.
A
Talking
about
like
this
is
just
like
a
lot
of
information
in
context
that
she's
passed
over
and
then
a
lot
of
hazards,
and
you
work
your
way
down
and
also
like
who
who
wins:
they're
like
if
I
link
to
somebody
and
I
say:
here's
a
schema
and
that
and
that's
deep
and
it
talks
about
the
schema
thief.
And
then,
when
I
turn
this
into
the
tree,
it
says
something
else
to
blood
like
either
you're
gonna
say
the
root,
most
always
wins:
they're
the
last
person
to
link
to
it
so
effectively
the
last
right.
A
A
Like
like,
if
I,
if
I
need
to
see
your
data
and
I
get
your
data
and
then
I
want
to
link
to
it,
I
now
need
an
I.
Don't
just
need
the
information
about
the
data.
I
need
an
information
about
the
link
that
got
you
there,
so
we
like
every
system
that
uses
this
is
going
to
have
to
keep
around
like.
This
is
a
large
reference.
It's
not
just
going
to
be
us
the
idea.
If
you
like
a
lot
more
data,
you
know
link
practically
done.
A
Too,
pretty
it's
a
pretty
big
departure
from
not
just
how
we've
done
links
so
far,
but
also
just
in
how
we've
constructed
all
of
our
libraries
in
this
I.
Don't
know
a
single
place
where
in
operation
on
a
sub
trees
or
on
a
larger
tree
that
just
reverses
into
that
sub
tree
actually
has
variances
in
behavior.
A
No,
but
that
would
that's
a
different
reference,
like
that's,
literally,
not
part
of
the
same
tree.
So
if
I,
if
I
swap
out
a
reference
from
raw
to
see
border,
that's
not
a
traversable
path,
anymore,
like
it
just
it
ends
or
if
I.
If
I
change
the
codec
and
it's
invalid,
then
it
actually
literally
throws
right
like
that.
You
can't
there
are
cases
where
you
can
change
it
and
then
just
make
it
fail.
A
D
A
C
D
B
Cloud
recordings-
oh
yeah,
I,
feel
like
this
I
one
of
the
problems
we
taking
notes
for
this
is
that
there's
a
lot
of
context.
That's
in
slack
from
you
and
Michael
having
a
long
discussion
and
I,
don't
feel
like
I'm
capturing
the
essence
of
because
I
don't
feel
like
I
fully
even
understand
it.
I
think.
D
B
D
That
makes
sense
if
we
can,
where
I'm
trying
to
get
is
if
we
can
pivot
the
signaling
design,
do
a
choice
between
like
the
de-facto
nonsense.
We
have
now
versus
something
explicit
that
might
be
based
on
schemas,
but
doesn't
matter
it
just
has
to
be
explicit
and
like
parallel,
Traverse
empowered
versus
the
in-band
thing
like.
We
can
also
carry
on
the
explicit
parallel
traversal
powered
thing
without
technically
blockage
of
schemas,
and
we
can
get
a
bunch
of
code
written
with
the
de
facto
signaling
stuff
as
well.
B
So
this
is
this
is
what
I'm
trying
to
still
trying
to
get
my
head
around
what
you're
the
way
you're
both
described,
things
that
are
in
your
head
to
me.
It
seems
like
what
you're
talking
about
is
analogous
to
in
HTML
when
you
reference
things,
you
might
say
hrs.
This
is
a
a
href
which
is
that
this
is
another
page
that
you
can
load
versus
an
image
tag
or
a
link
tag
for
a
CSS
thing
or
a
script
tag.
D
D
All
right
so
I,
don't
think
self
description
is
bad,
but
I
think
having
it
be
built-in
and
the
spec
require
that
it
trigger
action
would
be
insane
like
imagine
if
we
had
a
file
system
where,
if
something
had
a
dot,
jpg
extension,
you
are
not
allowed
to
open
it
with
a
plain
text
editor
that
would
not
be
something
you
want
to
do
often,
but
also
it
would
be
truly
bizarre
if
you
couldn't
choose
to
do
it
right.
Well,.
B
B
That's
pretty
common,
like
in
the
the
jQuery
metaphor
that
we're
sort
of
talking
about
on
the
JavaScript
side,
where
you
interpret
the
Dom
through
these
jQuery
lens,
and
you
get
back
these
jQuery
things
that
are
representative
of
this
underlying
ugliness,
but
you
can
always
choose
to
break
out
of
that
and
with
the
royal
stuff,
if
you
really
want
to
I,
think
that's
the
choice
of
the
library
to
provide
those
points
where
the
user
can
go
down
a
level,
but
the
default.
The
pop
is
just.
It
works.
D
D
Because
then
we
have
the
entire
need
for
explicit
out-of-band
signaling
anyway,
like
it's
a
requirement
for
the
system
to
function
correctly
in
the
presence
of
some
C's
of
user
data,
and
we
made
it
in
like
the
most
likely
to
fail
on
the
safe
mechanism
possible.
So,
given
that
we
need
some
explicit
signaling,
let's.
D
D
And
I'm,
just
so
Michael
is
trying
to
say
that
we,
if
I,
understand
him
correctly,
that
using
at
a
higher
level
of
library
usage
that
we
will
be
able
to
do
that
conflict
resolution
there.
But
to
me
that
is
look
so
it's
you
can't
ignore
the
single
problem.
That
is
a
choice
of
signaling
problem
solution.
That's
the
choices
de-facto!
Well,
this
gist!
That's
linked!
That's
where
you
choose
at
the
library
layer,
though
we're
not
avoiding
the
problem.
Category
and.
D
B
B
B
But
the
secondary
Nicks
is
going
to
point
to
pieces
in
the
primary
index
and
main
themselves
and
be
data
structures.
So
you
and
then
you
might
have
indexes
upon
indexes
that
there's
a
legitimate
thing
to,
and
so
you
need
to
jump
around.
So
you
need
to
encourage
something
that
says
when
you
got
over
there,
it's
going
to
be
this
type
of
thing
and
you
either
need
to
pull
that
up
to
the
very
top
layer
of
your
traversal
or
you
need
to
have
it
in
store
it
in
your
head.
D
It's
it's
so
like
with
that
example
of
the
temperature
system.
If
you
have
enough
local
context
already
that
you
pretty
damn
sure
you're
talking
about
temperature,
then
saying
the
word
temperature
repeatedly
or
like
spelling
out
Celsius
instead
of
just
C
or
some
other
indicator
becomes
unnecessary
because
there's
enough
information
or
entropy,
let's
come
with
you.
This
far.
B
We
don't
have
the
high
confidence
in
it.
Basically,
if
it
were
after
me,
I
would
I
would
put
Celsius
and
Fahrenheit
with
every
temperature
measurement.
Just
like
I
would
put
you
know
the
currency
with
every
dollar
measurement
and
the
I
would
order
dates
in
a
very
particular
way
to
be
very
explicit,
because
US
dates
drive
me
mad,
those
kinds
of
things
you
need
a
context,
isn't
enough
bi-weekly
isn't
enough!
It's
not
enough
to
tell
me.
You
were
meeting
these
bi-weekly
because
I
might
show
up
twice
a
week.
Are
you
American
or.
B
D
B
A
B
A
Yeah
yeah,
so
one
other
thing
I'm
doing
in
at
the
length
as
a
fat
link
that
I
realized
would
be
problematic.
The
publishing
and
subscribe
flow
gets
really
complicated
because,
all
of
a
sudden,
you
can't
just
publish
a
CID
here's
the
publish
to
see
how
the
and
all
the
information
about
it,
because
you
would
have
to
want
that
information
if
initially
be
updated.
A
B
B
If
you
wanted
to
migrate
to
a
new
version
of
some
data
structure
down
deeper,
you
would
have
to
force
that
migration
or
way
to
the
top
of
the
stack
you
couldn't
just
do
it
down
the
piece
and
have
it
done
in
that
piece
and
hand
to
version
one,
and
now
it's
ham
version
2,
because
it's
faster
and
better.
You
then
have
to
say
all
the
way
at
the
top
yeah
we
use
ham
to
it
and
choose
down
the
bottom
me.
A
I
know,
but,
like
you,
you
you're
taking
information
like
this
is
not
information
about
the
link
to
the
data.
It
is
literally
information
about
data
like
it
like
that
structure
is
not
like
really
interpretive
or
functionally
without
that
data
associated
you,
you
want
it
as
part
of
the
content
of
this.
Like
you,
you
literally
want
the
hatch
to
change
when
you
change
the
implementation.
D
Okay,
so
I
agree
with
that
and
I'm
gonna
go
back
to
the
three
original
separations.
That
is
the
problem,
and
I
definitely
want
that
in
there
I
agree
with
that
completely.
The
only
thing
that
I
have
a
stick
in
my
posterior
about
is
that
the
sheer
existence
of
something
that
looks
like
it
might
be.
A
reference
cannot
be
enough
to
change
behavior
alone,
because
that
I
have
problems.
We
have
to
back
out
of
that
in
special
cases
like.
A
A
D
A
D
A
D
I
think
a
way
to
look
at
it
might
be
trying
to
figure
out
where
concretely
like
in
an
implementation.
The
long
jump
is
going
to
be,
if
clause
for
this
and
then
just
I,
don't
know
figure
out
where
that's
gonna
be
because
every
time
I
try
to
figure
out
where
that's
going
to
be
it's
in
a
pretty
scary,
place.
D
A
Well,
okay!
So
we'll
learn
more
about
that,
the
more
that
we
move
down
the
road
of
just
doing
the
implementations,
though,
and
building
on
top
of
it,
so
not
to
worry
about
that
part
for
now,
I'm,
just
gonna
move
it
to
slash,
because
then
at
least
word
we're
putting
all
of
our
problems
into
one
place
and
then
having
them.
Spreader.
D
Since
that
links
got
her
fat,
coroner,
Scott
mentions
I
want
to
read,
mention
that
and
like
back
out
from
it
a
little
bit.
I
wanted
to
just
mention
that,
as
like
an
example
of
something
else
that
was
at
some
point
proposed
I,
don't
necessarily
particularly
like
that
one
mm-hmm,
like
sometimes
fat
pointers,
might
be
my
preferred
suggestion.
Like
sometimes.
B
B
A
Well,
I
I,
don't
I,
don't
agree
that
into
something
that
we
have
to
get
resolved
right
away.
I
mean
everything
that
were
working
on
is
highly
experimental
and
and
highly
like,
and
we
learn
more
the
more
that
we
do
it,
and
none
of
this
is
stuff
that
we
can't
back
up
enough
later,
I
mean
we
can't
back
out
of
eight.
B
A
B
A
A
Because
we
I
can
do
that
in
JSON
too.
We
can
even
just
update
Dec
JSON,
say
it
like
I
can
literally
just
say
like
okay
take
JSON
is
actually
just
an
object
with
two
properties.
One
is
called
data
when
it's
called
meta
and
the
meta
actually
can
overlay
on
the
regular
data.
So
then
we
don't
have
any
reserved
keywords
and
I,
just
like
had
all
the
meta
information
that
haven't
layer
that
on
the
structure
when
it
comes
out
of
the
decoder
right.
B
A
A
A
C
D
A
B
D
In
which
everything
would
be
serialized
to
roughly
double
the
tree
depth,
we
would
just
use
each
alternating
layer
to
treat
depth
to
say
whether
or
not
this
thing
is
a
little
bites.
Don't
other
things
that
are
otherwise
hard
to
represent.
Such
a
codec
would
be
IPL,
D
native,
in
that
we
could
put
any
information
into
it
and
it
would
be
bi-directional
lossless
that
doesn't
necessarily
mean
it's
ergonomic
for
existing
for
interacting
with
other
people's
JSON.
A
No
I
have
an
upgrade
path.
It's
fine
I
can
support
all
this.
In
the
same
thing,
we
already
break
the
flat
key
word
and
then
JSON.
So
we
can
just
put
information
about
the
version
of
'deck
JSON
into
the
slash
keyword
and
then
vary
behavior.
Okay,
sorry,
anyway,
I'm
not
doing
that
thing.
That's
people
do
I.
A
Thought
about
something
very
similar
actually,
once
when
I
was
trying
to
figure
out
some
of
the
other
binary
encoding,
stuff
and
yeah,
it's
it's
too
much
like
it's
easier
to
just
create
an
overlay
object
and
then
overlay
that
they'd
on
top
of
it,
when
you
do
the
interpretation
and
then
you
don't
end
up
with
double
the
size,
you
know
it's
just
like
a
tiny
bit
more
size.
You
end
up
with
likely
you
end
up
with
that.
We
would
like
an
array
of
the
keypad
as
like
the
extra
space
that
you're
taking.
A
Yeah
yeah,
let's
plan
that,
but
yeah
I
mean
if
he,
if,
in
order
to
use
the
nurse,
you
have
to
be
able
to
encode,
some
other
add
event,
information
or
other
information,
that's
transparent
to
the
data
model.
That's
fine.
A
If
you
basically
just
need
to
be
able
to
store
literally
like
the
generic
info
somewhere,
that
is
not
visible
through
the
data
model
decode,
it
would
change
the
block
api's.
It
would
violate
some
of
the
separations
in
the
layer
that
we've
been
talking
about,
but
if
that's
what
we
have
to
do
it
I'm
not
opposed
to
it.