►
From YouTube: .NET Design Reviews GitHub Triage
Description
00:00:00 - Needs Work: BoundedConcurrentQueue(T) https://github.com/dotnet/corefx/issues/24365#issuecomment-407484728
00:15:40 - Rejected: Allow easier access to binary representation of blittable types https://github.com/dotnet/corefx/issues/26313#issuecomment-407486861
00:21:48 - Needs Work: SocketsHttpHandler: Add MaxHttpVersion property https://github.com/dotnet/corefx/issues/30527#issuecomment-407499225
A
A
He's
proposing
a
brand
new
type
on
a
current
do
where
you
can
effectively
control
how
many
elements
the
thinking
ever
had
before
actress
starts
to
you
know
not
block
but
effectively.
He
turns
false
image
from
finding
you
and
then
somebody
else
comes
to
idq
and
then
saying
you
know
the
lot
of
discussion
and
let
me
just
walk
to
the
bottom
I
think
West
asked
the
question
that
can
be
makers
in
your
construct
on
the
existing
run
you
time
and
then
he
said
you
could.
It
is
about
what
the
way.
B
D
C
C
A
C
A
Then
until
they
drain
it
or
chore,
I
would
just
say
I
don't
care
because
I
mean-
the
consumer
has
to
up
into
this
behavior,
and
so
the
consumer
changes
the
way
the
object
is
being
constructed.
Of
course
it
can
change
the
behavior
that
you
can
ugly
right
and
that
if
the
library
doesn't
work
on
that
note
and
why
wouldn't
work
them
or
I
mean.
A
A
B
G
A
Actually,
snapshot
to
nine
ticks.
If
you
actually
get
a
nine,
you
move
the
old
adjust
I.
Think
at
the
time
you
asked
for
it
that
snapshot
I
forgot
what
this
unites
next,
where
I
think
the
only
one
that
is
interesting
is
what
I
produced
a
consumer
collection
whatever
of
T,
which
is
the
basic
as
the
abstraction
that
you
pass
around
and
I
think
this
one
over
here.
G
A
H
C
C
C
Like
I
think
either
take
is
acceptable,
but
we
have
to
pick
one
and
I
think
they
do,
but
either
of
them
are
a
surprise
to
a
library
that
has
never
seen
this
behavior.
If
you
view
before
it,
so
if
we're
gonna
modify,
comparing
feel
I
would
expect
it.
When
we
have
the
bound
depressed
the
instructor,
we
have
it.
What
do
you
want
to
do
when
it's
full?
A
G
A
Okay
methods,
like
type
II,
to
recovery,
to
building
where
the
order
card
ability
to
look
at
data
in
the
cube,
without
removing
it
and
in
the
current
implementation
that
requires
marking
the
segment
is
preserving
for
observation,
which
means
nothing
will
ever
be
removed
in
a
queue.
This
is
the
effect
of
continuing
to
log
in
queues
on
to
the
second
installment.
Some
pictures
don't
end
up
removing
data
at
that
point,
nothing
forever
can
be
in
here.
Even
if
everything
is
thank,
you.
A
G
G
C
C
Why
does
if
I
can
it
be
enumerated?
I
understood
his
implementation
detail
thing
said
that
the
way
that
concurrent
he
was
as
segments
at
the
moment
anybody
wants
to
read
a
segment.
It
says
I'm
never
allowed
to
erase
anything
from
it
again
because
I
don't
know
somebody's
still.
Reading
off
of
this
segment
and
the
whole
point
of
his
founded
thing
is:
he
won't
ever
create
a
second
segment,
so
he
is
not
supportive.
C
D
You
have
to
lock
or
though,
because,
if
you,
if
you
don't,
have
to
worry
about
resizing-
and
you
just
have
the
one,
the
one
you
know
spray
of
elements-
then
all
you
have
to
do
to
track.
The
current
element
is
to
update
the
index
and
you
can
track
that
any
enumerator
for
this
is
the
index.
I
was
on
and
if
it's
ever
changed
well.
A
Basically,
DQ
can
only
physically
remove
anything,
so
you
know
run
or
else
lots,
even
though
you
but
like
at
some
point,
somebody
would
have
to
say
or
get
screwed
somebody's
asking
for
data
like
to
array
a
copy,
but
in
that
time,
for
nobody
else
can
enter
a
TQ.
Otherwise,
we
run
into
this
issue
where
we
are
in
a
rough
spots.
I
know
if
we're
going
to
use
a
lock.
C
A
D
Isn't
it
part
of
the
whole?
Well
so
so,
there's
the
out
there's
the
external
discussion
on
like
what
does
ml
dotnet
need.
This
one
in
particular,
is
adding
it
for
the
hardware
intrinsic
support
and,
it's
basically
just
saying,
add
an
opaque
type,
with
basic
support
for
converting
to
and
from
signal.
A
H
A
All
the
things
with
having
all
just
to
give
you
the
context,
so
that's
how
it's
given
for
now
all
right
like
this,
what
kind
of
seeing
that
gets
you?
That
is
the
kind
of
thing
that
I
think
is
good
for
triage,
because
it
you
know
it's
one
message
and
believe:
I
can
explain
to
us
in
five
minutes
what.
I
This
is
about
I
wanna,
legit
I
thought
those
have
gotten
rejected
because
it
doesn't
work
on
it
doesn't
work
outside.
Of
course,
you
are
the
idea.
Is
it's
just
a
way
to
take
an
arbitrary
field
and
turn
it
into
a
span?
Abite
like
say
that
you
want
the
span
of
byte
representation
of
an
integer
without
copying
stuff
like
round
yeah
yeah.
L
D
L
I
So
we
already
have
a
date
here,
so
we
we
have,
you
have
to
do.
You
have
to
jump
through
a
few
hoops,
but
it
is
possible
today
and
the
hoops
that
you
would
have
to
jump
through
our
memory.
Marshall
dot
create,
read
only
memory,
Marshall,
don't
create
span
over
the
ref
itself,
and
the
memory
marshal
dog
has
bytes
to
turn
this
fan
of
T
into
a
span
of
item.
So,
okay,
two
calls:
that's
not
the
end
of
the
world.
Yeah.
I
K
A
C
A
Yeah,
it
kind
of
seems,
like
you
really
wanted
on
the
HTTP
client
right.
Whoever
constructs
the
messages
for
you,
because
that
one
has
the
right,
Wedel,
arity,
global
versus
instance,
one,
and
that
one
is
more
convenience
in
anything
else.
But
if
you
only
have
it
on
a
chip
in
there
should
be
a
request
message
then:
well,
you
can
effectively
no
longer
use
anything
and
it
should
be
claimed
and,
as
you
could
go
through
the
instruction
of
the
message
right.
C
I
very
strongly
think
that
no
one
should
ever
need
to
write
the
word
sign
family.
Like
most,
the
everybody
always
gets
confused.
They're
gonna
go
I'm
using
HTTP
client.
How
do
I
use
client
authentication
certificate
said
well
backup?
First
now
you
need
to
go
know
what
a
handler
it
doesn't
need
to
make
a
handler
you
to
set
the
permissions
on
the
hands
like
the
HTTP
client
should
be
the
place
where
people
make
the
modifications
for
their
client
things.
C
C
C
Anybody
can
someone's
configured
a
handler,
the
way
that
they
want
it
to
work,
but
maybe
you
need
to
do
something
different,
so
I
still
think
that
if
the
whole
point
is
oh,
but
there's
a
server
out
here
that
maybe
didn't
do
easy
to
be
to
the
way
to
be
expected
it
to
that's
a
concern
for
sockets
and
a
client.
Therefore
it
belongs
on
it
by
n
naught
on
him,
because
now
it's
a
problem
up
into
this
host
I.
G
F
A
A
G
H
F
I
E
A
A
A
What
I'm
not
entirely
sure,
so
they
went
back
and
forth
back
and
forth.
So,
like
you
take
this
comment
from
you
in
particular,
where
you
basically
say
it
doesn't
belong
on.
The
HD
client
itself
would
belong
on
the
client
Handler,
and
so
what
I'm
trying
to
understand
a
sec.
So
my
understanding
of
the
client
handler
is
that
it
reps
effectively
other
message:
handlers
well.
M
M
In
fact,
the
curl
handler
we
didn't
really
expose
that
publicly,
but
the
idea
was
that
HP
Klein
handler
itself
has
followed
from
framework
was
the
public
class
where
all
the
knobs
are
for
the
for
the
protocol
stack
and
as
we
did,
these
other
handlers
like
when
HP
Handler
and
sockets
HTTP
handler
we
sort
of
went
down
a
path
of
well.
Maybe
we
need
you
know
these
other
api's
on
these
sort
of
platform,
specific
and
alors,
more
nobs,
etc.
But
traditionally
the
knobs
are
always
on
the
handler
they're
not
actually
on
the
HTTP
compliant
class
itself.
A
That
makes
sense
so
and
so
I
think.
Like
last
time,
we
talked
about
this
and
I.
Think
I
did
not
do
the
best
job
writing
that
out.
But
basically
the
idea
was
I
think
to
say
it
doesn't
belong
on
a
particular
implementation
right,
so
like
Sokka,
HP
handler
seems
the
wrong
way
to
do
there,
because
it
seems
other
handlers
have
the
same
desire,
meaning
they
want
to
control
their
shitty
version
that
is
born
into
the
message
by
it
should
be
client
right,
so
they
yeah.
M
So
yes-
and
so
you
know,
the
final
intent
would
be
that
we
would
add
this
property
to
HP
client
handler.
We
did
not.
We
haven't.
We
have
another
issue
for
that.
We
didn't
propose
that
right
away,
because
there
are
several
other
properties
that
we
added
to
sockets
HTTP
handler.
While
we
were
developing
it
and
they
were
sort
of
a
way
for
developers
to
start
playing
around
with
the
new
Handler
and
we
we
weren't
sure
of
some
of
those
other
properties.
M
We
added
and
I
referenced
some
of
those
in
this
discussion
about
the
connection
least
time
out
and
about
the
pool
lifetime,
etc.
Some
really
low
level
knobs
and
we
weren't
sure
whether
or
not
those
made
sense
on
HP
client
handler,
especially
that
it
may
be
difficult
to
have
those
actually
work
on
other
implementations
of
the
class
on
maybe
on.
M
You
know
and
putting
them
on
HP
client
handlers
so
that
that's
where
they
work
for
the
long
haul
right
and
that
was
sort
of
the
thought
process
and
that's
what
we've
done
already
with
a
few
properties
on
socket,
HP,
Handler
and
because
HTTP
to
protocol
is
really
a
new
for
the
handler
and
we're
still
getting
they're
still
understanding
what
it
means
to
implement
it
in
that.
In
that
handler,
we
wanted
to
at
least
have
this
programmatic
API.
Just
on
that
handler
before
we
commit
to
putting
it
on
HD
client
handler.
So.
C
To
me,
this
is
solving
the
wrong
problem.
To
me,
this
is
like
the
max
shouldn't
exist.
Only
question
is
what
should
the
default
be,
and
so
either
the
default
needs
to
be
static.
Settable
on
the
on
the
HTTP
message,
which
seems
wrong
because
statics
mean
the
multi-threaded
applications
don't
work
or
that
the
client,
where
the
the
message
handler
has
a
what
is
the
default
version,
I
use
when
you
call
the
Constructors
on
or
when
you
call
the
methods
on
client
to
take
the
URI
instead
of
the
message
well,.
M
So
let
me
let
me
discuss
that
comment
and
the
history
of
how
this
max
version
property
was
proposed
to
be
on
the
handler
originally
vanilla
version
property
that
does
exist
today
on
the
HTTP
request
message
as
an
instance
property
and
the
default
for
a
long
time
had
been
1.1
and
when
we
first
added
when
we
first
thought
about
this
for
on
the
WinRT
api's
we
added
we,
you
know
we
needed
a
mechanism
to
one
move
to
default
forward
for
convenience,
because
many
of
the
HP
client
api's
don't
actually
take
an
HTTP
request.
Message:
object.
M
They
simply
take
a
URI,
so
API
is
like
get
async
post
async.
They
don't
take
a
request
message.
A
developer
doesn't
build
an
HTTP
request
message.
So
then
we
have
the
issue
of
well.
Many
developers
were
saying:
why
does
it
your
stack
use,
HTTP
2
since
you're,
adding
it,
and
so
we
decided
many
months
ago
to
push
the
default
of
HTTP
request
message:
dot
version
2.0.
We
did
this
because
we
had
HP
to
protocol
support
on
Windows
with
when
HP
handler.
We
have
it
on
Linux
with
curl
handler.
M
So
we
made
the
decision
to
push
that
forward
already,
so
that
the
default,
except
not
framework
the
default,
would
be
2.0.
So
when
developers
used
the
convenience,
the
api's
on
httpclient
like
get
a
sink
coupon
post,
a
saying
they
would,
they
would
start
talking
http/2
or
at
least
proposing
to
a
server
that
they
supported
HTTP.
M
The
reason
why
we
thought
about
adding
this
property
at
all
to
the
handlers
was
because
of
our
experience
with
WinRT
with
the
windows
web
HTTP
api,
where
we
discovered
that
some
servers
might
have
a
problem
with
getting
the
HTTP
2
protocol
proposed
via
the
ALP
n
negotiation
mechanism,
and
we
needed
a
mechanism
to
potentially
cap
that
you
know
that
version.
So
while
the
default
might
be
2.0
say
for
the
windows
web
HPA
API
is
on
that
handler
property.
M
We
gave
developers
the
option
to
dial
it
down
so
that
it
would
sort
of
have
a
cat,
and
that
same
philosophy
was
what
we
went
with
on
on
proposing
this
property
for
sockets
HD
handler
party
moves
the
default
2.0,
which
is
the
right
thing
for
most
cases,
but
in
the
rare
cases
where
developers
have
a
problem
communicating
with
legacy
servers,
we
wanted
this
property
to
be
able
to
dial
it
back
and
cap
it
so
that
it
would
be
captive
1.1.
So.
A
M
Ok,
so
in
that
case
they
can't
if
they
don't
deal
with
handlers,
meaning
they
just
say
new
HTTP
client.
So
it's
going
to
use
the
default
of
building
Batman
HT
client
handler
underneath
and
it
will
use
the
default
set
of
values
and
you
know,
and
if
they
don't
even
set,
they
don't
even
create
an
HP
request
message.
Then
yeah
they're
going
to
get
2.0.
Assuming
that
you
know
the
max
version
on
the
handler
is
2.0.
M
A
A
Thing
that
concerns
me
a
bit
so
if
we,
if
you
believe
it
never
belongs
into
the
abstractions,
it's
purely
a
sockets
thing
and
then
then
clewd,
that's
where
it
belongs.
If
you
believe
it's
just
a
stopgap,
but
eventually
we
will
fix
the
larger
problem.
Then
I'm
somewhat
more
opposed,
because
we
just
add
that
that
we
then
have
to
reconcile
to
me.
K
M
M
H
M
M
You
know
if
you
need
to
adjust
knobs
for
HP
client,
you
create
PHP
client
handler,
and
then
you
adjust
the
knobs
on
it
and
that
that
sort
of
is
the
it's
been
the
standard,
API
pattern,
so
yes,
having
this
property
to
socket
HP
handler
would
be
a
stopgap
much
like
the
other
two
properties
that
we've
already
added
to
socket
HTTP
handler
about
the
police
timeouts
on
on
connections.
You
know
the
final
thing
would
be
yet
you
know.
Perhaps
we
would
add
it
to
HD
client
handler.
M
You
know,
I,
don't
see
a
downside
of
adding
this
to
socket
HTTP
handler,
because
we've
already
made
already
passed
the
precedent
of
adding
a
couple
of
knobs
to
socket
HTTP
handler,
it's
sort
of
giving
us
just
a
quick
way
to
get
programmatic
mileage
on
building
the
HTTP
to
support
in
the
handler-
and
you
know,
having
sweary
have
this
API,
where
we
expose
the
handler
the
sockets
HTTP
handler.
So
we
wanted
to
add
the
max
version
so
close
without
yet
committing
to
the
HP
client
handler.
Yet
so.
A
C
Then
to
me:
if
we
go
back
and
we
look
at
people
who
are
say
they
say,
new
HTTP
client,
they
don't
know
what
a
handler
is
the
default
constructor,
because
that's
the
easiest
thing
to
use
and
they're
they're
using
the
URI
based
calls,
because
that's
what
they
do
like
to
me.
This
should
just
be
a
instance
property
on
httpclient
of
what
is
the
default.
C
Http
version
I
will
speak
if
you
call
the
convenience
method
and
if
they
hit
a
server
that
doesn't
support
it,
they
change
it
to
one
one
and
that
solves
a
WinRT
that
stands
it
for
sockets
that
solves
it
for
any
future
handler
that
solves
the
user
scenario
without
solving
without
caring.
What
the
technical
reason
we're
adding
it
right
now
is
so.
M
So
the
only
comment
I'll
make
on
that
is
that
historically,
we've
never
put
any
of
those
kind
of
knobs
on
HTTP
client
itself.
In
fact,
HTTP
client
is
a
derived
class
of
a
class
called
HTTP
message,
invoker
and
HTTP
message.
Invoker
is
sort
of
that.
It's
like
the
base
class,
and
that
has
one
ability
and
it's
called
the
send
async
API,
which
really
just
calls
the
handler
and
so
HTP
client
is
this
class
that
people
use
and
it
gives
them
a
little
value.
M
Add
above
HTTP,
message,
invoker
and
the
value
add,
is
a
set
of
convenience
methods
like
then
like
get
async,
post,
async
and
also
a
couple
of
mechanisms
of
buffering
response
content,
whereas
the
handler
itself
or
the
HTTP
message,
invoker
class,
never
actually
drains
the
response
body.
So
you
know,
HTTP
client
has
been
fee
thing,
people
use,
but
we've
never
thought
about
having
these
knobs
these
properties
at
all.
On
HTTP
client,
the
only
property
we
do
have
an
HP
client.
This
is
sort
of
the
timeout,
which
is
this
overall
timeout
thing.
M
C
Scenarios
HTTP
client
is
the
one
creating
these
messages.
It
is
specifically
the
convenience
overload
as
an
HTTP
client
that
creates
it.
They
should
be
request
message
and
I.
Just
say
that
HTTP
client
should
have
a
what
is
my
default
version
and
it
assigns
it
on
the
HTTP
request
messages
that
it
creates.
So.
M
So
yeah,
so
the
only
other
I'll
say
to
sort
of
push
back
a
little
bit
on
that
is
when
HP
client
was
designed
and
the
whole
handler
model
was
designed.
Now,
HP
client
tried
to
make
the
HTTP
protocol
itself
sort
of
a
a
first-class
thing
for
responses
in
headers,
but
things
that
were
like
transport
semantics,
like
SSL
or
connection
things.
It
wasn't
really
appropriate
for
the
object
model.
M
M
Message:
windows,
web
HTTP
namespace,
the
HP
request
message,
which
looks
very
much
like
system
net
because
we
designed
that
at
the
same
time
doesn't
even
have
a
version
property
in
that,
and
that
was
done
for
some
other
random
reasons
about
how
the
protocol
stack
that
it
used,
which
was
when
I
met
sort
of
works
so
and
and
so
HTTP
to
is
it
you,
don't
even
specify
that
that
version
on
the
HTTP
request
line?
So
the
actual
protocol
is
the
same.
It
still
is
HTTP
1.1.
M
So
it's
kind
of
a
semantics
thing
about
object,
model
stuff,
so
I'm
just
I'm,
just
very
pushing
back
on
adding
an
HTTP
client,
because
it
just
puts
us
into
this
new
space
of
adding
having
these
knobs
that
are
more
discreet,
more
connection,
oriented
semantics
and
takes
us
away
from
sort
of
the
more
abstract
model
of
what
HTTP
protocol
is.
So
that's
just
sort
of
why
I'm
pushing
back
on
adding
@hv
client
right
now,
I
mean.
A
I'm
fine
with
that
I
think,
like
the
I
mean
I,
can
live
with
the
fact
that
it's
not
so
Cassandra
because
I
know
to
reconcile
it
later.
With
the
you
know,
that's
the
Chandler
I
would
just
say
that.
Maybe
we
should
wait
for
some
more
customer
feedback.
I
mean
I,
don't
know
how
long
it
will
take
for
the
ecosystem
to
catch
up
of
http/2.
A
Maybe
that's
a
problem
that
just
disappears
relatively
quickly,
but
that
becomes
similar
to
ipv4
versus
ipv6,
where
it
basically
will
take
another
decade
until
everybody
talks
856,
then
maybe
we
find
ourselves
that
many
of
our
customers
end
up
having
to
cut
the
HTTP
version,
in
which
case
probably
should
expose
it
on
the
handler
just
to
make
it
a
lot
more
convenient,
because
as
soon
as
you
say,
you
need
to
give
up
the
hands.
Are
you
you
kindly
derail
the
primary
value?
I
Who
love?
Let
me
devil's
advocate
up
that
argument.
Real
fast,
well,
I
give
as
more
and
more
people
need
to
like
a
cloud
hosting
model.
You
know
imagine
every
AWS,
whatever,
where
you
have
some
type
of
shared
hosting
infrastructure.
You
can
imagine
that
the
hosts
are
enabling
HTTP
to
on
their
customers.
Behalf
at
that
point
right,
so
that's
pretty
near
in
there.
So
you
could
imagine
that
I
I
as
a
customer
just
have
an
application
running
in
like
after
websites,
for
instance,
right
and
maybe
they
just
enable
HTTP
without
me,
taking
any
action
like
now.
I
H
I
The
reason
that
I
mentioned
this
is
it
talks
to
your
argument
about
how
long
is
it
going
to
take
for
HTTP
to
catch
on
like
I?
Think
it's
not
really
going
to
be
a
gradual
thing,
I
think
what
we'll
actually
see
is
like
some
large
vertical
climbs,
where
we
see
entire
classes
of
applications
go
all
at
once,
I
mean
your
argument
is
almost
like:
it's
extra.
I
M
I
just
want
to
add
one
follow-on
comment
to
that.
Like
I
said,
the
90
percent
case
is
that
people
shouldn't
have
to
cap
the
version
and
the
default
having
if
the
fault
was
200,
it
should
work
in
90%
of
the
cases,
and
you
know
the
2o
sort
of
gets
sent
on
the
knot
and,
first
of
all,
it's
only
for
SSL
connections,
because
that's
really
all
we
do
for
HTTP
to
communication.
Anyway,
we
only
support
via
TLS,
and
so
it's
something
that
gets
sent
on
this
TLS
al
p.m.
M
and
and
a
lot
of
my
most
servers
will
simply
either
ignore
that
al
pan
negotiation
or
respond
back,
saying,
hey.
You
know
I'm
only
doing
one
point
one.
So
in
the
90%
case,
having
the
the
version
default
to
200,
as
what
is
proposed
is
fine,
because
a
lot
of
servers
that
don't
support
HP
we're
just
gonna
talk
11.1
anyway,
we
only
wanted
this
property
on
there
to
handle
customers
that
then
come
back
and
say
I'm
broken.
M
C
I
What
the
message
says
and
we
should
fix
it
at
the
problem,
which
is
who
created
the
message
itself?
I
am
David.
You
mentioned
earlier
that
historically,
we
haven't
really
put
properties
like
this
on
HTTP
client
itself.
Is
there
anything
that
we
should
have
as
a
consideration
if
we
were
to
suggest
that
that's
the
place
where
it
belongs?
I
know
that
you
and
men
you
had
mentioned
earlier
about.
M
No
I
mean
it's
keeping
the
intent
of
the
design,
the
original
design
of
what
what
the
class
was
meant
for
I
mean,
for
example,
if
you
only
added
two
HTTP
client
than
if
someone
uses
HTTP
message,
invoker,
which
is
the
base
class
of
HTTP
client,
then
they're
not
even
going
to
have
this
property
right,
but
but
they
both
thought.
It
should
be
messaged
themself.
C
M
C
No
I'm
not
suggesting
a
maximum
I'm
suggesting
the
default
in
them
all
the
convenience
methods
that
say
new
HP
message:
their
HP
request
message
whatever
it
is
that
they
would
then
assign
the
version.
That's
it
that's
what
I
think
this
API
should
be?
No
maximum,
no
fallback,
no
tree
right.
Things
know
like
just
change
the
factory.
A
A
C
M
M
M
C
C
M
A
M
Yeah
in
terms
of
the
name
yeah
yeah
yeah,
and
so
if
we
want
to
discuss
what
the
name
of
the
property
should
be
on
HTTP
client,
but
the
only
problem
I
mean
we'd
want
the
name
of
the
property
to
tell
people
that
it's
only
affecting
the
API
is
where
you
don't
explicitly
pass
in.
An
HTTP
request
meant
so
maybe
using
the
word
default.
There's
a
better
part
of
the
name.
I.
I
A
I
just
wrote
it
up
so
like
I,
just
copy
and
pasted
like
everything
that
we
just
talked
about,
and
it
may
be
typos
in
because
I'm
out
of
time,
but
they
said
the
very
end.
It
has
Barton's
our
Jeremy's
proposal.
That
basis
says
exposed
H
decline
in
four
HD
version,
which
would
control
will
to
be
fought,
waited
for
request,
message,
optically
way
that
are
constructed,
and
that
would
basically
mean
that
you
don't
get
a
a
global
cap.
It
would
just
be
you
control
what
the
defaults
are
and
the
user
wants
to
do
a
cap.