►
From YouTube: Incremental Delivery Working Group - 2023-06-05
Description
GraphQL is a query language for APIs and a runtime for fulfilling those queries with your existing data. GraphQL provides a complete and understandable description of the data in your API, gives clients the power to ask for exactly what they need and nothing more, makes it easier to evolve APIs over time, and enables powerful developer tools. Get Started Here: https://graphql.org/
A
C
B
Hey
hey
archive
how's,
it
going
I
know
that
Benji
reached
out
to
me
that
he's
not
gonna
be
able
to
make
it
today.
B
A
B
Okay,
so
I
think
the
last
meeting
was
two
weeks
ago.
B
B
If
I
don't
hear
back,
maybe
we
should
just
talk
about
it
in
the
next
working
group
meeting
the
main
graphql
on
yeah,
I,
know
and
I
know
also
that
Yakov
like
he
has
his
proposals
here.
That
he's
been
iterating
on
and
he's
also
been
working
very
hard
on,
both
the
spec
draft
and
a
graphql
JS
implementation,
and
he
we
met
last
week.
He
started
to
show
me
through
the
PRS
yeah.
Maybe
we
should
just
maybe
we
should
talk
about
that
with
a
group.
That's
here.
B
So
so
Yakov
he
has
a
bunch
of
stacked,
PR's
and
I.
Think
the
top
one
in
the
stack
is
for
graphql.js
is
to
build
this
concept
of
a
publisher
that
manages
like
how
the
payloads
get
get
added
to
the
queue
and
released
and
handles
the
details
of
the
underlying
async
generator
and
the
spec
draft
that
he
wrote
also
includes
that
same
publisher
and
I
guess
maybe
I
don't
know.
B
If
Yvonne
you
had
a
chance
to
look
at
it
at
all,
but
maybe
it
would
be
good
to
get
to
get
your
thoughts
on
how
that's
implemented.
A
B
Yeah,
it's
38.94,
I'll
put
it
in
in
the
chat
here.
B
Yeah,
so
this
one
actually
keeps
the
same
implementation,
that's
on
that's
on
Maine
right
now,
but
builds
out
the
publisher
and
then
that's
used
as
a
base
for
the
changes
that
go
into
our
like
the
the
draft
that
we
that
we
put
into
the
that
we've
been
sharing
in
the
just,
so
that
this
is
kind
of
like
the
first
step
there,
yeah
I
guess
like
what's
what's
on
Main
now
kind
of
yeah,
do
you
want
to
describe
it
back
off
or
yeah
yeah.
C
A
Assumed
you
remember,
you
wanted
to
to
use
some
other
Concepts
and
I
think
generators,
some
some
other
like
primitive
forget
how
how
it
was
so
I
thought
you
doing
well,
but
no,
what
I
see
is
you
just
basically
like
gets
quote
from
execute
and
wrap
it
in
the
class?
D
So
so,
taking
taking
a
step
back,
taking
a
step
back,
I
mean
what
we
have
is
a
is
a
straight
is
a
stream
that
that
is
published.
So
what
we
already
have
now
on
Main
is
already
has,
in
some
sense
the
concept
of
a
of
a
publisher
meaning
and
there's
pretty
much
the
same,
the
same
kind
of
psycho.
You
know
we
wait
for
some
asynchronous
event
to
have
to
happen
like
a
promise
to
be
fulfilled,
and
then
we
cycle
through
you
know
some
sort
of
intermediate
state.
D
So
on
Main
right
now,
that's
the
entire
list
of
promises.
So
every
time
any
one
of
those
promises
is
fulfilled
that
represent
any
of
the
branches
of
deferred
results.
We
cycle
through
all
of
them
again
and
checked,
which
of
them
have
completed,
and
then
we
build
a
payload
for
that,
so
that
that
already
is
a
bunch
of
publishing
logic.
So
what
I
do?
What
I
do
here
is
I
extract
that
publishing
logic
into
a
class
and
I
change
it.
You
know,
enhance
it
a
little
bit
so
that
it
basically
has
two
improvements.
D
The
first
Improvement
is
that
we
don't
we
don't.
You
know
we
don't
have
to
check
all
of
the
all
of
the
promises
to
see
if
they've
completed.
Instead,
we
can
keep
a
separate
list
of
completed
promises
and
whenever
any
of
them
have
completed,
we
just
check
that
set
so
that
we
don't
have
to
cycle
through,
maybe
I,
don't
know
a
thousand
pending
stream
items
to
see
which
one
has
completed.
D
So
that's
one
Improvement
and
the
rest,
and
the
second
second
Improvement
is
that
we
we
make
this
synchronous
so
that
when
the
initial
result
is
completed
it
can,
it
already
will
know
like
without
waiting
any
extra
ticks.
So
already
we'll
know
if,
if
if
there
have,
if
filtering
has
like
excluded
all
of
the
sorry
yeah
all
of
the
Deferred
results.
So
those
are
the
basic
two
improvements,
but
the
idea
is
is
that
we
already
have
a
publisher
set
up,
and
so
so
I
extract
it
and
I
tweak
it.
D
You
know
some
some
bug
fixes,
but
no
output
is
changed,
no
meaning
no,
no,
really
new
construct,
just
a
different
way
of
of
awaiting
changes
and
storing
the
the
parent
hierarchy,
so
so
I
think
the
new,
the
new,
the
construct
that
I
I
think
in
a
while
back
in
a
couple
old
PRS
involved
like
a
repeater,
which
is
a
very,
very
clever
implementation
of
of
like
an
async
generator.
This
does
not
do
that
this.
This
does
not
do
anything
new
like
that.
D
It's
basically
just
taking
the
logic
that
we
have
using
The
Primitives.
We
have-
and
you
know
you
know,
formalizing
it
a
little
bit.
You
know
just
tweaking
a
little
bit
better
so
that
it's
a
very
strong
base
for
when
things
get
a
little
crazy
with
concurrent
delivery
of
of
you
know,
a
field
of
deferred,
fragments.
C
A
C
D
Yeah,
so
that
has
to
do
with
the
the
the
timing.
Let
me
I'm
trying
to
get
that
up.
Just
on
my
phone.
B
It
will
help
yeah
I
think
you
were
telling
me
about
that
case.
Yeah,
it's
something
like
that!
There's
a
there's,
an
extra
tick
that
we
have
somewhere
in
the
existing
implementation.
That's
not
necessary!
That
means
that
we
don't
know
that
when
there's
an
error
that
we
don't
know
that
there's
no
more
payloads
when
there's
an
error,
because
there's
an
extra
tick
somewhere
like
to
check
where
we're
checking
for
a
yeah.
It
was
something
like
that.
So.
A
B
D
Some
of
the
tests,
the
extra
sorry
shortening
the
num,
reducing
the
number
of
ticks,
causes
us
to
Emit
and
has
next
true,
and
then
an
extra
has
next
false,
because
we've
emitted,
let's
say
before.
We
know
that
an
async
iterator
has
completed,
whereas
if
we
were
slower
there
would
there
wouldn't
be
an
extra
payload
and
in
some
in
some
of
the
tests,
some
of
the
tests,
it's
the
reverse.
D
We
can
know
immediately
when
the
initial
result
has
completed
whether
there
any
pending
results,
and
so
we
can
reduce
an
extra
has
next
empty,
has
next
false.
The
other
changes
in
the
test
files
are
because
this
is
just
built
on
on
an
earlier
PR
that
separates
all
of
this
logic
into
a
separate
file.
A
Yeah,
so
just
to
understand
like
with
new,
has
next
like
new
objects.
This
has
next
Falls
caused
by
like
caused
by
a
one.
Loop
thing
like
we
have
likes
like
one
thing:
I
might
be
like
I'm,
actually
like
not
very
familiar
with
different
stream
implementation.
It's
about
so
much
that
last
time,
I
actually
reviewed,
but
it's
so
it's
like
cured
from
logical
standpoint
of
view.
It's
like
when
you
have
has
next
object,
which
has
next
pose
and
no
errors.
It's
like
weird,
why
you
have
it
like?
A
D
One
thing:
we
should
only
have
it
now
with
this
change:
actually,
we
should
only
have
it
now
with
stream.
That
should
be
the
only
case
where
it
shows
up
like
an
empty
house
next,
not
never
with
the
fur.
B
Was
already
the
case
before
yeah
go
ahead.
A
Yeah
I
kind
of
document
it
in
more
but
like
small
things,
Publishers
like
pretty
generic
name,
maybe
like
in
incremental,
result
publisher
or
like
something
something
more
more
like
specific,
because
technically
we
can
have
other
Publishers
and
who
cannot
file,
name,
publisher
and
Quest,
name
publisher.
You
cannot
guess
what
it's
actually
published
and
specifically
it's
not
like.
For
example,
you
can
assume
it's
subscription
and
this
understand
it's
not
the
related
subscription,
at
least
for
now
yeah,
and
it
would
be
great.
A
You
know
there
is
a
knowledge,
be
shared
between
you
and
Rob
and
you
discuss.
And
now
you
explain
it
to
me,
but
it's
like
it's
safe
somewhere
in
the
video,
but
not
in
code.
So
maybe
I
suggest
like
moving
all
the
functions
because
Lee
teach
me
like
good
to
us
and
if,
if
a
file
a
code,
publisher,
Quest
publisher
should
be
on
top
and
should
have
like
comments
saying
what
what's
supposed
to
do?
Why
we
have
this?
A
Small
comments
about
like
moving
stuff
around
and
maybe
like
better,
maybe
who
has
generic
names
and
publisher,
but
in
general
we
think
it's
way
definitely
a
good
start
of
of
like
yeah,
and
so
the
end
result
of
this.
What's
the
end
result
of
this
PR
stock
send
result
is
what
you
presented
on
a
was
working
group
or
it's
like
something
different.
D
The
end
result
of
this
stack
should
be
matching
the
gist
that
Rob
put
out
a
while
back,
except
that
I
haven't
implemented
either
the
sub
paths
or
the
IDS
for
the
payload.
So
I
just
always
use
the
full
path,
but
currently
the
goal
is
to
match
the
the
gist
there's
a
little
bit
of
that.
That's
the
end
result
of
the
whole
stack
meaning
so
it
includes
you
know:
incremental
delivery
with
deduplication
of
execution
and
delivery.
C
Yeah
I.
A
Think
what
we
can
do
is
we
can
merge
up
up
until
we
change
response
format
and
when,
when
do
I
try
to
get
metal
involved
and
like
figure
out
like
where
we're
heading
and
one
start
merging
thousand
change
response
so
like
I,
think
it
would
be
great
to
merge
everything
up
until
we
change
response
forward
and
maybe
like
what
you
presented
in
yeah,
it's
like
yeah,
it's
stage
one.
So
we
need
to
discuss
it
more.
A
We
cannot
imagine
oh
yeah,
oh
your
one
is
too
much
like
with
the
response
change.
D
Yeah
the
thing
is,
we
can't
I
mean
currently
as
implemented.
We
can't
actually
get
the
exact
same
old
response
format.
You
know
just
we
can't.
You
know
we
have
a
deduplicated
version,
and
so
let's
say
a
parent
field
has
a
you
know.
So
every
defer
is
going
to
have
a
parent,
let's
say
maybe
the
initial
response,
or
maybe
some
other
defer,
and
if
the
parent
has
a
couple
Fields
that
the
child
doesn't
like.
D
The
initial
result
has,
you
know,
let's
say,
request
a
user
and
request
the
ID
and
the
name
and
the
and
the
defer
doesn't
doesn't
request
the
ID
or
name
just
some
other
like
complicated
slow
field
in
the
DJ,
but
it
also
requests
the
idea
and
the
name
so
in
our
deduplicated
version
will
only
send
the
slow
field,
but
in
and
but
to
reconstruct
the
non-deduplicated
version
you
would
have
to
you
would
have
to
then
you
know,
sort
of
sub.
D
D
But
we
don't
I,
don't
think
we
necessarily
I
have
to
think
it's
actually
a
little
complicated
to
reconstruct
just
the
just
what
the
the
child
defer
has
meaning
sort
of
undeduplicated.
It
actually
would
make
it
much
more
complex,
okay,
much
more
complex.
A
Like
just
to
clarify,
because
we
have
two
types
of
did-
maybe
more
but
I'm
thinking
about
two
types
in
this
thing,
this
application,
this
initial
response
is
the
duplication
between
compete
and
differs,
so
I
think
it's
pretty
safe
to
like
change
the
format
of
deduplicate
it
with
the
initial
response.
I
think
it's
pretty
safe.
We
discussed
it
one
time
we
agree.
A
It's
happening
so
I'm
like
I,
think
it's
safer,
because
it's
always
how
to
do
that,
and
also
as
as
far
as
I
understand,
it's
like
simpler
for
a
clients,
but
the
duplication
between
competing
differs.
It's
like
it's!
What
we
basically
discussing
now!
So
when
you
say
it's
hard
to
do
it
without
the
duplication.
Do
you
mean
like
one.
B
So
I'm
not
sure
that's
that's
exactly
the
case,
because
because,
like
the
the
gist
that
we
have
now
the
one
that
I
I
that
I
demoed
at
that
working
group
meeting,
I
guess
it
was
a
month
ago.
Now
that
one
was
like
full
deduplication
in
every
aspect
like
between
pay.
It's
like
every
field
is
only
said
once
and
I
thought
that
there
was
like
agreement
on
that
direction,
but
Matt's
concerns
were
just
around
like
more
of
the
metadata
like,
however,
like
saying
the
paths
and
what's
pending
and
and
whatnot
that
stuff.
A
B
A
C
A
Yeah
before
we
went
into
deep
and
into
competing
proper,
like
whisper
stack
before
to
have
only
one
PR
before
you
change
the
response
or
like
multiply,
do
we
have
something
to
work
on
yeah.
D
With
those
you
know,
as
a
separate
you
know,
class
and
with
those
bug
fixes,
the
third
PR
stack
adds
tests,
which
show
it
just
adds
a
whole
bunch
of
tests
which
show
that
things
are
duplicated
and
then
so
that
you
know
the
next
PR,
which
is
the
main
one,
adds
the
duplication,
and
instead
of
you
know
that
PR
and
one
connect
now
shows
how
those
existing
tests
change,
rather
than
just
introducing
a
bunch
of
new
tests
and
then
the
the
next
PR
adds
the
pending
notification
locations
and
then
the
last
one
is
sort
of
like
optional.
D
It's
you
know
to
discuss.
You
know,
consolidate
some
of
the
payloads
so
that
we're
not
sending
so
that
would
reduce
the
number
basically
so
sometimes
meaning
in
the
in
when
we
first
add
pending
end
in
the
from
when
we
first
introduce
the
new
deduplicated
publisher,
we
always
will
have
a
pending
for
every
completed
and
then
we'll
wait
another
round
before
completing
it
and
with
the
final
one.
We
we
skipped
some
pendings
and
we,
you
know
if
they're
already
completed.
So
that's
the
basic
order.
D
The
the
main
big
PR
is
the
one
that
you
know
does
most
of
the
work
is:
is
the
one
that
adds
completed
and
and
separates
out
the
incremental
data
from
the
completed
payloads,
and
it's
really
tough
to
break
that
apart
into
smaller
ones.
Just
because
it's
a
big
change
in
terms
of
how
everything
hooks
together,
we
had
an
initial.
D
We
had
an
initial
PR
implementation
that
I
worked
on
way
back
then
that
did
deduplication
differently
and
partly
but
I,
don't
think
it
would
be
really
helpful
to
go
back
to
that
and
merge
it.
And
then
you
can
see
how
the
other
response
I
think
that
would
just
confuse
the
git
history,
even
even
more
so
that
I'm
not
I'm,
not
quite
sure
how
to
break
up
the
main
PR
in
the
stack
into
smaller
ones.
Unfortunately,.
A
Foreign,
yes,
so
basically
we
have
like
three
pairs
like
can
we
do?
Can
we
like
buzz
away
Rob
when
you
say
like.
A
Way
back
I
can
might
be
so
bad
because,
like
this
chord
is
a
weird
I
personally
also
don't
respond
on
this
court.
A
lot
of
time
because,
like
it's
not
working
for
me,
like
really
weird
one
so
I
trick
to
reach
math,
is
to
use
Facebook.
A
So
he
is
always
on
in
my
experience
here
responsibly
immediately
on
Facebook
I
will
reach
to
him
and
pin,
pin
him
to
check
Discord
and
so
like.
Maybe
you
can
agree
wait.
A
Maybe
he
would
use
a
friend
on
Facebook
or
something
so
you
can
okay
communicate
faster
and
can
we
do
like
we
match
with
free
pairs
that
don't
change
anything
and
it's
good
chunk
of
work
like
for
a
week
to
review
and
match
it
and
ask
Matt
if
he
can
join
like
Monday
and
if
he
cannot
because
I
have
my
concern
of
confusing
thing
like
one
thing
is
to
to
release
some
format.
We
release
some
format,
people
already
adopted
it.
A
We
decided
to
change
it
and
I'm
kind
of
worried
that
we
will
release
intermediate
format
like
it
will
Express
intermediate
formats
that
to
like
walk
like
it's
very
similar
to
finish
one
but
changing
the
details,
and
if
we
stuck
on
a
long
time
in
like
half
finished
state,
it
will
also
be
weird
so
I'm
like
more
since
Matt
to
has
the
strongest
my
concerns
in
a
group.
Maybe
it's
worth
the
discuss
with
him
and
see
like
do
we
his
argument
and
decide?
Do
we
need
to
wake
change
it?
It's
like?
A
A
Basically,
do
we
do
we
change?
Do
we
do
incremental
change
to
response
format,
or
we
will
try
to
find
the
response
format
that
satisfy
satisfied
like
final
one
and
apply
it
as
a
final
thing
or
what's.
B
A
Yeah
so
like,
let's,
let's
try
to
match
everything
that
don't
change
like
first
three
pairs
and
hopefully
it
will
be
awake.
A
Is
the
main
reviewer
and
if
I
will
have
time
I
will
bike
leave
General
comments?
If
it's
something
big
like
like
a
new
course
pin
me
if
it's
something
like
smaller,
like
changing
the
tests,
you
more
in
scope
of
code,
so
like
industry,
just
review,
maybe
earthquake
eventually
like
at
least
have
a
couple
of
reviewers
and
just
match
it.
B
Yeah
yeah
definitely
and
we've
been
doing
that.
There's
been
like
a
few
small
PRS
that
yaakov
extracted
like
small
refactors
and
I
I
approved
those
and
either
you
or
someone
else
from
the
reviewer
team
approved
it,
and
those
were
marriage.
I
just
wanted
to
call
this
one
out
because
it's
like
it's
a
new
class.
It's
like
pretty
it's
a
bigger
change,
I
think
I'll
I'll
review
the
test.
I
think
that
I
agree
with
them
like
the
changes
that
showed
up
in
the
tests
and
and.
A
A
One
thing
please
document
it
there
like
because
it's
it's
like
if
it's
rise,
a
question.
It's
the
last
question
for
Europe
and
Jacob
explained
that
the
last
question
for
me
and
yeah.
B
B
And
now,
and
but
the
other
part
is
with
this
publisher
class
like
I'm-
curious
how
it
would,
how
are
we
going
to
have
it
relate
to
what
goes
in
the
spec?
So
I
I
think
that
we
have
like
a
spec
PR
that
has
like
a
pretty
faithful
representation
of
this
publisher.
B
I
know
that
Benji
had
concerns
about
having
like
any
kind
of
mutable
state
in
the
spec,
where
there's
a
function
that
modifies
a
variable
that
wasn't
created
and
there
I
do
think
there
is
a
little
bit
of
that
like
by
the
nature
of
how
the
publisher
works.
It
is
all
kind
of
wrapped
up
into
like
this
group
of
functions
that
only
do
publisher
stuff
and
then
the
executor
calls
those
functions
and
that's
where
the
state
is
managed.
So
I
I
asked
Benji
for
his
opinion
on
that
he's
I
think
he
was.
B
He
was
out
for
the
past
few
days
and
I
think
so.
I'll
get
your
thoughts
on
that
too.
A
Yeah
I'm
I'm
like
quite
concerned
I'm,
always
concerned,
since
it's
not
the
end
of
the
I
think
so,
like
I
think
if
we
spend
with
Hawaii
response
format
problem
how
can
to
consume
my
the
first
problem
and
how
to
document
it
in
a
spec
out
of
this
like
problems,
how
to
document
the
test
spec,
it's
like
smallest
problem
and
I
I'm,
like
I,
think
it's
like
pollution
step.
So
it's
not
a
figure
out
how
to
describe
it
in
in
a
text
set
right
in
similar
fashion
that
all
the
other
algorithms.
A
In
like
worst
case
scenario,
it
will
be
tax
explanation
as
similar
how
we
describe
streams
in
subscribe.
We
also
don't
describe
streams
as
like
functions.
We
describe
it
as
a
text
so
like
voice
what's
case
scenario
I
like
I,
like
algorithm
I,
like
functions,
I,
think
everybody
feels
the
same.
That's
why
we're
programmers,
but
in
wordscape
scenario
we
can
describe
it
in
the
text.
A
I,
don't
think
it's
a
a
big
problem
now
and
I
definitely
don't
think
describing
like
I,
don't
think
we
should
change
to
the
whole
proposal
because
we
cannot
describe
it
as
like
pure
conscience,
I
think
I
yeah
and
a
bit
of
trivia
when
I
spoke
with
Lee
about
krakil
dress.
A
He
actually
said,
like
he,
first
wrote
like
stuff
in
grab
KJS
and
one
and
write
tests
against
it
and
only
when
he
described
it
in
this
pack,
so
I
think
now
we
kind
of
in
Discovery
phase,
so
I
wouldn't
wait,
who
wouldn't
bother
with
spec
algorithms.
C
A
So
we
describe
them,
we
discuss
like
Whispers
anything
else.
We
want
to
discuss.
B
I
I,
don't
think
so
yeah
if
you
can
reach
out
to
Matt
and
see
if
he
can
check
his
Discord
and
reach
out
to
me
or
and
then
figure
out
some
way
that
we
can
communicate
that's
easier
for
him.
That
would
be
very
helpful.
D
D
Well,
I
I
see
them
as
addressing
two
related,
but
distinct
issues.
I
mean
the
first.
The
first
is
the
the
immutable
concern
meaning
right
now.
In
our
current
algorithm,
we
have
what
Benji's
been
called.
D
What
what
we've
been
called
I've
been
calling
that,
like
the
final
reconcilable
object,
that's
updated,
whereas
and
that
that
object
is,
is
mutable,
I,
guess
by
Design
and
and
some
of
the
and
it's
just
suggestions
of
changes
like
in
the
comments
that
Matt
and
and
and-
and
we
all
have
been
making
have
have
tried
to-
you
know,
produce
an
algorithm
that
can
avoid
that
that
those
mutable
objects.
D
But
the
second
second
issue
which
is
kind
of
related,
is
how
we
present
you
know
the
location
of
the
pending
fragments
and
the
location
of
the
insertions
to
either
the
final
reconcilable
object.
Or
you
know,
even
in
these
new
proposals
to
to
you,
know
the
new
immutable
objects,
meaning
do
we
send
lit
at
lists
or
do
we
send
trees
and
the
idea
would
be
that
trees
might
be
a
tree-like
structures.
It
might
be
easier
for
the
client
to
navigate
either
that
final
or
consolable
object
or
just
in
reconstructing
you
know,
immutable
objects.
D
So
those
are
two
different
concerns.
You
know
how
they
fit
together.
You
know
they
may
interact
with
each
other,
but
they're.
Two
different
concerns,
so
I,
just
wanna
aren't
really
adding
much
to
it,
but
I
just
want
to
highlight
that
those
are
two
different
issues,
meaning
even
if
we
go
even
if
we
go,
we
don't
go
with
math
suggestions.
You
know
we
stick
with.
You
know
the
the
single
final
reconcileable
object.
D
We
still
might
want
to
send
trees
or
tree-like
structures
down
using
either
the
special
characters
or
the
arrays
or
the
or
the
doubly
wrap
like
Benji,
said,
the
the
the
the
doubly
wrapped
kind
of
trees.
But
those
are
two
different
issues,
so
we
might
wanna,
you
know,
I,
don't
know
what
you
know.
Maybe
we
want
to
deal
with
Matt's
issue
first
about
immutability,
and
then
the
tree
is
second
I.
Think
we've
sort
of
been
dealing
with
them
both
together,
but
they're,
not
exactly
tied
hand
in
hand.
A
Yeah,
maybe
I
can
show
what
I'm
working
on
yeah,
because
I
I
tried
last
time.
I
suggested
a
syntax
solution
and
I
was
thinking
about
that.
What
I
wanted
to
present
something
before
we
school,
but
so
basically,
I
took
like
Matt's
idea
of
Alias
fragments
and
he
one
of
his
suggestions
was
use
at
simple
as
a
reference.
A
So
now,
I'm
yeah
I
will
explain
how
it's
connected
to
differs
in
a
second.
So
basically,
you
provide
the
query
you
use
like
Alias
fragments
and
here
how
I
feel
you
have
fields
that
have
since
he's
same,
and
you
have
different
fields
and
inside
the
data
you
have
like
ideas
and
ideas
and
inside
to
like
references.
You
have
the
same
ideas
and
you
know
it's
not
Json,
as
always,
this
problem
of
arbitrary
data
initiation
by
having
a
path.
A
D
A
Same
as
as
Y
is
here
when
it's
valid,
if
it's
different
it's
invalid
and
what's
interesting,
if
we,
if
we
treat
Fields
inside
default,
fragments
as
promises
each
field
as
a
promises,
we
can
use
the
same
like
ID
in
not
promises
app
basically
like
C
is
in
inquiry
like
both
Alice
fragments
have
duplicating
quite
C
field,
and
here
we
just
use
ID
from
the
same
from
the
same
reference
object
and
I
didn't
figure
out
how
to
cope
with
like
this
type,
maybe
filled
or
something
and
yeah
it's
our
data,
so
basically
the
duplication.
A
If
we
switch
the
duplication
to
Fields,
it's
pretty
pretty
easy
to
do
because,
like
Fields,
can
reference
the
same
ID
and
actually
like
interesting
thing:
I'll
figure
out
how
to
prevent
Infinity
tubes,
so
you
follow
numbers
and
numbers
should
always
grow
if
numbers,
if,
like
you
go
into
like
free
and
inside
the
free
inside
the
data,
there
is
like
earliest
fragment
and
that's
how
like
ideal,
I,
wasn't
free
it's
invalid.
So
it's
you
should
always
follow
bigger
numbers.
A
What
prevents
like
Infinity
tools?
It's
very
early!
It's
like
I
figure
out
how
some
of
this
thing
today.
So
I
just
wanted
to
share
what
what
I'm
yeah
and
how
it's
connected
to
to.
A
How
it's
connected
to
streaming?
D4!
Imagine
we
add
sorry
we
had
default
here
and
here
so
A
and
B
already
presented
in
response.
So
we
basically
yes,
say,
like
we
say,
is
Alias
for
basically
took
this
puff
and
add
like
to
a
name
and
C3.
We
can
deliver
it
in
a
separate
Wayward.
Basically,
we
can
add,
like
another
period.
D
A
The
data
so
basically
yeah
sorry
I,
was
so
like
three
and
three
finish.
So
if
it's,
if
stuff
resolved
and
synchronously
it's
in
the
same
port,
if
it's
resourcing
currency,
it's
in
separate
wayward
so
and
type,
it
feels
something
I
have
to
yeah
I'm
still
like
thinking
about
it,
but
maybe
I
will
document
something
it's
half
finished.
A
It's
still
like
have
problems
edge
cases
with
like
deep
matching,
as
you
figure
out
how
to
do
deep,
Magic
One
Thing
is
interesting,
for
me
is:
if
we
switch
areas,
fragments
have
the
same
problem
of
deduplication.
A
We
we
discuss
it.
We
kind
of
agree.
It's
like
a
great
thing
to
do
component
reservation,
but
the
main
concern
for
Alice
fragments
was
that
the
data
is
duplicating
and
this
before
we
have
the
same
problem.
So
my
idea
is
what,
if
we
use,
if
two
proposals
have
like
the
same
problem,
maybe
we
will
use
one
to
solve
another
so,
like
we
use
and
default,
we
used
earliest
fragments
to
solve
the
four
problem
and
I.
Will
people
allow
developers
to
differ
only
Alias
fragments?
D
I
I
I
that
that's
that's
a
really.
You
know
really
very
interesting
proposal
I,
but
before
I
before
I
say
anything
generally.
I
just
have
a
question
because
I
don't
know
if
I
understand
everything
about
Alias
fragments.
D
A
There
is
two
things
you
can
have
is
there
is
like
parameterizing,
which
is
separate
problem.
You
can
do
parameters,
you
can
add,
like
arguments
to
fragments,
not
Alias
fragments
so
like
is.
There
is
two
problem
of
is
a
fragmentation
arguments.
A
D
D
So
the
only
reason
why
I
bring
up
arguments
is
because,
once
once
you
allow
the
parameterizing
of
fragments
and
and
I
think
that's
that's
going
to
be
a
major
use
case
of
Alias
fragments
I'm,
not
sure
how
easy
it
is
to
de-duplicate
between
the
the
different
fragments,
depending
on
how
they've
been
parameterized,
because
they
have
to
be
the
same
really
in
order
to
you
know
in
every
way,
in
order
to
say
that
we
can
safely
deduplicate
them
that
that
that's
that
I
mean
I.
D
I
know
that
might
be
a
minor
concern,
but
that's
just
the
first
thing
that
pops
into
my
head
I
think
way
back
when
I
I
submit
an
issue.
Well,
why
don't
we
just
make
every
you
know
also
required
aliases
on
I'm,
not
sure
exactly
what
I
was
thinking
at
the
time,
but
now
that
I
think
I.
D
D
Yeah,
there's
there's
a
different
idea
that
I
think
that
I've
been
in
the
back
of
my
head
sort
of
working
on
that
I
want
to
formalize
more,
but
it's
it's
somewhat
related,
which
is
that,
which
is
that
if
we
had
a
way
of
expressing
identity
and
I
think
this
comes
up
with
the
new
response
format,
that
Matt
was
suggesting
to
go
along
with
fragment
isolation,
meaning
if
we
had
a
way
of
of
of
of
of
of
pointing
out
that
you
know
that
an
object
was
the
same
in
across
many
different
places.
D
That
was
referenced
in
the
graph,
whether
it
was
in
a
named
fragment
or
or
not,
then
we
could
you
know
if
it
was
really
the
same,
then
we
could
rely
well,
then
we
could
deduplicate
it
in
the
resp
in
the
final
response
format
and
that
shares
some.
D
You
know
I
think
a
lot
of
similarities,
but
it's
like
a
separate
piece,
a
piece
that's
linked
and
that
he
you
know
he
put
together
so
I,
wonder
if
you
add
sort
of
that
requirement
to
what
you're
saying
then
then
yeah
then
I
think
it
would
work
nicely.
A
D
A
In
yamo,
it's
like
a
native
concept
like
what,
if
the
and
you
cannot
add
the
references
in
Json,
it's
impossible
because,
like
everything
without
new
syntax,
it's
not
happening
in
Json,
but
we
operate
on
restricted,
restricted,
Json.
So
we
we
can
basically
say
like
fields
that
start
with
some
percent
few
field.
Names
are
references,
you
jump
to
a
reference
and
you
compare
a
path
that
way
you
ensure
way.
A
Yeah
yeah
I
actually
try
to
find
it
and
I
could
not
solve,
thank
you
or
for
finding
it
for
me,
because
yeah
you're,
right
I'm
trying
to
do
that,
but
then
Jason
and
keep
Backward
Compatible
and
least
surprising,
so
only
feel
that
I
have
like
Ampersand
and
Fields
have
one
percent
only
because
user
did
alias
in
his
query.
A
So
it's
not
like
any
field
is
a
reference.
It's
not
like.
We
change
totally
change
response
format.
It's
like
when
you
use
Alias
fragments
you
switch
to
like
you,
switch
what
thing
into
like
reference
mode.
A
D
Unmute,
it's
very
it's
very
you
know
it's
a
very
promising
idea,
I
think
I!
Guess
in
the
context
of
this
working
group,
the
goal
is
to
get
deferring
stream
going
released.
D
To
you
know
to
to
try
to
I
think
Rob
when
I,
when
I
put
out
that
PR
I
think
Rob
said:
oh
no,
we
delayed
you
know
by
that
suggestion
tying
them
together.
We're
gonna
delay
gradual
delivery
by
a
year.
So
I
don't
know,
I,
don't
know
exactly
what
date
I
have
to
check
what
date
Rob
said
that
and
see.
If
it's
a
year
has
actually
gone
by,
but
I
don't
think
it
was
all
my
fault
from
that
suggestion.
D
A
A
I'm
like
before
a
course
I,
actually
thinking
a
lot
of
what
Matt
said,
he
said
like
we
focused
on
server
side
how
to
push
all
necessary
data
in
in
response,
so
we
advise
more
stuff
and,
like
all
the
data,
is
there,
but
they
write.
So
technically
you
can
reconstruct
whatever
you
want
more
or
less,
and
we
try
to
keep
all
the
semantics
and
even
have
discussion
how
to
better
preserve
aerosomatics.
So
we
try
to
push
as
much
semantics
in
response
as
possible.
A
But
question
here
is
like:
is
it
readable
when
person
try
to
understand
what's
happening
and
second
thing?
If
it's
like?
Is
it
maybe
it's
too
complex
for
for
client
in
current
form
when
so
PM
I'm?
Thinking
of
like
we
always
know
what
data
should
we
put
inside
like
we
need
to
de-duplicate?
We
need
to
say
something
in
spending,
but
can
we
can
we
represented
in
simple,
simple
layer
form
so.
A
Yeah
I
will
try
to
I,
cannot
do
I,
create
the
whole
proposal.
I
will
do
a
draft
wait
draft
proposal,
meaning
it's
not
a
proposal.
It's
like
just
set
up
syntax
ideas
and
and
I
will
post
it
probably
on
a
as
discussion
on
the
report.
The
best
way
to
have
discussion
of
something
is
is
a
repo
discussions.
Okay,
I
will
post
it
there
obvious
week.
B
All
right,
awesome
I
have
to
jump
off
now.
Yeah
thanks
a
lot.
Everyone
and
see
you
all.
Next
Monday
yeah.