►
From YouTube: IETF-ALTO-20230223-1300
Description
ALTO meeting session at IETF
2023/02/23 1300
https://datatracker.ietf.org/meeting//proceedings/
A
B
B
C
C
A
C
B
A
A
Already
uploaded
the
latest
version,
but
but
this
is
what
I'm
saying
is
that
I?
We
can't
fix
that,
while,
while
we
are
dealing
with
the
when
when
so
no
need
to
wait
for
us
sure
sure
thank
you
so
I
will
I
will
check
again
and
if
there
is
any
in
the
problem,
I
will
send
you
a
private
private
chat.
Richard.
B
So
for
this
is
a
detailed
note
where,
if
you're
not
familiar
with,
please
read.
It
also
has
already
been
published
on
the
idea
website,
and
this
is
our
meeting
agenda
and
the
for
meeting
Logistics.
Actually,
we
already
have
Jody
and
to
take
a
have
to
take
minutes
and
we
create
the
the
notes
in
the
Kodi
markdown
and
so
foster.
B
Actually,
as
a
chair
we'll,
you
know,
introduce
the
working
Google
status
at
update
and
to
actually
discuss
where
we
are
and
which
direction
we
should
move
toward
and
also
where
you
know,
discuss
our
Yokohama
meeting
play
and
in
this
agenda
we'll
you
know,
focus
on
two
channel
items.
One
is
auto
new
transport,
the
other
one
is
auto
om
and
the
goal
is
all
this
intermitting
is
to
make
sure
these
two
chat
items
ready
for
the
working
of
last
call.
B
B
So
the
this
is
a
working
status
update.
Actually
we
already
make
several
you
know
each
other.
The
reason
every
child
actually
take
took
place
in
November,
November
2021
and
the
charter
actually
focused
on
auto
om,
HTTP,
2
and
lgb3,
and
also
Auto,
om
young
and
auto
deployment
update
for
the
last
one
Auto
diploma
update.
It
could
be
documented
in
the
individual
chart
or
document
in
a
Wiki
page
actually,
with
you
know,
choose
the
later
one
actually
and,
and
we
made
a
lot
of
progressions
return.
B
The
second
one
actually
is
integrate
Auto
into
teleport,
considian,
Network
and
and
also
we
actually
socialize
Auto
in
many
working
group
in
ITF,
actually
Lewis
actually
from
telephotica,
and
you
know,
present
the
telefonica,
City
and
networker
integration
with
Auto
in
media
Ops
working
group,
and
also
we
made
some
tutorial
and
presented
the
auto
introduction
in
obviously
WG
working
group,
and
also
we
actually
work
on
the
publishing
or
the
introduction
in
the
Internet
Protocol
Journal.
This
is
working
in
progress
so
for
the
future
meeting
plan.
B
Actually
we
request
the
one
hour
time
slot
for
the
for
the
auto
way
plan
to
use
this
time.
You
know
to
conclude
the
the
working
Google
last
call
for
to
China
item.
Also,
we
will
use
this
time
to
introduce
Auto
deployment
update,
which
is
a
diploma
that
will
relate
to
some
new
use
cases.
The
the
one
is
related
to
multi-domain
setting
the
other
one
is
the
network
computing
exposure,
work,
update.
B
B
C
Great
thank
you.
So
my
goal
is
to
give
an
update
on
the
transport
update.
You
can
notice
for
people
who
are
not
follow
the
intermediate
changes
between
ietf
115
and
now
is
we
change
the
name
of
the
service
as
well
as
now.
It's
called
transport
information,
publication,
service
or
tips
very
easy
to
I
guess
easily
to
pronounce
and
remember
so.
Therefore,
this
really
is
called
Auto
tips.
C
Next
slides,
please,
okay,
here's
the
outline
and
what
we're
going
to
talk
about
battle
where
this
really
is
a
very,
very
good
effort,
with
a
lot
of
work
from
Kai
from
Lachlan
and
from
Roland.
So
therefore,
this
really
is
a
team
effort
to
really
present
the
effort,
and
here
the
goal
is
the
first
review
and
recap
what
we
have
talked
about
before,
because
it
turns
out
that
there
are
a
lot
of
reviews
and
we
also
want
to
summarize
the
changes
and
so
on.
C
You
can
see
that
we
really
did
a
lot
of
work,
so
we
want
to
first
start
by
reviewing
the
reviews
and
also
the
intention
of
the
whole
document
and
in
particular
we're
going
to
talk
about
two
main
issues
or
major
confusions
and
which
we
risk
and
then
we're
going
to
go
over
actually
how
design
very
very
carefully
and
today,
to
get
feedback
from
the
whole
working
group.
Because
now
the
design
is
almost
complete
now
and
we're
very
happy.
C
C
So
therefore
we're
going
to
go
over
the
almost
all
the
design
points
to
really
get
feedback
and
so
on,
and
then
we'll
just
use
a
very
simple
slide
to
talk
about
the
document
status
and
then
we're
going
to
talk
about
one
essentially
one
essential
remaining
issue,
and
we
want
to
the
working
group
to
give
us
feedback,
and
then
we
will
talk
about
how
we
plan
for
the
next
step.
Next
slide,
please!
C
Okay!
So,
first,
let's
really
talk
about
how
what
motivates
the
changes
of
the
document
and
still
the
four
excellent
early
HTTP
ad
reviews
are
still
incredibly
useful
and
the
reviews
by
Martin,
Thompson
and
Spencer
Dawkins
and
Mark,
knocking
him
and
also
our
ad
marketing
Duke
they're,
also
wonderful,
wonderful
reviews
and
both
in
terms
of
in
terms
of
post
on
the
mailing
list
and
also
in
terms
of
you
know
the
meeting
and
also
in
person
feedback.
C
There
are
still
a
wonderful
wonderful
review,
we're
still
trying
to
address
all
the
reviews
and
so
on,
because
they
gave
a
lot
of
guidance
and
also
we
want
to
mention
that
we
do
gather
two
or
four
excellent
post,
a
150,
ipf
115
reviews.
One
is
very,
very
detailed,
very
thoroughly
very
careful
review
by
Adrian,
pharaoh
and,
of
course,
also
feedback
from
him
on
a
million.
So
therefore,
you
can
see
that
his
review
will
be
reflected
in
the
document.
C
Then
we'll
also
have
review
from
Lewis
and
majority
and,
of
course,
Ting.
They
also
give
very
detailed
reviews
give
out.
They
ask
all
all
the
questions
you
can
see
that
we
have
a
summary
about
what
issues
we
have
addressed
and
what
issues
are.
We
have
not
fully
addressed
before
this
document.
So
therefore
those
would
be
the
sources
of
the
multi
motivation
for
the
reviews.
Of
course,
we
do
have
the
wonderful
working
group
weekly
meeting,
so
people
give
us
feedback
and
but
that's
slightly
more
informal,
okay,
next
slides,
please,
okay!
C
So
let's
first
recap:
what
is
the
purpose
of
Auto
new
transport?
The
main
focus
of
the
whole
work
is
the
ability
to
support
a
common
use
case,
which
is
that
you
have
Auto
server
here
on
the
left
hand,
side
and
you
have
an
auto
client
on
the
right
hand
side.
So
the
auto
server
is
sending
information
to
Auto
collect
about
Network
information,
it
can
be
cost
mapped,
it
can
be
Network
map
and
it
can
be
input
properties,
for
example.
C
What's
the
connection
property
of
a
client,
a
common
use
case
is
that
the
server
would
send
a
sequence
of
the
updates
or
versions
of
information
to
a
client.
Basically,
you
can
from
here
is
essentially
first,
it
serves
an
emotion
one
and
then
we'll
send
a
version,
two
which
is
small
data
and
then
we'll
send
a
version.
Three,
for
example,
one
more
data,
so
a
very
concrete
use
case,
for
example,
with
certain
use
case.
The
certain
use
case
essentially
is
the
following:
you're
gonna
have
a
you
know.
C
Extreme
case
will
be
600
by
600
RCS
remote
Soldier
unit.
They
are
the
servers
which
hosting
a
large
amount
of
certain
data,
and
we
are
doing,
for
example,
for
usual
integration
or
we're
doing,
for
example,
FTS
integration.
So
therefore
we
want
to
know
the
cost
map
from
every
peer
or
source
to
destination.
So,
therefore,
we're
going
to
have
total
of
360
000
pairs
a
matrix
size
to
send
the
information
around
from
a
server
to
the
cloud,
for
example
the
server
but
I
know.
C
What's
the
cost
so
therefore
can
do
the
selections
and
so
on
once
in
a
while
and
there'll
be
some
can
measurements.
The
measurement
comes
in.
We
identify,
for
example,
from
Silver
one
to
Decision
One
or
the
cost
will
have
some
change.
We're
not
going
to
have
a
major
changes
among
all
the
360
000
pairs.
Only
a
small
number,
for
example,
and
a
few
entries
are
changed.
So
therefore
you
can
imagine
resource
version.
One
is
the
initial
cost
map
very
big
and
360
000
entries,
and
then
you
update
a
few
smaller
entries.
C
Therefore
you
get
small
data
and
then,
after
a
while,
you
get
some
small
changes,
you
get
a
data,
and
so
you
continue
to
push
the
information
from
server
to
the
client,
so
that's
a
common
use
case
and
actually
driving
our
deployment
so
how
to
support
this
use
case.
There
are
two
cases
and
one
of
course
is
auto
SSE,
which
is
defined
by
this
working
group.
It's
defining
RFC,
88
and
5..
C
So
this
one
is
a
purely
silver
Porsche,
only
approach,
it's
based
on
HTTP
1.1.x,
and
it's
not
a
bad
protocol
at
all,
but
essentially
the
major
problem.
Of
course,
there
are
two
problems.
Number
one
problem
is
that
it
needs
a
separate
control
connection
from
the
server
to
the
client,
essentially
it's
based
on
HTTP
1.x
and
therefore
to
avoid
blocking.
So,
therefore,
you
must
have
separate
connection
to
set
up
the
data
from
the
server
to
the
client
manager,
which
one
subscribed
and
so
on.
C
So
therefore,
Union
separate
control
connection,
which
oftentimes
needs
more
like
firewall
connections
and
those
type
of
issues,
then
also
because
of
this
HTTP
1.x.
So,
therefore,
you
must
serialize
all
the
information,
and
so,
if
you
have
two
updates,
for
example,
suppose
you
are
monitoring
multiple
information
and
in
the
same
connection
they
would
compete.
So,
therefore,
you
cannot
have
concurrency
of
multiple
monitorings.
So
therefore
there
will
be
potential
issues.
C
C
If
you
want
to
send
a
version
two
with
a
small
data,
you
can
make
it
a
chain,
for
example,
you
can
specify
attack
and
then
you
can
send
a
tag
from
the
when
a
client
is
pulling
for
the
next
version,
canceling
attack
and
then
the
server
can
can
send
in
the
incremental
changes.
So
therefore,
that's
really
possible,
but
then
incremental
changes
would
be
not
cachable
and
because
they
are
not
really
identified
attack.
But
tag
really
is
not
part
of
URI.
C
So
therefore,
very
hard,
we
like
reuse
the
content
very
hard
to
really
use
some
kind
of
front-end
really
catch
all
the
changes,
if
you
have
multiple
clients,
for
example,
trying
to
get
information,
there's
no
not
possible
doing
silver
approach.
So
so,
therefore,
those
are
the
issues
that
we
want
to
address
next
slides,
please
the
design
go.
Let's
summarize
everyone
everything
clearly
so
probably
all
on
the
same
page
is
to
provide
a
transport
design
for
auto
to
support
efficient,
incremental
updates
to
allow
either
Clan
pool
or
HTTP
two
of
three
version
native
server
push.
C
So
a
single
transport
protocol
and
you
can
do
a
very
efficient,
parallel
incremental
updates
and
each
individual
income
update
must
be
named,
because
if
you
want
to
support,
for
example,
HP
203
native
server
push,
you
really
need
to
have
a
get
a
resource
right,
hp2,
for
example,
the
server
approach.
Push
promise
essentially
is
a
get
resource
and
you
gave
the
header.
So
therefore,
essentially
you
need
a
name
resources.
That's
actually
is
a
very
nice
property.
We
want
to
have
that's
the
basic
requirement.
C
The
intention
is
very
simple,
and
this
new
design
is
not
intended
to
replace
rc7285,
which
is
still
good
for
simple
requests
and
simple
replies.
If
you
don't
have
a
incremental
use
cases,
you
only
require
something.
We
still,
of
course,
think
RFC
70
to
85
based
protocol
is
what's
that
and
there
would
be
a
good
protocol,
but
this
one
should
be
able
to
maybe
replace
RFC
88.95,
but
that's
essentially
the
decision
of
the
working
group.
C
C
So
now,
let's
go
over
the
design,
review
and
oh
I,
think
I'm
still
missing
the
slides,
okay
and
I
we're.
So
this
is
another
version
which
I
I
sell.
Let
me
just
summarize
what
I
was
intending
to
see
because
we're
missing
one
slides
here,
the
we.
We
got
excellent
reviews
from
four
additional
new
reviews
and
the
main
issues
we
identified.
After
all,
the
reviews
and
in
other
questions
will
be
falling
number
one
is
the
system
will
have
all
kinds
of
resources
in
a
system?
C
So
a
very
common
question
and
I
think
I
received
by
a
couple
of
times
is
what
exactly
is
the
view?
What
exactly
is
incremental
for
different
client
will
get
information.
So
therefore,
that's
question
number
one
which
we're
going
to
address
that's.
Why
and
second
question
essentially,
is
about
the
link,
so
what
exact
exact
thing
is
link
and
how
exactly
really
is
attack?
C
So
what
exactly
really
data
is
a
name,
so
those
are
the
most
important
questions
or
either
question
we
did
not
answer
in
we
found
out
from
the
reviews
we
try
to
address
those
reviews
and
now
to
address
those
reviews.
It
turns
out
that
we
need
to
change
the
data
model
a
little
bit.
So
that's
why
and
now,
and
we're
going
to
give
you
a
major
design
summary
so,
therefore,
to
introduce
all
the
concept
and
so
therefore,
that's
why
we
started
with
basic
concepts.
C
B
C
C
Okay,
so
the
main
thing
now
for
the
overall
system
design
is
the
falling
is
that
we
want
to
really
support
incremental
updates.
So,
therefore,
the
basic
data
mode
of
our
neural
output
transport
is
incremental
transfer
over
representation
right.
So
the
traditional
design
of
HTTP
is
called
restful.
Api
is
representational,
say
the
transfer
protocol
and
here
for
ours,
is
actually
very
similar,
but
somehow
is
incremental.
C
So
what
does
it
mean
and
the
mean
is
the
phone?
If
you
look
at
the
left
hand
side,
that's
the
basic
resource,
a
base,
HTTP
resource,
and
traditionally,
of
course,
you
are
doing
the
state
transfer
of
the
resource
from
the
server
to
the
client
or
from
a
client,
color
server,
and
here
in
our
design
we
consider
actually
each
resource
will
be
represented
by
as
by
a
sequence
of
increment
updates.
So,
therefore,
the
transfer
is
no
longer
State
transfer.
It's
increment,
app
dates,
representation,
state
of
transfer,
so
you
can
think
about
this
design.
C
Actually,
it's
a
generalization
of
a
basic
protocol,
the
basic
model
of
GDP.
So
what
exactly
is
the
representation
now
of
resource
now
inside
the
Eva
HTTP?
Of
course,
potentially
this
work
can
be
generalized
and
to
be
presented
even
as
extension
of
HTTP
itself,
but
right
now,
of
course,
we're
only
focusing
in
the
context
of
Auto,
but
this
one
comes
out
actually
quite
a
generic.
We
are
very
happy
about
it
and
we'll
talk
to
Mark
and
nothing
had
to
talk
about
potential
generalized
version,
but
this
is
only
for
auto
contacts.
C
So
what
exactly
is
a
resource,
for
example,
anywhere
page
or
any
resource?
Of
course
here
in
the
context
of
Auto,
is
essentially
is
a
cost
map
or
network
map
or,
for
example,
import
cost
service
and
or,
for
example,
property
or
enter
the
private
service,
and
so
on,
so
how
to
represented
conceptually.
If
you
have
increment
updates,
then
the
resource
can
be
represented
using
essentially
such
a
graph
okay.
So
it's
a
very
simple
incremental
transfer
graph,
and
if
you
look
at
this
one
and
node
is
a
version.
C
C
So
here
is
each
attack.
Each
version
can
be
identified
by
attack
and
hack
identifies
the
version
of
of
this
particular
basic.
The
basic
resource.
I
know
what
happens.
Actually
you
know
overall
system
is
the
transfer
in
the
system
and
inside,
for
example,
for
auto,
of
course,
overall
for
GDP
and
transfer
data,
accurate
is
Edge
and
Edge
of
the
transfer
data
and
the
basically
means
is
Edge
from
version
I
to
version.
C
J
is
the
operation,
and
the
data
basically
means
operation
can
be
the
full
replacement,
and
then
the
data
will
be
a
full
replacement
or
the
operation
can
be,
for
example,
multi-patch
and
a
data
will
be
data
and
it
can
be
Json
patch
and,
of
course,
is
operational.
Existing
patched
data
will
be
the
data
to
support
the
operation
and
so
on.
So
therefore,
essentially,
this
ad
will
bring
the
version
from
one
version
to
another
version
and
it's
very
important
to
notice
that
for
this
data
model,
I
know
the
content
is
passing
dependent.
C
For
example,
look
at
the
content
105
node
105,
which
is
on
the
second
last
note.
You
can
really
go
to
from
by
the
way
node
zero
representation
at
the
beginning
of
a
universe,
for
example,
is
emptin
empty
version
basically
beginning
of
this
particular
resource.
Zero
means
it's
empty
and
you
can
go
to
this
particular
version
in
multiple
ways,
for
example,
go
from
0
to
105.
C
and
you
can
go
full
replacement,
go
from
zero,
for
example,
103
and
full
replacement,
and
then
you
have
increment
update
from,
for
example,
from
103,
124
and
105,
and
eventually
the
latest
version.
You
can
go
to
wow
six,
so
that's
basically
how
data
will
be
represented
and
how
they
can
be
really
transferred.
For
example,
let's
go
back
to
the
auto
contact.
Let's
understand
why
this
is
Meaningful,
so
imagine
a
cosmetic
cosmetic
model
for
for
this
certain
deployment,
360
versions,
360
000
of
entries
and
so
on.
So
that's
basically
the
cost
map.
C
So
therefore,
what
happens
in
the
deployment
is
very
simple,
is
initially
it's
empty
and
then
we
compute
the
version
of
the
Holocaust
map,
and
then
you
went
very
quickly.
For
example,
we
query
a
bdp
looking
Galaxy
server.
We
get
a
new
new
cost
for
some
peers.
We
upload
those
guys,
we
get
a
new
version,
a
data
and
so
on.
We
continue
and
we
pull
another
server.
Pdp
server
or
we
put
another
example,
for
example,
a
query,
for
example
using
gradient
graph
and
so
on.
We
get
another,
for
example,
data.
C
We
update
some
some
other
costs.
We
continue
to
produce
all
kind
of
data
and
then
once
in
a
while
in
the
background-
and
we
have
the
auto
server
in
the
deployment
with
a
computer
snapshot,
for
example,
initially
we
have
snapshot
or
101,
we
compute
snapshot
of
103
and
once
in
a
while,
we
compute
snapshot
of
105.,
so
those
Snapchat
will
be
made
available
to
give
to
the
clients
and
for
different
clients
they
might
want
to
acquire
different
ones.
C
C
Then
you
get
a
new
client,
for
example.
Also
trying
to
do
another,
for
example,
for
FTS
or
Russia
would
have
14
instances.
You
get
a
second
version,
get
started
and
reboot
it
and
so
on
they
get
started.
They
might
want
to
fetch
a
new
snapshot,
for
example
starting
from
version
one
or
five.
So
therefore
the
get
snapshot
over
there.
They
continue
to
get
all
the
updates
to
really
maintain
the
latest
version
of
custom
app.
So,
therefore,
that's
really
a
representation
of
the
data
of
a
data
model.
Next
slide.
Please.
C
So
here,
if
you
have
a
data
model
and
now
the
transfer
model
in
a
system
design
transport
protocol
is
now
quite
simple.
It's
a
transfer
is
incremental
RBA
transfers.
So
basically
it's
very
simple.
It's
now,
every
you
know
every
link,
every
Edge
on
the
graph
is
labeled
and
label.
Clearly
label
is
from
initial
version
to
the
targeted
version
representing
what
the
data
really.
It
is,
for
example,
from
zero
to
one
one
it
would
have.
It
would
be
as
an
ID
of
0-1.
Of
course,
later
we'll
talk
about
the
exact
grammar.
C
Next
one
is
101
to
102..
It
doesn't
representing
the
transfer
of
data,
which
is
which
data
you
want
to
fetch
from
the
server
and
then,
if
you
patch,
you
forget
the
data
and
then
you
apply
the
operation
of
the
data
and
you
get
the
next
version.
Eventually
you
get
to
the
latest
version.
You
may
not
need
to
get
a
related
version.
Oftentimes,
for
example,
cost
map
really
doesn't
have
to
be
like
a
latest
version
at
all,
and
you
have
a
reasonable
snapshot,
consistent
snapshot.
C
You
can
do
all
kinds
of
selections
and
planning
already,
but
somehow
should
be
consistent.
That's
why
you
should
get
a
data
in
a
consistent
way.
So
therefore,
the
overall
transfer
now
can
be
modeled
by
the
following
a
model
on
the
right
hand,
side
step.
One
always
is
map
based
resource
ID
in
increment
to
increment,
to
transfer
representation,
IDs
based
model
right,
for
example,
a
cost
map
for
this
particular
class
map,
and
then
what
that
transfers
is
one
zero
to
101
and
1
1
to
102.
This
should
be
really
mapped
into
the
system.
C
That's
over
system
designed
to
go,
and
then
we
have
the
mapping
now
actually
transfer,
as
protocol
is
quite
simple
to
design
and
one
is,
you
can
use
a
client
pool
like
client
can
pull
continuous,
for
example,
suppose
I'm
a
client
I
already
have
version.
103
I
want
to
put
103
to
104
and
then
one
four
to
one
five.
One
five
to
106
continue
to
push
me
into
more
updated
version,
and
then
you
can
also
use
server
approach.
Now
the
server
push
would
have
all
IDs
and
all
IDs
and
the
server
for
example,
said.
C
Oh,
the
client
has
103
I'm
going
to
push
you
103
to
104,
username
and
I'm,
going
to
push
you
140.5
and
then
I'm
going
to
push
you
105
tomorrow,
6
and
so
on,
and
if,
for
example,
there's
a
reboot,
the
server
can
put
you
from
zero
to
105
and
then
one
five
to
round
six.
So
the
server
can
pick
the
right
one
to
push
it
to
the
client
continuously.
So
either
way
can
work.
C
C
So,
given
this
one-
and
there
are
one
design
issue
which
I
think
also
raise
up,
email
review
is
through
the
mapping
from
the
base
protocol
until
the
increment
update
to
be
persistent
resource
or
somehow
to
be
procession.
Persistent
basically
means
the
defaulting.
You
get
a
base,
ID
based
resource
on
the
left
hand,
side,
and
you
get
all
the
increment
increment
to
update
the
resources.
Should
this
one
be
always
available
and
always
around
and
so
on,
and
therefore
anyone
can
create
it
at
any
time
so
become
Universal,
which
would
have
all
kinds
of
nice
properties.
C
C
So
therefore,
it
decided
to
provide
A
View
to
a
client
and
when
a
session
is
closed,
the
view
is
removed,
of
course
doesn't
mean,
for
example,
this
graph
This
Server
will
remove,
for
example,
the
servers,
the
server
server,
our
Auto
server
or,
for
example,
the
overall
server
might
maintenance
all
the
time,
but
you
may
not
really,
for
example,
always
deleted
when
client
opens.
For
example,
your
controller
comes
in
open
it.
You
can
see
The
View
when
they
close.
This
will
disappear.
That's
what
I
mean
it's
graphic
deleted
and
very
likely.
C
C
Cuban
is
one
now
here's
overall
particle
structure.
The
protocol
structure
is
the
following,
and
initially
the
client
want
to
get
into
about
resource.
For
example,
a
central
incremental
transfer
of
resources
conductors
increment
resources
or
inventory
transfer.
So
what
happens
is
volume
and
essentially
the
client
or
the
first
really
issue
an
incremental
Gap?
Is
it
an
open
and
specify
the
base?
Resource
One,
let's
be
proud
to
end
right.
Remember
the
session
based
the
front
end
we'll
do
the
mapping
we'll
tell
the
client
okay,
what
exactly
is
the
mapping
of
all
these
resources?
C
This
is
why
central
to
provide
the
information
for
the
client
to
be
able
to
really
fetch
the
list
of
all
equipment
updates
and
also
can
get
the
data
income
updates.
So
therefore
we
did
the
assuming
that
if
you
look
at
this
fundamentally
graph,
Aggregates
directory
and
every
single
act
is
really
the
content.
So
therefore
you
can
open
it
and
and
increment
update
get
it.
Then.
Actually
you
get
this
whole
graph
directory
and
then
you
can
patch
the
data
or
you
can
get
information.
You
can
directly
to
proceed
next.
One.
C
Another
client,
of
course,
can
also
do
the
in
the
same
session
can
have
an
incremental,
for
example,
open
our
base
resource
too,
and
then
we'll
gather
this
in
essential
basic
information,
and
then
the
client
would
be
able
to
start
really
fetch
information
as
well,
so
the
server.
Basically,
if
you
look
at
it,
server
basically
provides
three
types
of
resources:
R1,
which
is
front
in,
and
open
and
R2
resource
type.
2
is
a
directory
and
metadata,
and
three
R3,
which
is
real
data,
basically
edges
of
all
the
data.
C
So,
given
its
design
and
now
one
design
decision,
I
think
that's
also
one
review
questions
and
is
exactly
how
the
three
types
of
resources
should
be
really
deployed
into
the
system.
And
if
you
really
want
the
maximum
flexibility
and
what
you
can
do,
is
you
put
all
three
resources:
either
three
different
Uris
and
you
can
have
the
most
flexibility.
So
therefore
that's
a
certain
color
design,
flexible
in
the
middle,
then
you
can
also
have
the
design,
which
is
all
three
type
of
resources,
should
be
either
a
single
server.
C
So
therefore
you
open,
you
use
the
same
URI
you
open
it,
and
then
you
can
get
a
directory.
You
can
fetch
directory
in
the
same
connection
at
the
same
server
and
you
can
do
the
same
connection,
each
TCP
or
quick,
whatever
connection,
and
then
you
can
get
all
the
data
and
so
on.
So
that's
the
design
single.
C
Then,
of
course
you
can
also
have
a
compromise
where
the
directory
and
the
data
we
put
into
the
same
same
location
and
front
end,
can
be
at
different
locations
and
so
on.
So
therefore,
quite
a
lot
of
interesting
design
points
and
in
particular
the
more
you
want
to
separate,
for
example,
you
really
can,
for
example,
when
a
directory
can
point
in
every
data
at
different
locations,
you
can
achieve
quite
quite
a
high
level
of
flexibility,
income
load
balancing,
but
also,
of
course,
I
had
a
complexity,
income
session
management,
So.
C
Eventually,
the
decision
for
this
current
document
is
we
proceed
with
a
single
design,
meaning
all
three
types
of
resources:
front-end
directory
and
also
data.
We
collocated
into
a
single
server
to
simplify
the
session
management
and
later
versions
can
can
externally
design,
but
right
now
that's
the
main
design.
Therefore,
hopefully
answer
the
question
from
a
couple.
Videos
next
slide:
please,
okay!
So
given
this
one
now
exactly
given
that
all
information
will
be
essentially
at
the
same
server
and
how
exactly
now,
this
information
right,
essential
information,
your
fetching
is
directory.
C
So
therefore
the
client
can
pull,
or
also
the
data
which
we
essentially
add
labeling
our
edges.
So
exactly
how
do
we
label
all
these
information
in
a
very
simple,
coherent
way,
make
it
as
simple
as
easy
to
understand
possible.
So
your
virtual
decision
is
use
some
kind
of
directory
structure,
so
imagine
mapping
code
Uris.
C
So
when
a
client
opens
the
the
incremental
transfers
and
the
server
will
return
a
type,
what
we
call
tips
new
root
right,
it's
a
root!
Imagine
it's
a
directory,
and
this
one
we
separate
into
a
subdirectory
of
folders.
If
you
like,
here's
the
first
one
is
I'll,
be
the
cube,
obvious
Cube.
Second,
one
will
push
so.
Therefore,
all
kinds
of
Transport,
State
Etc
can
be
put
into
the
same
directory
and
organizing
a
directory
structure.
C
Therefore,
you
very
easy
to
map
into
a
UI
inside
each,
for
example,
a
RPS
Cube
and
essentially
is
using
some
kind
of
adjacency
list
of
data
structure
or
directory
structure,
for
example,
and
the
first
version
always
be.
For
example,
the
top
level
will
be
also
the
base
starting
version
number.
For
example,
if
you
always
start
from
zero-
and
you
can
also
be
have
101
1021314105
because
essentially
remember
all
these
obvious
essentially
is
from
one
version
to
go
to
the
second
version
of
patch.
C
So,
therefore,
if
you
have
zero
and
you
can
go
to
101
full
replacement
from
zero
to
one
three
from
zero
to
105.,
so
basically
is
updates
q
and
from
version
0
go
to
101.
So,
therefore,
if
you
fetch
the
content
of
0
101,
you
get
a
411
content.
You
go
zero
one
five
you
get
essentially
the
105
version
content.
You
can
also
have
very
small
data,
typical
case
from
101
to
102
that
essential
to
give
you
a
patch,
very
easy
to
really
understand
the
structure.
C
How
data
has
to
maintained
varies
to
maps
for
various,
for
people
to
remember,
and
so
on.
So
now
actual
location
is
very
simple.
If
you
think
about
a
implementation,
and
of
course
we
don't
talk
about
implementation,
but
support
you
want
to
implementation,
you
get
all
the
updates
or
income
updates
how
you
store.
It
is
very
easy
and
you
can,
of
course
you
can
store
it
into
a
file
system
and
install
it
in
this
given
way
and
whenever
request
easily
using
a
front-end,
just
reply
very
easy
to
implement.
C
Of
course,
this
one
can
be
also
virtual,
but
that's
less
implementation,
but
we
want
implementing
to
be
easy
sort
of.
Basically,
every
UI
become
is.
If
you
look
at
right
hand,
side
is
tapes,
view,
root,
slash,
uq,
slash,
I,
slash,
UK
version,
I
version,
J
and
then
client,
who
is
very
easy,
is
the
get
tapes
will
root,
slash
uq,
for
example,
0
105,
you'll,
fetch,
essential
lab
content
and
uq105106.
You
can
get
other
one
and
silver
push.
Also
very
easy:
you
can
just
use
a
URI.
Everything
is
the
name.
You
know
equipment
way.
C
D
C
C
D
C
That's
a
good
question
too,
and
this
moment,
of
course,
this.
We
consider
this
one
as
implementation
right
and
you
can
imagine
the
typical
implementation
is
the
following,
for
example,
in
a
lot
of
digital
systems,
what
you
do
is
for
a
large
resources,
for
example,
a
lot
of
cost
map
and
you
probably
get
increment
updates
very
quickly.
For
example,
if
I'm
a
server
for
the
auto
server
implemented
for
certain
or
large
ones,
I,
for
example,
push
pool,
for
example,
the
b2p
Looking
Glass
server
from
one
project.
C
Entry
and
I
will
get
a
new
entry,
and
my
server
is
very
busy
I,
don't
I
mean
I
even
process
it,
for
example,
I
would
just
put
it,
as
in
I
would
compute
the
incremental
cost
for
this
relevant
cost.
I
put
it
as
patch
myself,
I,
even
don't
compute
a
full
cost
map
myself,
I'm
Auto
server,
I
put
it
there,
but
once
in
a
while,
I
might
have
separate
thread
when
it's
available
I
compute
a
full
or
snapshot
to
update
the
whole
map.
So
therefore
I
would
do
it.
C
D
Yeah
there
seems
to
be
a
notion
of
granularity
that
the
graph
gives
gives
the
operator
a
way
to
to
tune
the
ground
polarity.
So,
for
instance,
if
a
client
is
interested
in
getting
the
like
a
fine-grained
granularity
on
other
Snapchats
say
each
of
an
object
is
like
an
update
every
second,
then
you
would
get
the
the
whole
sequence,
but
then
another
client
might
be
interested
in
just
getting
One
Direction
every
minute.
D
So
then
you
would
be
jumping
out
like
from
one
on
to
another
and
skipping
the
other
nodes,
so
so
that
could
drive.
Maybe
the
way
to
design
this.
This
graph
from
from
a
server
standpoint
like
like
you,
wanted
to
get
an
ID
every
every
10
seconds,
and
then
you
would
skip
like
10
notes
and
jump
the
next
one
or
something.
C
D
C
That's
why
you
see
only
two
types
from
zero
to
a
version
number
or
essential
from
I
n
to
n,
plus
one
and
eventually
we
might
imagine
there
may
be
some
capabilities
or
really
jump
from
one
word
to
another
version
to
provide
capabilities
to
help
with,
for
example,
clients,
but
right
now
the
deployment
is
the
setting
can
be
flexible,
but
it
currently
we're
focusing
on
the
case
will
be
essentially
only
two
types,
but
very
very
good.
Actually,
that
really
drives
a
lot
of
design
decisions
about
why
this
representation
is
generic?
C
Okay,
good,
it
comes
wonderful!
Thank
you
so
much
okay.
So
can
you
go
to
protocol
design
yeah
next
slide,
please,
okay,
so
the
protocol
actually
essentially
now
is
relatively
easy.
I'll
explain
to
us
to
specify
it
really
consists
of
four
components:
one
is
the
information
resource
directory
announcer.
If
you
provide
such
a
mapping
from
a
base
protocol
basic
resource
to
a
set
of
increment
transfers-
and
you
can
announce
it
using
the
auto
design,
the
second
piece
is:
you
need
to
open
it
and
you
need
to
close
it.
C
So,
therefore,
we
don't
want
to
serve
it
to
be
too
busy
and
for
Pusher
server
push
and
to
really
maintain
a
view.
So,
therefore,
we
do
have
open
closed
mechanism.
Sorry
for
the
second
component,
and
when
you
open
you
get
the
mapping
to
the
directory
and
the
client
can
really
try
to
really
manage
and
read
or
manage
actually
the
directory
amount
of
data
in
Professor
approach.
C
So,
therefore,
the
third
component
is
metadata
and
directory
access
last,
one,
of
course,
really
raw
data
transfer
and
really
get
that
all
the
incremental
changes
and
get
all
the
data
server
for
that
first
component,
we're
going
to
go
over
one
and
HP
is
a
one
by
one
and
to
give
you
a
complete
picture
of
final
design.
Next
slide,
please
it's
ird.
Should
we
now
be
pretty
familiar
for
people
who
are
familiar
with
auto,
but
we
don't.
We
do
want
to
go
over
a
little
bit.
What
structure
looks
like
so
paste?
C
It
here
is
announced
in
an
information
resource
directory.
If
you
provide
such
a
service,
for
example,
here
is
update
my
cost
tips
and
only
upper
right
corner,
and
therefore-
and
here
is
your
announce-
you're
going
to
provide
it,
and
so
if
why
you
can
realize
this
one,
it
provides
such
a
service,
because
the
media
type
is
Oracle
text
Json.
So
that's
really
a
media
type
and
of
course,
you
specify
the
uses
you
you
see,
hey
for
which
Auto
resources
you're
going
to
provide
such
a
service.
C
Here
the
example
is
you
provide,
for
example,
this
for
services.
Basically,
users
indicate
about
this,
and
of
course-
and
you
also
have
capabilities
and
One
requirement
for
the
protocol-
is,
we
must
provide
capability
of
negotiation
or
selections.
So
here
the
server
can
indicate
that
hey
I
really
want
I
can
provide
the
following
capabilities,
and
first
capability
is
incremental
change,
media
types
because
you
can
encode
for
the
address
right
and
in
different
types
here
you
must
indicate
for
each
resource
ID.
What
type
of
incremental
changes
you
might
be
able
to
provide
by
the
server
they
might?
C
We
can
server
choose
it.
For
example,
if
you
look
at
the
example
in
the
middle
after
the
capabilities,
for
example,
my
network
map
and
you
can
support
Json
patch
and
for
my
working
class
map
I
support
the
merge
patch,
for
example,
you
can,
you
can
enumerate
all
the
resources.
What
incremental
updates
you
added
essential
types
can
appear.
You
can
really
enumerate
it.
Then
you
can
also
specify
that
device
support,
for
example,
server
push
or
not,
and
you
can
indicate
two
and
by
default.
Of
course.
C
C
And
then
you,
open
and
open
is
also
very
simple
click.
Basically,
it's
really
open.
Of
course,
we
are
following
all
the
rest
for
API.
There's
no
concept
called
open,
essentially
you're,
creating
a
concept
open,
really
is
creating
a
state.
So
therefore,
you
must
clearly
use
a
post
as
a
method.
So
therefore
paste
it,
your
usern,
post
and
with
the
body
and
the
body
is
specified
on
the
tips
request
on
your
lifepen
site,
so
essentially
with
potential
included
for
fuse.
One
is
resource
ID
which
resources
are
interested
and
the
next
one
will
be
input.
C
For
example,
for
some
like
resources,
you
might
have
an
input,
that's
the
third
one
you,
for
example.
If
a
custom
map
you
do
a
filtered
cost
map,
you
can
specify
the
input
and
then
for
every
resource.
You
you
have.
A
client
already
has
a
version
of
the
resource
and
remember
you
have
a
tag.
Remember
every
version
would
have
tag
you
can
indicate
which
tag
you
have
so.
C
Therefore,
a
server
can
really
get
started
into
the
right
version
with
it
and
then
also
here,
if
you
can
write,
an
eventual
decision
is
really
simplified
effort
a
little
bit.
We
decided
to
provide
produce
a
single
document,
so
therefore
you
can
also
indicate
U1
server
push
and,
if
not,
if
you,
if
you
do
server
approach,
can
also
be
getting
started
and
of
course
later
you
can
also
modify,
but
here
is
in
open.
You
can
indicate
by
itself
so
right
hand.
C
Side
essential
is
an
example
right
and
impose
tapes,
the
cars,
and
then
you
specify
resource
ID.
Is
my
login
cost
map
and
you're
done
with
it.
So
here
there's
a
small
issue
and
RC
88
at
95
special
attacks
only
for
get
resources
only,
but
little
version
can
do
for
both
resource
and
also
input.
So,
therefore,
for
this
document
we
allow
for
both
tag
for
both
essential
get
resources
and
also
post
resources,
for
example,
filtered
cost
map
search
for
that's
overall
design.
C
So
here's
the
response
and
response
is,
on
the
left
hand
side.
So
you
can
see
that
response
essentially
defines
two
attributes
and
the
first
one
is
transport
State
view
root.
Remember
and
you
put
it
at
the
location
as
essentially
the
root
directory
where
it
is
and
then
we'll
give
you
a
summary
C
summary,
and
we
can
we
we
thought
about.
We
don't
gave
State
summary
at
all,
but
we
want
to
simplify
the
workflow.
We
don't
want
to
client
now
issue.
The
second
query:
we
want
to
send
a
summary
given
Universal
request.
C
So
therefore,
that's
essentially
it's
a
way
to
reduce
one
round
of
time
and
it
potentially
can
have
a
very
streamline
our
client
mode.
So
what
exactly
transports
is
summary
include
so
right
now
it
includes
two
types
of
summary:
if
you
look
at
the
second
object
and
one
is
up,
the
Q
summary
and
one's
push
update
summary
if
it
requires
approach
updates.
So
what
is
the
object?
Q
summary
essentially
include
two
things.
So
what
start
secret
number
and
what's
the
end
second
number?
C
Currently,
the
server
will
provide
the
queue
right,
provide,
essentially
the
data
and
what's
the
first
version,
number,
what's
the
last
version
number
and
then
the
server
can
return
to
the
client.
The
client
can
already
use.
Remember
if
you
know
secret
number,
you
can
construct
accurate
request
already,
and
then
you
have
the
server
push
summary.
Essentially,
what's
a
state
server
push
it's
true
or
false,
and
then
what's
the
next
number,
that
is
at
the
bottom
of
left
column.
So
that's
the
summary
and
that's
response.
C
The
right
hand
side
gives
you
a
very
simple
example,
so
you
they
will
tell
you
the
root
is
tips.
Give
some
concession
number
must
be
unique
within
the
single
session
and
then
give
us
a
summary.
For
example,
starting
number
is
101
and
it's
a
signal
number
106
following
our
example.
So
therefore
that's
essentially
what
really
works
here.
The
requirement
is,
the
view
must
be
an
absolute
directory
after
the
server.
So
now
everything
all
the
other
uis
will
be
constructed
in
in
this
way.
C
Of
course,
in
later,
if
there's
an
extension
and
the
root
can
be
a
different
server,
then
you
really
should
give
absolute
UI
include,
for
example,
the
server
and
the
name
server
server
port
number
at
different
server,
but
for
now
we're
happy
to
go
to
a
local,
absolute
UI
next
slide.
Space
here
is
Clan
view.
A
initial
response
and
client
can
indicate
attack
for
this
resource
and
if
the
server
identifies
a
matching
node
ID
for
this
given
tag
and
server
can
return
starsequent
number
to
equal
that
one.
Otherwise,
we
do
recommend
I.
C
Think
that's
one
question
asked
by
Jody
and
so
on,
and
is
that
initial
view
is
last
snapshot,
for
example
105
in
that
critical
example,
and
of
course
that's
only
recommended
and
the
server
can
really
return
anything
that
possible.
Of
course,
they
must
give
a
consistent
path
which
we'll
talk
about
shortly
and
severeign
state
online
server
push.
So
the
server
basically
help
you
to
pick
initial
good
starting
point
really
to
get
you
all
increment
updates,
but
really
it's
only
recommended
and
the
easy
one
just
gave
you
your
first
second
number.
C
But
if
you
have
something
we
can
streamline
a
little
bit,
do
some
optimization
which
we'll
talk
about
shortly
next
slide,
please
so,
let's,
let's
open-
and
now
you
can
also
close
close-
is
very
simple
and
if
the
client
will
say,
delete
and
give
this
root,
ID
this
whole
state
or
would
delete
it
from
The
View.
A
client
can
no
longer
see
the
view
and
all
push
updates
and
all
stuff,
essentially,
oh,
which
will
be
stopped.
C
Essentially,
analysis
is
a
transport
tips
session
is
over
sort
of
is
over
and
also
of
course,
you
can
close
the
connection.
We
always
imagine.
This
open
is
embedded
into
a
connection.
That's
all
we're
defining
the
product
context.
You
know
TCP
and
or,
for
example,
quick.
We
all
Define
a
concept
of
connection.
If
you
close
the
connection
overall
and
essential
equivalent,
you
have
your
iterator
go
through
every
single
open
view.
They
all
be
iteratively.
C
C
C
Okay,
request
is
very
simple
and
if
a
client
wants
to
really
get
a
a
a
what's,
the
essential
of
the
graph
looks
like
the
client
should
say,
get
and
the
transport
say
the
view
root
and
slash
uq,
so,
basically
using
the
total,
the
Unix
file
system
semantics.
Essentially
you
just
iterate
over
the
file
system
and
get
all
the
information
recursively
and
anyone
which
is
not
like
a
real
file.
So
therefore,
you
get
the
whole
information.
So
therefore
the
definition
essentially
is
specified
on
the
lower
left
corner.
C
The
first
object
is
essential
object
directory
and
which
is
extension
from
response
entity
based
from
the
auto-based
protocol
and
each
one
actually
is
office.
Map
and
update
update
map
is
defined,
as
second
object
object
map
and
from
Star
second
number
to
end
second
number
secret
entry
number
update
and
any
second
number
update
is
defined
as
a
third
object,
essential
integral
number
to
update
a
add.
The
item
matter
and
update
meta
actually
is
I.
Think
there's
a
formatting
slightly
different,
so
you
may
not
be
able
to
see
column
included
four
or
three
entries.
C
It
will
be
metadata
type
and
media
type
and
what
type?
What
type
hack
it
is
and
also
the
size
so
therefore,
the
size
I
think
it's
black
over
there
I
think
we
have
different
PowerPoint,
slides
so
right
hand,
side
is
an
example,
so
you
won't
get
on
get
the
the
directory.
They
give
you
automatic
information
about
essential,
because
this
one
also
changes
the
directory.
Also
changes
all
the
time.
C
So
therefore
we
give
them,
we
give
a
b
tag
as
well,
and
then
what
you
can
see
is
essential,
update
map
essential
on
Instagram
zero
as
a
secret
number
and
go
to
101,
and
you
have
the
data
and
zero
to
one
three
data
and
so
on
zero
one
five.
So
essentially
it's
very
clear
way
of
encoding
and
adjacent
list
and
also
actually
makes
it
more
detect
very
easy
to
deal
with,
as
you
can
see
later
next
slide,
space.
C
You
can
also
do
a
filter
directory
request
there.
It
becomes
filter.
You
must
really
give
essentially
the
filter.
So
here
the
filter
is
very
simple.
Is
that
and
you
give
a
post
and,
of
course,
on
the
same
directory,
but
now
you
essentially
Define
the
future.
The
future
of
the
attack,
so
essentially
you
indicate
which
version
you
already
have
another
system
essential
now
is
very
simple:
it's
going
to
start
from
that
tag
and
instead
of
that
node
ID
to
really
filter.
C
So,
therefore,
basically
now
you
can
use
the
merge
pack,
for
example,
suppose
now
you
want
to
really
do
one
and
then
you,
you
want
to
say:
hey
I
have
the
version
already
and
from
the
previous
version
of
the
directory.
Now
what
I
have
changed
support
the
server
has
deleted
version
of
101
and
102.
Add
a
new
version
of
107
I
think
you
may
not
be
Alum
and
so
on.
So
therefore,
you
basically
just
get
a
mod
patch,
for
example,
right
hand:
side
is
the
compute
version
left
hand.
C
Side
essentially
is
user
mode,
basically
zero
to
one
deleted.
You
would
you
you
will
get
a
zero
one
or
one
now
and
0.7
is
a
new
entry.
You
get
0.7
your
entry
and
so
on
so
forth,
user
mode
pad
can
very
quickly
do
an
incremental
push
updates
or
even
a
directory
itself.
So
that's
a
coherent
design.
That's
called
the
future
Direction
request
next
slide.
Please.
C
And
someone
Jordy
ask
and
that
also
review
asked
about
what's
the
consistency
in
terms
of
the
server
incremental
data,
so
we
have
a
following
environment
of
update
data.
This
is
called
Integrity
number.
One
is
called
continuity.
Basically,
whenever
the
server
maintains
all
the
versions
and
support
initial
version,
the
smallest
version
called
NS,
the
larger
version
is
called
NE
and
and
then
the
server
must
maintain
that
all
versions
from
NS
to
any
you
should
not
have
any
gap
before
consistency.
That's
called
continuity.
C
If
you
have
you
specify
101
106,
you
must
have
version
101
all
with
106
to
be
serialized
feasibility
and
a
server
must
have
maintained
a
direct
link
to
NS.
You
must
have
the
version
over
there.
So
therefore
you
can
always
directly
go
from
zero
to
NS
to
make
it
always
a
feasible
request
from
zero
to
NS
to
get
started
and
also
right
shift
only.
Basically,
you
should
not
go
back
to
time.
C
So
if
a
client
requests
and
gets
nsne
at
10p
and
then
request,
for
example,
at
time,
T
Prime,
which
later
time
get
NS
Prime
and
any
Prime,
then
the
version
numbers
and
as
Prime
must
be
greater.
You
could
do
NS
and
also
any
Prime
must
be
good,
oh
yeah,
and
you
basically
your
only
right
shifting.
You
cannot
really.
For
example,
it's
only
go
back,
get
a
new
version,
but
confuse
the
fetching,
long
pool
or
prediction
or
to
configure
the
server
push.
Okay
next
slide,
please!
C
C
Yeah
next
slide,
so
individual
request
now
actually
is
very
simple,
very
clean
and
it's
basically
get
URI
and
how
to
construct
UI
is
very
simple
and
it's
taking
the
root
directory
right.
Transporter,
CW,
root,
slash
uq
rpmq
and
slash
I,
slash
j.
I
is
initial
secret
number.
Ga
is
in
version
number,
and
then
you
just
get
the
data,
for
example,
right
hand
side
over
here
give
example
of
if
you
look
at
upper
right
corner
is
update
q
and
in
from
version
0
to
101
island
server,
just
a
central,
cable
content.
C
Here
the
silver
must
accept
the
media
type
of
encoding.
For
example,
here's
Auto
cost
map
and
maybe
other
versions
can
be
plugged
with
increment
update
using
wordpad
or
whatever
the
client
mass
is
accepted.
The
client
can
know
the
potential
types
by
reading
the
ird.
We
already
said
next
slide.
Please.
C
We
do
have
the
following
policies
about
individual
update
item
request,
processing
at
the
server
and,
if
possible,
that
conducts
proactive,
fetching
or
future
updates
right
because
remember,
we
won't
allow
all
kinds
of
parallel
and
long
pool
and
take
advantage
of
hb2.
So
therefore,
a
potentially
you
requested
version
which
are
not
not
existing
yet.
So.
Therefore,
here
is
the
recommended
policies.
One
is
server
processing
a
client
book.
A
central
client
would
send
a
request
of
eye
energy.
C
So
if
the
ing
already
exists
in
the
middle,
you
can
see
that
first,
if
condition
you
return
content
using
encoding,
because
you
should
have
a
content
already.
We
have
this
requirement
and
if
I
to
Jade
is
not
existing
yet,
but
somehow
can
be
considered
as
prefetch,
for
example,
from
I
to
J
is
the
latest
version
from,
for
example,
from
106
to
107
and
and
there's
a
local
policy.
The
server
set
as
acceptable
prefetch
example
and
we'll
put
requests
into
backlog
queue
with
a
potentially
block
over
there,
eventually
understandable
requirement.
Otherwise,
the
server
should
return
error.
C
It
is
recommended
that
the
server
always
allow
prefetch
from
Instagram
numbered
in
second
class
one.
So
therefore,
the
client
can
always
request
slash
Instagram
number
slide,
increasement,
plus
one
to
allow
prefetching
over
the
content,
but
that's
the
real
policy,
for
example,
of
preferred
client
must
indicated
in
set
media
type.
So
you
must
be
able
to
predict,
for
example,
if
you
refreshing
something
it's
not
in
the
directory
already,
and
you
must
use
ird
to
really
include
all
the
potential
types.
Otherwise
it
can
be
an
error
next
slide.
Please.
C
So
here
are
the
error
conditions.
So
we
want
to
recommend
the
following
error:
condition:
answer
a
lot
of
questions,
I,
think
I'll,
ask
it
during
our
weekly
meetings
and
also
in
the
reviews.
So
here
are
the
potential
four
potential
error
cases
to
really
indicate
the
client
to
be
more
informative.
One
is
for
10
gun.
If
an
update
has
secret
number,
that's
smaller
than
the
Star
Circle
number,
let's
go,
it
will
not
never
come
back
again.
So
therefore,
the
server
wants
to
tell
the
clan
is
gone
for
10.
C
and
a
for
the
clan,
for
example,
and
a
requested
type.
But
that's
the
indicator.
Correct
meter
type
because
somehow
in
the
predictable
media
type
is
protective
system
and
immediate
type
is
not
right
and
the
server
can
get
a
free
thing
to
tell
like
media
type,
not
supported
and
even
perfect
window
is
exceeded.
For
example,
you
any
signal
number
plus
10,
that's
not
a
second
number
and
a
server
can
really
tell
the
client
can
really
return.
Error
inside
blocking
said.
Okay,
too
early,
you
see
the
perfect
Amendment
window,
you
return
425.
C
and
then
also
if
we
want
to
really
don't
allow
too
much
prefetching
and
to
really
to
cause
all
overhead
and
and
backlog
Queue
at
the
server
and
server
essential.
That
has
a
local
policy,
which
is
kind
of
operational
discussions
is
if
a
number
of
opinion
request
is
too
many,
and
it
should
return
for
29
too
many
requests.
So,
therefore,
those
are
the
error
conditions.
So
therefore
those
things
can
handle
make
it
as
as
current
as
possible.
Next
slide,
please.
C
Surplus
now,
actually
also
a
question
is
simple:
to
implement
when
client
user
tips
there
is
whose
ID
indicates
server,
support,
server
push
and
then
the
client
can
managers
push
state.
So
initially
it's
very
simple
and
when
you
create
initial
State
and
if
the
server
says
server
push
in
the
open
right,
post
command-
and
you
can
start,
they
put-
you
know
server
port
at
start.
Of
course,
you
can
also
change
the
push
state
in
the
middle
of
the
whole
session.
C
So
therefore
one
is,
you
can
really
essentially
use
all
the
put
all
the
reservoir
API,
because
remember
that's
the
future
directory
you
can
put
and
change
the
value
and
so
on.
You
can,
for
example,
you
can
put
and
transport
the
state
view,
root,
slash
push
and
you
can
see
super
push
2,
then
that
will
start
server
push
and
if
you
put,
for
example,
the
the
the
same
URI
and
you
have
server
portal
false,
essentially
stop
right.
It's
centered
report.
C
You
can
realize
the
push
data,
basically
is
you
can
get
in
the
push
and
then
Etc
of
the
server
will
return
the
directory
and
the
purchase.
The
subdirectory
would
have
a
server
push,
and
the
two,
for
example,
will
tell
an
X6
number.
Next
number
is
when
this
next
example:
let's
talk
about
what
push,
if
it's
ready
already
so
that's
essential,
give
a
little
bit
information
about.
What's
going
on
next
slide,
please.
C
So
the
only
thing
here,
slider
complexity
is
when
a
server
conducts
push
and
the
server
must
must
select
a
push
path.
Remember
the
incremental
data.
Accurate
is
a
graph
right
from
I
to
J.
You
know
from
0
to
101
and
1
1
to
power
two
zero
to
one
three
and
so
on,
so
exactly
how
to
really
pick
a
push.
A
path
right
essentially
on
the
server
is
selecting
path,
a
path
on
a
graph
to
push
it
on.
C
The
client
objective
of
the
server
is
to
push
the
latest
version
to
the
client
using
the
lowest
cost
cost
defined.
As
sum
of
sizes
of
all
edit
right
is,
if
you
pick,
for
example,
a
path
on
a
graph,
essentially
you're
pushing
a
given
amount
of
data.
So
therefore,
right
now
the
recommended
goal
is
pick
a
password
which
minimizes
the
sum
of
the
sizes
of
edges
to
go
from
the
client
current
state
to
the
latest
version.
C
So
therefore,
recommendation
algorithm
at
server
is
a
following:
algorithm
is
compute
the
purchase
path
using
the
following
algorithm
upon
each
event:
Computing
approach:
whenever
server
one
push
the
decline,
what
they
do
so
you
first
compute
initial,
the
the
current
the
current
current
version
and
and
see
so
what's.
Nc
is
currently
working
on
the
clan
already
has
so
initialization.
If
request
has
attacked
and
the
the
version
number
is
what
the
client
has
already
able
calendar
doesn't
have
any
version.
Of
course
the
initial
version
is
NC
equal
to
zero.
C
So
you
know
what
the
kind
of
working
current
version
is,
and
otherwise,
if
it
is
England
made
of
not
initial-
and
you
are
really,
for
example,
pushed
into
the
card
because
you're
doing
a
push
past
selection,
all
the
time
and
that's
essentially
the
end
state
right.
So
therefore,
it's
a
push.
So,
therefore,
what
you
do
is
from
another
kernel
version:
you
compute
the
shortest
path
from
current
version
to
link
to
the
version.
So
let's
pass
from
NC
N1
N2
all
the
way
to
the
latest
version.
C
Next
signal
will
be
equal
to
M1
and
on
the
shortest
path
right,
because
NC
NY
next
one
and
so
on.
Therefore,
the
server
just
using
push
promise
and
so
on
push
okay.
The
URI
is
current
prostate
review
root
under
q
and
C
two
and
one,
and
it
can
be
zero
initially
and
one,
for
example,
can
be
one
or
can
be
one
on
five
or
can
be
one
five,
one
or
six.
So,
whatever
server
portion
to
pick,
they
push
past
selection.
Okay,
next
slide.
C
There's
one
more
complexities
and
about
the
push.
If
you
are
pushing
across
multiple
resources,
for
example,
you
have
a
network
map,
you
also
will
have
the
custom
app
and
they
have
dependencies
and
they
have
different
graphics
and
so
on.
So,
therefore,
if
it
really
is
a
client
pull
controversy,
what's
dependency,
and
so
on
so
for
client,
Community
pull
the
data
in
a
given
order.
You
want
to
pull,
for
example,
the
corresponding
Network
map
before
you
pull
the
custom
map,
but
the
client
can
always
decide,
but
the
the
silver
one,
of
course,
is
relatively
simple.
C
Server
essentially
is
trying
to
really
compute
actually
the
deck
right.
You
really
want
to
have
the
compiling
order.
You
approach
always
you're,
going
to
give
an
order
to
make
sure
they
always
correct.
So
therefore,
that's,
basically
what
client
pull
push
really
looks
like
basically
follow
the
dependencies
and
push
updates,
all
the
sending
order
of
the
dependence
tag
and
so
on.
So
that's
overall.
There
are
a
lot
of
details
in
the
document
and
when
you're
going
to
want
to
clarify
next
slide.
Please.
C
C
So
those
information
you
should
reflect
the
design
offline
in
the
design
summary
and
which
will
just
go
over
for
throughout
the
day
and
that's
basically
the
design.
Of
course.
The
document
there's
like
a
small
typosphere
there
we're
trying
to
really
like
update
everything
as
clean
as
possible
within
this
week.
So
therefore,
that's
really
the
document
status,
but
a
slight
exercise
more
complete,
because
we
did
modify
some
a
few
things
later
in
the
last
couple
days.
C
C
A
E
C
Oh
I,
think
this
is
not
a
little
bit
slice,
no
yeah
I
think
somehow,
maybe
I'll
send
you
a
wrong
version:
okay,
okay
and
so
the
main
remaining
issue
here
is
the
phone
number
that's
actually
a
bit
hard
to
talk
about,
but
I
can?
Why
don't
you
show
me
the
last
slide.
So
therefore,
I
can
use
the
word
to
describe
a
little
bit.
C
Yeah
so,
overall
we're
pretty
happy
with.
Oh
no
in
the
previous
slides,
the
summary
yeah
overall
we're
pretty
happy
with
overall
design
and
the
only
thing
we
are
there's
some
discussions.
I
think
overall,
I
think
the
question
as
well
is
basically
discuss
about
potential.
Co-Location
of
all
three
entities
front
end
right
front
end
to
handle
the
open
right
and
the
directory
metadata
right.
So
that's
the
second
piece
and
the
real
edges
with
real
data.
C
So
right
now
the
current
document
and
current
design,
the
co-location
of
all
three
services,
all
three
resources
into
a
single
location.
We
want
a
3DS
car
to
be
this
one.
The
major
issue
about
this
one
is:
it
will
not
allow
fine
green
load
balancing
what
does
it
mean?
Imagine
a
property
and,
for
example,
some
kind
of
like,
for
example,
eventually
supposed
to
go
to
wireless
and
so
on,
and
you
won't
really
factually
end
up
on
a
property
of
giving
client,
for
example,
connection
status.
C
Okay,
so
therefore
for
different
client
IP
address
and
would
have
different
properties.
So
therefore
the
stream
would
be
different.
Okay.
So
therefore,
this
one
is
only
known
when
you
have
request
parameter,
which,
for
example,
is
a
client
IP
address
I
want
to
know
this
particular
any
point.
I
want
to
see
all
the
properties
I
want
to
server.
Tell
me
what
the
connection
status
connected
and
not
connected,
and
so
on.
C
For
example,
if
I
continue
to
push
about
this
one,
then
currently,
for
example,
we
are
not
going
to
know
about
this
information,
so
therefore
we
cannot
know
Finding,
green
load,
balancing
because
go
to
the
front
to
end
and
front
end
already
would
be
a
directory
and
updates
and
other
data
will
be
at
a
single
server
location.
So
we
cannot
do
find
the
green
load,
balancing
and
so
on.
So,
therefore,
the
only
remaining
issues
are
two
and
one
is
separate
front
end
from
directory
and
the
data
we
still
do.
C
The
directory
and
the
data
into
a
single
server
but
put
front
end
is
essentially
as
a
separate
server.
So
therefore,
now
we
return
the
transport
State
view
route.
It
can
be
absolute
UI,
pointing
you
to,
for
example,
at
the
location.
That's
a
very
typical
application.
The
layer,
seven
request
shouting
load,
balancing
service
design
so
for
Less
design
number
one.
So
therefore,
that's
potential
can
solve
the
issue.
That's
why
YouTube
were
discussing.
That's
the
only
one,
I
believe,
of
course,
the
second
one
is
the
fallen
and
which
I
think.
C
Why
should
the
design
kind
of
can
go
through
is
the
following?
Is
you
allow
front
end
to
redirect?
So
basically,
the
client
will
send
a
post,
okay
and
password
indicate,
for
example,
the
parameters
and
then
the
front
end.
It
will
say:
hey
redirect
what
means
okay
I
got
your
request,
but
I'm
not
going
to
give
you
the
the
state
I'm
going
to
tell
you
redirect
to
the
other
server
which
is
closer
to
the
kind
of
zone.
So,
therefore,
if
we're
okay,
according
to
operational,
we
can
add
a
sentences.
C
You
know
option
said
okay
for
this
one.
The
client
must
be
prepared
to
accept
redirect
to
allow
fine,
green
applicant
layer
request
routing.
So,
therefore,
that's
the
only
remain
issue.
We
are
not
for
the
written
up
in
the
document.
Otherwise
we're
happy
and
we're
going
to
say
the
latest
version.
You
can
see
a
little
bit
like
a
figure
to
show
what
it
really
design
looks
like,
but
otherwise
we're
pretty
happy
about
it.
C
So
that's
essentially
only
one
and
then
we
can
discuss
about
a
person's
data
versus
and
Pharaoh
estate,
but
overall
we're
pretty
stuck
with
an
inferior
state.
But
if
we
want
people
to
discussed,
I
will
be
happy.
We
can
add
the
discussion
into
the
operational
discussions
about
why
it's
beneficial,
but
we're
pretty
happy
about
it,
and
then
we
can
also,
for
example,
discuss
about
how
to
read
the
metadata
right
now.
Decision
is
using
slash
uq
return
directly
using
essential
all
the
Unix
semantics
right.
C
C
F
B
Thank
you
for
introduction.
Actually
you
speak
on
this
document.
Actually,
I
made
this
several
revision.
Actually
we
made
a
lot
of
you
know,
change.
Actually
so
I
I
think
yeah.
We
can.
You
know
we
have
some
time
to
take
a
question.
If
I
I
want
to
ask
a
question:
is
there
any
other
want
to?
You
know,
answer
questions.
B
B
This
possession
part
so
the
same
same
as
the
idea
you
want
to
have
client
to
you
know
get
access
to
some
contents.
If
these
contents
actually
is
very
interesting,
maybe
get
a
catched
and
it
will.
Nobody
really.
You
know,
want
to
get
these
kind
of
catch
content.
Actually,
this
this
session
will
be
closed.
C
C
Yeah
we
did
raise,
for
example,
discussions
on
the
data
model
incremental
right,
so
eventual
I,
guess
graphical
API
becomes
I
restful
right,
incremental,
restful
and
I
think
we
got
the
feedback
from
Adrian.
Of
course
it
will
be
more
happy
here
from
alapet
back,
but
actually
this
channel
was
really
motivated
question
about
what's
linked
and
what's
the
tag
so
now
we
think
now
actually
everything's
very,
very
well
clarified.
B
B
Body
that
you
you,
you
raise
the
question,
not
a
balance,
actually
I'm
a
little
bit
scared.
Actually,
you
know
there's
a
really
neat.
Really,
maybe
more
you
know
scalable.
Maybe
if
you
have
some
loader
balancer
solution.
So
what
what
do
you
think?
How
do
you
you
know
address?
Is
you
want
to
leave
this
out
of
scope
or
you
you
think
it
is
a
should
be
solved.
C
I
think
basically
the
following
and
so
I
think
for
the
our
current
use
case
for
the
cost
map
use
case
the
main
deployment
case.
The
currently
I
think
we're
pretty
happy.
That's
why
single
server
single
session,
rather
than
a
single
server
and
all
the
three
types
of
resources,
the
front
end
open
right
and
the
management
and
the
directory,
and
also
the
real
data,
and
it's
very
well
so
load.
The
balance
is
good
enough
If.
Eventually
we
realize
that
we
need
them
all.
C
And
basically,
if
you
want
the
multiples
of
server
to
help,
you
can
use
being
that
really
return.
Different
IP
addresses.
So
that's
everything
is
very
good.
We're
pretty
happy
about
that.
But
the
only
thing
is,
but
we
don't
have
good
use
cases.
We
don't
believe.
That's
really
important.
It's
a
use
case
where
you
want
to
do
application
layer
of
Direction.
So,
for
example
the
example
I
just
mentioned
right
and
would
be.
You
won't
really
monitor.
C
So
that's
why
I
talk
about
and
there's
some
complexity,
but
we
think
that's
also
acceptable
right.
As
long
as
a
client
will
accept
the
the
post
redirect,
then
that
also
can
still
send
the
client
to
write
a
server.
Of
course
you
can
even
use
a
fancier
ones,
but
that's
probably
too
too
messy
and
you
can
use,
for
example,
the
same
name
right.
So
therefore
the
offensive
ones
would
be.
We
some
operators
eventually
realize.
Okay,
I
really
need
large
skill.
C
I
want
to
really
using
a
push
update
to
read
the
deliver,
a
standard
to
some
like
a
clients
and
so
on,
and
it
might
be
at
different
locations,
different
access
points
and
different
focus
on
database
and
so
on,
and
you
can
use
for
example,
say:
name
right:
the
clan
was
sending
the
request
name
and
then
you
look
at
the
current
IP
address.
You
look
at
the
same
name
and
it's
like
like
how
can
I
request
your
routing?
C
You
can
direct
them
to
the
right
table
server
as
well,
so
essentially,
single
server
single
session
wouldn't
block
these
kind
of
optimizations
and
this
kind
of
flexibilities,
but
slightly
record.
They
need
to
really
go
essentially
go
leave
the
decision,
so
that
cannot
be
done
inside
the
auto
tips
itself.
It
has
to
be
used
a
different
mechanism.
D
D
C
People,
local
and
his
main
developer,
but
my
intention
is
yes:
it
will,
and
hopefully
it's
a
complete
a
future
Set.
It
actually
think
about
it.
Actually
is
not
a
very
hard
to
implement
you
think
about
it.
The
whole
Beauty
about
this
one
I
can
make
this
server
to
be
very
lightweight
and
make
the
Implement
a
bit
simple.
Traditional
I
could
also
serve
is
a
harder
to
implement,
because
why
it
also
sorry,
you
always
need
to
give
a
snapshot.
So,
therefore,
what
if
I
need
to
trade
up
Suddenly
I
got
a
lot
of
updates.
C
C
A
C
C
Yeah
so
I
think
we
will.
Of
course
we
saw
the
whole
team
Raul
and
the
kai
as
well
we're
going
to
implement
the
whole
thing.
Okay,
it's
another
hard
to
implement
I
I.
Do
it
typically
I
I,
typically
I
do
have
a
very
reasonable
sense
about
implementation.
This
is
easy
to
implement,
then
actually
The,
Standard,
Auto
server.
B
C
G
C
Yeah
so
version
7
is
really
anyone
who
won't
read
about
version
7.
All
the
latest
version
that
you're
in
the
working
group
report
not
evenly.
You
know,
ID
directory
by
the
way,
one
like
I
said
we're
going
to
take
one
more
pass
like
England
around
two
days.
We
definitely
want
to
post
everything
by
say
this
this
week.
So
for
people
can
you
can
issue
a
last
call
to
get
all
the
feedback,
because
this
already
went
through
like
80
reviews,
so
we'll
address
a
lot
of
issues
with
you.
B
B
B
G
F
Problem
so,
as
you
can
see
so
in
the
new
version
they
they've
had
a
new
character.
This
is
a
check
on
that,
so
she
made
a
lot
of
contributions
in
the
previous
working.
So
it
is
the
your
father
and
the
yeah
next
slide.
Please
and
yeah.
This
is
the
summarize
the
current
status.
Let's
see
it
is
the
latest
version.
F
Okay,
I'm
not
sure
if
this
is
the
latest
one
but
yeah,
let's
continue
so
the
latest
version
actually
is
not
the
working
zero
three.
It
is
already
out
of
the
new
versions,
actually,
which
is
the
kind
of
you're
working
with
the
zero
five
under
the
make,
some
updates
to
Across
the
comments
we
just
received
from
30
and
13
in
this
week
and.
F
F
F
F
F
F
F
F
Server
to
provide
the
other
workers,
no
sound,
and
the
second
part
is
to
configure
the
server
Discovery
and
in
this
case,
models
of
the
several
history
only
have
the
only
Define
the
model
for
the
reverse
bi
space
Authority
coverage,
which
is
defined
by
the
adhesive
ADC.
It's
a
core
domain
server
recovery,
so
we
do
have
some.
We
do
have
some
examples
in
the
appendix
tissue
actually
in
the
different
applications.
F
They
can
have
the
different
server
Discovery
mechanism,
so
we
can
extend
This
Server
recovery,
so
something
else
to
have
had
they
different
mechanisms
and
also
it's
just
a
right
to
configure
the
login
system
so
how
to
so
where
to
send
it
out
to
and
the
the
last
part
about
some
metadata
which
will
be
used
by
the
different
information
results
and
the
other
purpose.
Let's
say
the
cost
patterns
and
matter
other
metadators
of
you
in
the
artist
and
for
the
security
configuration
security
configuration.
F
F
And
they
start
part,
it
I
think
it's
most
important
for
project
data
model,
which
is
how
to
do
the
information
without
operating
and
management,
so
that
will
be
separate
to
three
parts
so
which
is
the
first
slide,
is
how
to
configure
the
data
cells
listeners
and,
of
course
it
doesn't
listen
apart.
So.
F
As
the
most
commented
parameters
is
about
the
update
policies,
because
so
have
two
policies
for
the
data
update,
so
they
a
data
listener
can
use
the
react
remote
to
update
the
data.
I'll
use
the
proactive
mode
so
for
the
record
mode
activate
so
that
it
uses
our
proof.
So,
let's
consider
the
status
of
the
listener
is
a
plan
for
the
data
software
server
and
the
data
thought
there
will
go
just
to
put
the
data
to
the
data
translation.
F
F
But
for
the
specific
implantation
we
still
need
to
find
some
specific
status
of
so
that
will
be
augmented
to
the
source
parameters
charge.
So
in
the
appendix
I
will
show
some
examples
in
the
concrete
implementation.
So
how
to
do
this?
How
to
extend
this
basically,
the
model
for
the
for
a
real
implementation.
F
B
F
And
the
second
part
of
this
to
configure
the
information
results
so
for
ATV
publishing
results.
We
have
the
the
common
parameters
for
average
every
Infamous
result.
You'll
have
the
to
come
in
parameters
which
is
the
accepted
Row
for
the
attack
control.
The
robust
attack
control,
which
broadcast
that
is
a
camera
result
and
a
little
depending
information
results
and
for
the
specific
type
of
the
information
result.
F
So
we
have
the
HD
Fund
in
the
details,
plastic
parameters.
We
can
have
the
arc,
the
network
methodology
all
kind
of
the
human
resource
test
we
have
defined
in
the
data
model,
but
it
only
includes
the
standard,
so
I
think
one
issue
here
is
that
we
need
to
consider
if
the
new
transport
also
is
built
up
by,
as
they
are
say
so,
whether
it
can
fit
to
this
data
model.
F
F
C
C
But
I
do
have
a
question
about
the
following
about
access
control:
it's
not
falling.
For
example,
let's
say
you
want
to:
let's
say
you
have
endpoint
Property
Service,
okay,
so
for
end
upon
service.
So
therefore
this
is
It's
a
single
end
upon
proper
service,
it's
a
single
service,
but
then
you're
going
to
have
a
different
entities
which
you
can
create,
for
example,
basically
user,
one
user,
two
user,
three
user
4.
and
each
user
is
not
like,
for
example,
the
user
can
access
this
resource
or
not
so
basically,
I.
C
F
C
C
C
Yeah
not
only
resource
ID,
but
also
somehow
regular.
The
key
is
not
a
resource
ID.
The
key
access
control
key
should
be
resource,
ID,
plus
the
input
which
we
use
as
well
in
our
transform,
because
all
the
states
also
be
you
know
the
graph
also
is
key,
but
on
really
it's
resource,
ID,
plus
the
the
the
parameters,
at
least
that
would
solve
this
case.
C
So
conceptual
I
think
it's
fun
conceptually.
What
Auto
does
or
over
on
is
low
overall
internet
that
is
falling
it's
a
resource.
It's
not
really
a
single
level
right,
essentially
restful,
API
really
is
resource.
Somehow
I
think
that's
one
thing
essentially,
I
guess
the
HP
model
is
a
bit
weird.
You're
gonna
follow
nonsense.
Resource
we
always
want
to
talk
about
resource
resource
and
resource
is
unique
identified
resource.
It's
a
piece
of
resource,
but
in
real
life,
oftentimes
resource
actually
really
is,
is
really
selected
by
a
Select
Market
right.
C
F
C
C
C
F
F
F
F
They
have
some
creative
and
authentication
approach.
Will
it
will
reuse?
Some
authentication
is
already
defined
in
the
HTTP
server
parameters
in
the
listening
tab
and
for
the
role.
So
if
you
go
they'll
Define
the
effect
at
least
number
of
clients,
that
will
be
exactly
the
given
row.
So
in
the
resource
level,
you
can
use
this
flow
to
Define,
zero
Business
Health
control.
F
F
F
F
F
F
B
E
Okay,
okay,
so
I
just
want
to
mention
that
I
noticed
that
there
are
only
very,
very
limited
configurations:
I
defined
for
the
auto
client,
conf
autoclike,
the
configuration
but
think
of
the
two-way
TLS
authentication
scenario,
where
not
only
that
the
thorough
authenticate
the
client,
but
also
the
client
need
to
authenticate
this
server
as
well.
So
maybe
we
need
to
consider
that
if
there
is
any
auto
server,
authentic
authentication,
related
configuration
need
to
be
defined
under
the
auto
client,
so
works
as
a
TRS.
E
E
B
B
B
F
E
B
E
B
C
C
B
Yeah
Johnson,
actually
so
for
for
panics.
Actually
you
you
need
to
add,
maybe
more
example.
Actually,
as
you
mentioned
in
in
a
you,
know,
last
slides.
Actually
the
model
need
to
be
extensible
actually
so
so
maybe
some
more
example
will
will
be
helpful
to
people
to
understand
how
this
model
can
be
used.
F
B
F
B
B
A
I
think
I
think
we
need
just
to
to
do.
Let
me
see
a
double
check
from
the
author
that
the
all
major
issues
are
currently
covered,
and
once
we
have
an
app
from
them,
we
can,
and
we
say,
run
the
working
class
College
in
parallel
send
the
request
for
the
young
losers.
Reviews
that
you
can
have
both
I
would
say
are
running
parallel
and
you
can
gain
some
time.
B
D
F
D
B
B
C
For
the
last
call
the
transport
do
we
can
we
like
send
email
to
arrange
a
meeting
from
Mark
Nottingham
or
you
prefer
that
we
don't
go
down
at
the
path,
because
it's
incredibly
good
in
terms
of
getting
all
the
HTTP
insights.
So
should
we
like
proceed
immediately
and
we
go
through
working
with
the
last
call
and
basically
we
submit
the
version
I
think
timelines
by
this
week
we
get
everything
clean
up
and
we
go
through
the
working
blast
car
from
our
automobile
group.
B
C
B
C
Server
pool
silver
Port
is
no
longer
in
your
system
and
we
are
going
to
realize
substantially
my
Slaughter
us
down.
We
would
rather,
there
are
a
couple
of
design
decisions.
For
example,
merging
the
push
into
a
single
document
essentially
is
have
single
documents
that
we
can
orchestrate
it
very
quickly.
Therefore,
we
won't
get
transport
down
instead
of
having
you
know,
base
protocol
and
push
so
and
there
we
want
essentially
one
goal
for
RC
speed
up
instead
of
doing
like
a
complete,
I
think.