►
From YouTube: GitHub Quick Reviews
Description
Powered by Restream https://restream.io/
A
Hello,
everyone
welcome
to
oh.
This
is
a
regularly
scheduled
api
review
session.
How
unusual
we
have
fewer
red
things
and
we
may
actually
get
to
non-red
things
today.
That'll
be
exciting,
but
first
up
dealing
with
the
red,
avx
vnni
intrinsics
issue.
Four,
three:
seven,
eight
zero
is
that
you
tanner.
B
They
would
like
for
us
to
expose
those
instructions
that
way
users,
particularly
in
the
machine
learning
area,
can
take
advantage
of
them
proposed
classes,
avx
bn
and
I
following
the
underlying
isa
name,
inheriting
from
avx-2,
which
is
the
required
base
isa
and
then,
following
the
general
naming
pattern
we
had
already
landed
on
for
arm
64.,
so
multiply,
widening
and
add,
for
example,.
C
B
A
B
I
don't
actually
have
this
stock
down,
we
could
probably
just
leave
it
as
we
should
double
check.
Type
is
correct
and
follow
whatever
the
instruction
set
says.
A
And
and
then
just
redundantly
asking
questions,
there's
not
a
64-bit
add-in
version
of
these
instructions.
B
Yes,
those
all
follow
the
intel
originally
proposed
other
names
and
then
igor,
and
I
asked
them
to
parody
the
names
we
decided
on
these
for
arm.
A
B
Transfinzi,
whenever
we
decide
avx,
512
or
sv
or
rmsve
is
worth
implementing.
B
B
F
Yep,
so
this
is
follow-up
to
the
managed,
apply,
update
api
that
we
added.
So
the
general
setup
for
for
hot
reload
is
that
a
tool
like
netwatch
is
running
at
the
same
time
as
your
app
and
whenever
you
make
some
changes
to
your
code,
rosalind
is
invoked
to
generate
an
edit
and
continue
delta.
That,
then,
is
transferred
to
the
to
the
running
app
and
it
applies
it
and
everybody's
happy.
F
So
the
the
question
then,
is
like
what
kind
of
update
should
rosalind
generate
like
what?
What
are
the
supported
edits
and
that
sort
of
depends
on
the
runtime.
It
depends
on
if
you're
running.net
framework
or,
if
you're
running
six
with
like
core
clr
with
mono,
so
core
clr
and
mono
might
have
different
capabilities.
F
F
E
F
It's
not
necessarily
so
mono,
depending
on
the
execution
engine
that
it's
using,
can
either
support
edits
or
not.
So
if
it's
using
the
interpreter,
then
some
edits
are
supported.
If
it's
using
something
else,
then
it's
not.
G
F
No
because
we
want,
we
don't
know
exactly
up
front
what
what
we
want,
the
granularity
that
we
want,
so
that
kind
of
depends
on
what
on
what
the
rosalind
folks
decide.
They'd
like
to
know
about.
A
E
E
Now
we
also
added
two
properties:
is
dynamic
code
compiled
and
does
that
make
all
this
supported
because
we
don't
have
the
one
true
way
across
all
our
runtimes
right.
So
all
the
other
things
are
kind
of
designed
to
be
accumulative.
Right.Net
five
has
six
runtime
features
and
dotnet
seven
has
nine
and
it's
an
ever-growing
set
right.
So
for
the
things
that
are,
you
know
different
across
all
run
times,
you
basically
went
with
the
boolean
returning
property,
where
you
at
runtime
can
ask.
E
Well,
if
I
generate
code,
is
it
going
to
be
fast
right
or
first
of
all,
can
I
generate
code
at
one
time
and
if
I
can,
is
it
going
to
be
compiled
or
interpreted
basically
right,
and
so
that's
why
we
have
these
two
blue
properties
there
as
well.
So
I
think
for
better
or
worse.
I
think
we
have
both
patterns
on
this
type
already,
and
I
think
that
what
you're
describing
here
is
like
to
me.
It's
either
one
of
two
things:
either
we
say:
there's
a
there's,
a
static
description
that
we
think
we
can.
E
E
I
think
what
I
wouldn't
do
is
kind
of
the
way
you
propose
it
here
because
it
kind
of
seems
like
you
have
this
back
door
now,
but
you
say:
well,
we
have
the
stream
returning
thing
we
will
figure
out
will
be
returned
there
and
it
shouldn't
some.
You
know
semi-structured
data
payload
here
that
somebody
else
can
interpret
right
and
that's
kind
of
the
you
know
it's
almost
like
a
you
know
an
object,
returning
an
api
where
you're
saying
like
well,
we
still
figure
out
what
object
we're
returning
here.
E
Like
you
know,
we
make
up
our
mind
as
we
go.
That
seems
a
bit.
You
know
like
a.
I
don't
know
like
a
yeah.
I
don't
know
like
a
an
open-ended
backdoor
almost,
and
so
I'm
wondering
like,
if
you
already
know
kind
of
here,
the
three
or
four
things
that
may
or
may
not
be
available.
E
F
Okay,
so
I
think
there
are
two.
F
Sort
of
comments,
so
one
is
having
having
individual
properties
for
individual
edits.
I'm
not
sure
that
we
necessarily
want
that
just
because
the
scenario
is
that
these
are
two
separate
processes,
so
we
have
to
serialize
something
anyway,
so
we
have
to.
We
have
to
design.
F
You
know,
essentially
the
string
representation
of
this
thing
anyway.
The
other
is
that
for
future.net
runtimes
we
could
imagine
adding
additional
capabilities.
As
you
know,
core
clr
supports
more
kinds
of
edits
than
it
does
today,
which
means
we'd
have
to
you,
know,
sort
of
come
back
and
add
additional
properties
or,
if
there's
a
new
new
that
defines
these
things,
you
know,
add
additional
enum
values
and
I'm
wondering
if
that's.
F
You
know
a
viable
strategy
or
since
we.
E
E
You
know
in
a
flex-based
in
I'm
assuming
32-bits
are
enough
for
you
right
or
you
know,
literally
32
different
properties
would
probably
be
a
bit
overkill,
but
so
I
mean
that
would
probably
what
I
would
do,
I
would
say
like
yeah
in
the
beginning,
we
support
six
things,
you
put
it
in
enum
and
then
crosshilar
has
five
on
one
and
six
on
or
whatever
the
case
might
be
right
and
then
that's
the
thing
you
can
create
from
all
that.
That's
probably
what
I
would
do
and
then,
as
we
as
we
discover
more
capabilities
yeah.
D
E
F
It
includes
some
hot
reload
manager
which,
which
is
the
thing
that's
accepting
the
edits
from
roslyn
and
roslyn
is
running
in
a
separate
process
and
the
first.
The
first
thing
when
both
of
these
things
start
up
is
roslyn,
would
query
the
running
app
and
ask
what
kind
of
edits
are
you
supporting?
And
so
that
has
to
go
over
a
communication
channel
and
that's
where
the
serialization
is
occurring.
E
E
That's
the
truth,
I
mean,
and
it's
not
that
I'm
against
strings
right.
It's
just
that
it
just
instead
of
designing
an
api.
No,
no!
No!
You
design
a
language
it
just
kind
of
pushes
the
can
down
the
road
a
little
bit.
So
that's
why
I'm
kind
of
hesitant
to
say:
let's
just
approve
this
api
because
it
seems
like
it's
not
clear
what
the
string
return
value
is
right.
So,
if
I
try
to
understand,
what's
I
mean
if
I'm
not,
I
mean
yeah.
E
Well,
let's
say
this
api
is
for
roslyn
right,
but
we
still
try
to
have
apis
that
we
can
describe
to
people
right
and
if
you
say,
yeah
there's
this,
you
know
subsection
in
the
ekmar
335
specification
that
says:
here's
the
string.
The
one
time
needs
to
return
order
for
somebody
else
to
do
edits
and
it's
a
400
page
talk
that
might
be
works
right
so
like
if
you
can
just
say,
here's
a
32-bit,
video.
E
Here's,
what
these
values
mean
because
chances
are,
somebody
else
will
carry
those
things,
but
probably
the
only
interested
in
some
subset
right.
You
could
imagine
an
aot
framework
or
something
else
that
wants
to
participate
in
the
rebuild
or
something
that
needs
to
know
whether
certain
things
are
supported
or
not
right.
So,
even
if
we
design
this
api
for
vlogs-
and
we
should
probably
still
make
sure
that
you
know
it's
somewhat
reasonable
in
terms
of
what
you
know
can
we
can
you
know,
can
we
explain
the
api
in
like
two
paragraphs
or
something.
E
F
Yes,
initially
we're
going
to
have
to
describe
the
things
that
mono
can't
do
and
that
might
be
a
longer
list.
E
E
Anyway,
but
yeah,
I
guess
we
have
to
think
about
what
it
means.
If
you
know
the
generating
run
time
and
the
the
running
runtime
have
different
versions
right,
because
you
know
the
tooling
version
will
go
in
the
different
cadence
than
the
then
the
user
code
right
and
it
could
be
higher
or
lower.
Depending
on
how
it
goes.
So,
I
guess
yeah.
F
That
matches
what
what
roslyn
has
internally.
Essentially,
I
can
probably
dig
up
the
pr
where
they
implemented
it,
but
yeah
we
just
wanted
to
propose
coming
in
with
a
string
just
because
then
we
don't
have
to
talk
about.
You
know,
there's
this
thing
and
then
we
have
to
serialize
it,
but
but
yeah.
That's.
E
I
mean
you
kind
of
have
to
talk
about
this,
just
that
you
know
I'm
going
to
talk
about
it
in
terms
of
apis
and
you're
talking
in
terms
of
documentation
right.
So
it's
just
and
our
next
question
is
then:
what's
the
string
format
right?
So
it's
just
I
don't
know
it
just
seems
like
we're
just
avoiding
the
conversation.
That's
actually
interesting.
A
I
mean
it
just
changes
which
group
of
people
you
have
to
have
the
conversation
with,
and
once
we
get
the
infrastructure
in
place.
I
don't
think
this
group
will
actually
care
what
names
you
use
other
than.
If
it's
you
know,
a
complex
mixture
of
snake
and
pascal
case,
then
we
may
get
a
little
touchy,
but.
E
E
E
I
mean
it's
a
bit
complicated
now,
because
the
question
is
should
is
support.
It
also
work
for
that.
So
you
I
mean
we
could
have
a
contract
that
says
when
you,
when
you
take
this
enum
mask
and
your
prostitute
is
supported.
E
They
also
tell
you
whether
it's
supported
or
not,
but,
like
I
think
at
that
point
it
just
becomes.
You
already
have
a
dynamic
api.
It
gives
you
back
a
bit
mask
and
well
you
just
you
know
if
you
compile
against
version
five,
you
may
not
have
the
inner
members,
but
you
know
what
the
majors
are
when
you
look
at
version
six
or
seven
at
the
one
time,
so
I
think
that's
sufficient
as
a
light
up
story.
A
A
A
Like
in
here,
it
would
just
end
up
with
case
name
of
assembly,
update
features,
dot,
run
time,
edits,
return,
enum
dot
is
bit
set
or
whatever
it's
called
has
flag
of
the
existing
thing.
So
it
would
just
be
case
each
of
those
other
names
and
yeah
or
we
could
decide.
We
don't
care
for
these
supported
on
those
things,
but
we
probably
would
but.
A
E
What
does
ya
mean
by
the
last
comment?
Is
the
idea
that,
based
on
the
capabilities
you
made
to
more
aggressive
trimming,.
F
I
think
that
was
about
the
special
case
of
the
empty
string,
meaning
nothing
is
supported,
and
then
you
can
aggressively
trim
based
on
that.
E
F
Right,
it's
a
question
of
a
framework
like
maui,
for
example,
where
they
might
want
to
have
support
code
so
that
they
can
refresh.
F
You
know
when
when
an
edit
comes
in,
they
want
to
refresh
the
ui,
but
if
they
know
statically
that
everything
will
never
get
edits,
then
all
of
that
code
can
be
dropped
out.
I
think
there's
going
to
be
a
separate
proposal
for
for,
for
that.
E
Yeah,
that's
I
mean
that's
interesting
question,
though
right,
because
those
are
not
runtime
capabilities.
At
that
point
it
becomes
more
like
what?
What
is
your
publishing
profile
right
like?
What
do
you
want
the
resulting
app
to
be
still
due
at
one
time
right?
It's
kind
of
like
retain
debug
information
or
not
right.
It's
a
the
runtime
has
support
for
it,
but
you
may
decide
that
you
want
to
link
all
of
the
stuff
out
because
you
don't
want
to
pay
for
it
right.
You
know.
E
I
mean
it's
an
interesting
question,
though,
because
I
think
once
you
have
such
an
app
plus
the
app
at
runtime,
you
know
what
capabilities
do
you
have?
It
should
probably
reflect
what
what
is
actually
available
at
one
time
right.
So
if
you,
if
you
linked
all
that
stuff
out,
then
ideally
the
return
video
at
runtime
is
sorry.
I
don't
support
any
edits
right,
especially.
D
E
A
A
I
So
there
is
existing
methods
in
libraries
for
platform
and
always
version
check,
which
is
recognized
by
the
flow
of
analysis
of
platform,
compatibility,
analyzer
and
used
for
regulating
the
context.
If
the
reference
platform
specific
api
is
safe
to
call
or
if
the
analyzer
needs
to
barn
for
it
and
but
the
analyzer
for
now
not
support
the
cached
values
for
platform
check
like
in
the
field
or
property
or
or
helper
methods.
So
we
want
to
add
such
support
for
that.
G
So
I'm
guessing,
you
would
use
this
to
annotate
like
foo
dot
is
windows,
and
then
the
analyzer
would
just
realize
that
if
you've
checked
that,
then
it
doesn't
need
to
give
you
warnings.
I
Yeah,
if
check
that
what
platform
is
squirting
and
then,
if
the
calling
method
is
safe
to
call,
then
not
one
for
now
that
we
cannot
use
any
custom
guards
and
except
the
existing
libraries
methods,
like
os
platform,
check
os
platform
operating
system.
That
is
always
button
kind
of
methods.
A
I
Like
exactly
for
for
this
example,
for
example,
in
this
case,
the
guard
is
straight
start
supported,
will
be
work,
just
like
it's
you,
and
there
is
a
is
operating
system.
That
is
always
is
browser,
but
with
the
not
in
front
so
in
the
else
case
means
it
will
be
browser.
Firstly,.
A
G
I
I
You
support
the
version
to
open
because
the
the
existing
attributes
for
supported
and
unsupported
attributes
does
like
different
things
I
mean
like,
for
example,
supported
will
only
say.
The
api
is
only
supported
on
this
api,
but
not
support
for
all
other
but
unsupported
os
platform
attributable
sailing.
It's
only
support
for
the
and
support
on
this
platform,
but
supported
for
all
order.
It's
like
not
exactly
same
thing,
not
exactly
opposite,
I
mean
so
that's
why
I
need
different
quad
attributes
for
those
I
cannot
use.
E
E
So
now,
with
this
attribute,
you
can
say
well,
this
method
provides
a
guard
check
and
so
that
when
we
see
a
call
to
it,
we
know
that
if
this
thing
returns
true,
then
it
was
windows,
10
or
higher
right,
and
so
that
in
that
sense,
it's
not
the
same
as
the
supported
or
as
platform
attribute,
where
the
supported
start
from
attribute
says
the
caller
is
responsible
for
checking,
because
these
news
attributes
are
saying
this
method
performs
this
check
right,
and
you
can
reason
about
what
this
thing
will
tell
you.
A
Yeah
I
I'll
take
I'll
give
frederick
some
credit
from
the
youtube
chat,
even
though
I
was
already
thinking
the
same
thing
I
feel
like
what
we
want
is
to
be
to
let
the
caller
or
let
the
person
who's
painting.
It
indicate
what
the
boolean
means
instead
of
pre-associate
the
meaning
so
basically
supports
os
platform
win
so
for
http
3
enabled
it
would
be
supports
os
platform
when
true
comma
linux.
A
So
if
we
return
true,
then
linux
is
supported
and
that
lets
you.
If,
for
some
reason,
you
end
up
opposite
of
the
current
meanings,
you
don't
have
to
go
replace
all
of
your
semantics,
like
I
agree
with
it
being
boolean,
but
since
it's
an
attribute,
the
true
and
false
have
to
be
declared
inline
and
therefore
everything's,
like
all
we
need
to
do,
is
open
up
that
one
tiny
little
valve
and
we
gained
two
free
attributes
out
of
this.
D
E
E
E
Well,
yeah,
we
would
have
os
platform
guard
for
supports
yeah.
I
guess
support
to
os
platform
when
or
whatever
right
and
then
the
first
argument
is
the
bull
that
says
true
or
false
and
then
the
second
one
is
the
os
platform
string
right,
yeah,
so
yeah.
A
Like
that,
but
I
don't
know.
A
C
A
A
If
it
returns
true,
then
you
know
you're
at
least
windows
10.,
but
if
it
returns
false,
that
doesn't
necessarily
mean
anything.
But
then
that
would
let
you,
if
you,
if
the
existing
code
you'd
already
written,
had,
is
below
windows
10,
then
you
would
just
say:
oh
if
I
return
false.
That
means
I'm
windows
10
or
better.
E
E
I
A
Right,
I'm
just
saying
right
now:
you've
you've
made
the
decision
that
for
the
yes,
I
support
this,
that's
when
it
returns
true
and
right
now,
if
this
returns
false,
I
assume
you're
not
changing
your
truth
table
in
any
way
like
you're,
not
you're,
not
learning,
I'm,
not
linux
you're,
just
not
learning!
A
I
am
linux
versus
the
unsupported
attribute
where
you
showed
here,
it's
assuming
that
if
this
returns
false,
then
I've
learned
I'm
not
this
platform,
and
that's
I
just
wonder
if
we
should
put
the
boolean
in
there
so
that
the
caller
can
control
which
direction
it's
going.
G
I
And
the
existing
always
platform
guard
mets
also
like
work
this
way,
so
it's
just
should
be
like
more
easier
to
apply
it
into
the
analyzer.
A
A
The
I
don't
know
that
we
have
any
that
tells
you
that
you're
in
an
unsupported
or
on
an
unsupported
os
now-
and
maybe
we
don't
even
want
that
like
maybe
this
is
the
wrong
model,
but
probably
not
I'm
just
saying
right
now:
you're
you're,
assuming
that
someone
who's
written
their
own
code
has
true
meaning
they
have
a
thing
and
that
false
would
imply
an
unsupported
and
maybe
that'll
hold
true
99
of
the
time.
A
I
just
feel
that
if
we
added
the
boolean
to
what's
already
proposed
here
that
it
lets,
it
doesn't
really
complicate
the
flow
analyzer
and
means
that
we
don't
need
to
go.
Add
support
for
unsupported
os
platform
guard
negative
behavior
of
like
they
really
need
it
to
be.
It's
unsupported.
If
true
and
yeah.
K
K
Logic-
oh
sorry,
I
I
want
to
agree
corey
like
adding
a
like
the
true
false
there
like
whether
or
not
it's
tractable
from
a
programming
perspective
like
just
looking
at
the
http
3
example,
where
you
have
like
multiple
attributes
like
if
you
combine
true
and
false,
it's
just
hard
for
me
to
reason
about
as
a
programmer-
and
I
I
haven't
heard
a
use
case
where,
like
the
false
case,
is
super
useful.
Yet.
I
I
mean
if
it's
had
the
true
false
option
I
mean
another
attribute,
I
mean
another
parameter
then,
and
then
we
have
these
supports
on
linux,
mac,
os
windows
and
then,
if
they
have
different,
true
false
values
than
what
they
should
understand
or
should
what
the
analyzer
should
do
with
that
like
it
will
be
very
difficult
to
match
them
or.
C
A
Yeah
yeah,
like
it's
just
yeah,
a
question
of
what
makes
sense
for
somebody's
current
api
and
code
that
they're
already
trying
to
wire
up
and
because,
if
we,
if
we
have
the
thing
that
only
has
the
the
supported
guard
means
it's
supported
when
you
return
true
and
the
unsupported
guard
means
it's
unsupported.
When
you
return
false,
then
we
may
force
people
to
go
rewrite
their
code
just
to
get
this
negative
assertion
statement.
G
A
It
seems
obvious
to
me
it's
when
it
returns.
True
apply
the
following
support
things
into
your
statement.
If
it
returns
false
apply
these
different
set
of
things
into
your
statement.
E
You
see,
but
that's
I
think,
but
I'm
still
not
sure
so
for
unsupported.
I
understand
what
it
means,
but
I
still
understand
what
unsupported
platform
guard
would
mean.
So
so,
let's
say,
take
the
http
3
and
enable
thing
now.
Let's
say
we
replace
all
support
west
platform
guard
with
unsupported
os
platform
guard.
What
does
this
field
mean?.
A
A
I
I
E
D
E
A
G
E
E
That's
why
I'm
still
mentally
struggling
with
the
inverse
of
that?
Okay,
I,
I
guess
yeah,
that's
the
way.
Unsupported
works
right.
So
basically
it's
the
same
thing.
You
just
track
the
ones
that
you
know
are
unsupported,
and
so
now,
when
you
call
an
api,
that
explicitly
is
unsupported
for
any
of
the
things
you
know
you
might
be
running
on.
You
get
a
warning
as
well.
E
But
I
guess
in
terms
of
composability
they
will
not
compose
the
same
way
as
supported
or
as
platform
does
because
supported
wise
platform.
The
question
is,
you
know
you
can
model
it
over
time.
Right.
You
can
say
this
api
was
introduced
in
windows,
10
and
then
removed
the
windows
12,
and
so
you
started
with
supported
os
platform
and
then
later
on
you
edit
and
support
the
rs
platform.
I
E
Yeah,
I
mean,
I
think
we
don't
have
to
implement
it
necessarily
if
you
don't
believe
we
need
it,
but
I
think
we
need
to
decide
what
semantics
these
attributes
are
supposed
to
have,
and
I
kind
of
agree
with
what
corey
is
saying.
Like
I
mean
given
the
naming
and
given
the
structure,
it
just
makes
sense
to
say
they
are
mirrors
of
supported
us
platform,
and
so
they
would
have
to
have
the
same
logic
right.
A
Yeah
I
mean
I
own
the
screen,
so
I
get
to
doodle
to
me
this
makes
sense
of
let's
just
say
we
put
a
boolean
in
the
current
one.
A
If
this
property
evaluates
as
true,
then
you
know
you're,
one
of
or
you
do
know
that
you're
mac
os
or
linux-
and
you
do
know
that
you're
not
ios,
you
don't
know
anything
about
browser
and
you
don't
know
anything
about
windows
like
you.
Just
don't
learn
anything
about
those,
it's
not
guaranteed
by
the
state
and
if
it
returns
false,
then
you
know
you're,
not
browser,
and
you
know
you're.
Sorry,
if
you,
if
it
returns
false.
You
know
that
browser
api
won't
work
and
if
it
returns
false
ios
api
won't
work.
K
Can
we
mix
in
some
supersets
and
subsets
right
so,
like
I
support
windows
10,
but
I
don't
support
windows
10
greater
than
sent
version,
because
that's
the
things
that
people
do
right,
yeah
and
so.
E
A
A
If
I
return
false,
you
don't
learn
anything
about
linux
and
then
this
one
says:
if
I
return
true,
you
have
learned:
I'm
not
ios.
K
A
G
A
We
had
a
lot
of
code
in
framework
is
win
9x
right,
which
meant
I'm
win
9x
and
not
win
2k
or
higher.
It
was
the
am
I
old
check
and
since
we
wrote
a
lot
of
am
I
old
checks,
I
can
see
a
lot
of
people.
Writing
am
I
old
checks,
and
then
that
means
they
want
com,
more
com,
they
want
complicated
behavior
and
they
wrote
negative
logic
as
compared
to
what
this
guard
is
currently
proposed.
I
So
what
the
fourth
attribute
means
like
support
those
plot
from
file
where
to
false
one
browser.
A
C
A
Yeah,
you
have
the
notion
that,
if
it
has
supported
from
the
current
proposal,
if
it
has
supported
os
platform
guard,
that
means
gain
this
state
when
it
returns
true
and
for
unsupported.
You
said
gain
this
state
when
it
returns
false.
I'm
just
saying
move
that
true
and
false.
Instead
of
a
hard
coded
answer
to
another
attribute,
parameter.
I
I
K
So
I
think
there
are
two
things
right,
supported,
support
and
true
and
false
are
similar.
The
problem
is
supported,
is
an
or
and
unsupported
is
an
and
and
therefore
like
it's
not
exactly
the
same
as
flipping
true
false
here,
but
the
problem
I
have
with
this
isn't
that
you
can't
make
the
logic
work.
Programmatically,
I'm
sure
you
can
it's
that
I
don't
want
to
read
that
like
as
a
programmer.
A
It
I
mean
that
that
is
100
an
aesthetic
style
right
like
there's,
if
is
win
9x,
throw
that
totally
makes
sense
to
people.
That
means
that
there's
a
bunch
of
established
is
win
9x
already
in
your
code
and
now
saying
is
win
2k
or
higher.
A
That's
inverting,
all
of
your
logic,
and
you
have
to
I
mean
yes,
if
you
do,
if
you
delete
the
old
name,
then
the
compiler
will
help
you
find
all
of
them,
but
it's
it's
because
we
came
up
with
this
guard
suggestion
we're
forcing
you
to
write
your
code
in
a
particular
manner,
and
my
suggestion
is
add
the
boolean
here
and
it
lets
people
write
code.
However,
they
want
so
one.
G
Thing
that
jeremy's
code,
jeremy's
idea
might
enable
is,
you
could
have
like
a
an
is,
is
unicode
or
something
for
for
windows
support
and
if
it's
true
you'd
call
the
unicode
api,
if
it's
false,
you
would
call
the
multi-byte
encoded
api
and
that
would
just
work.
You
wouldn't
need
two
checks,
because
it
would
tell
you
what's
supported
if
it
returns.
True
and
what's
supportive,
it
returns
false.
G
Yeah,
because
without
the
true
false
you
would
say,
if
unicode
do
this
and
then
under
that
you'd
have
to
say
else:
if
multi-bite
do
this,
so
you
you
would
need
to
have
an
extra
check.
K
But
ultimately,
like
all
jeremy's
saying
ads
as
far
as
I
understand,
is
you
can
invert
the
bool
like?
So
if
you
just
invert
the
blue
in
your
program,
it
doesn't
stop
you
from
doing
anything.
It's
a
style
thing
like
jeremy
said
like
you
might
not
want
to
change
your
entire
program.
If
you
wanted
to,
you
could
have
two
bulls
that
are
always
the
opposite
of
each
other
and
use
one
for
the
guard
and
the
other
in
your
program.
Well,.
K
A
A
And
we
can
make
the
boolean
be
an
optional
second
parameter,
and
basically
people
will
only
do
it
when
they
want
to
say
I
wrote
my
thing
backwards,
so
the
default
thing
looks
shorter
or
whatever
it
just
feels
to
me,
like
we
shouldn't
assert
that
people
are
writing
only
positive
assertions.
Sometimes
they
write
negative,
slash
old
assertions.
I
I
I
E
I
mean
my
question
is:
like
I
mean
I
think
I
understand
now
jeremy's
proposal.
My
question
is:
is
this
a
problem
that
you're
likelying
and
countering
because
my
understanding
is
that
basically,
what
this
allows
us
to
do
is
say:
if
you
have
feature
check
code,
like
is
thread,
start
support
or
whatever
what
booya's
feature
allows
us
to
say.
E
Well,
if
this
returns
true,
here's
what
you
know
about
the
platform
support
matrix
right
and
that's,
it
seems
inadvertently
positive,
like
it
doesn't
seem
likely
that
somebody
has
a
is
normal
threat
supported
right
because,
like
you
need
to
have
a
negative
boolean
effectively
in
order
to
run
into
the
need
to
say,
I
need
to
indicate
what
returning
faults
mean
versus
if
they.
If,
if
we
assume
that
all
feature
flags
are
inherently
positive,
then
you
only
ever
need
to
describe
what
true
means
you
never
have
to
describe
what
faults
means.
G
I
think
that
works
for
our
own
apis.
We
probably
want
them
to
be
positive,
but
that's
kind
of
our.
E
E
A
I
I
feel,
at
least
in
you
know,
framework
back,
because
you
know
core
never
ran
on
win
9x.
There
was
a
lot
of
is
win
9x
and
what
that
really
meant
was,
if
I'm
not
in
t4
aka,
I'm
not
windows,
2000
or
windows
xp,
and
that
was
then,
if
I'm
win,
9x
throw
and
that
was
written
all
over
the
place,
which
is
essentially
a
negative
feature.
It's
if
this
is
true
feature.
E
But
if
you
say
is
when
an
x,
the
check
is
literally,
are
you
running
on
windows
9
like?
Are
you
running
on
windows
and
maybe
you're
running
on
windows,
9
or
higher
right,
and
so
that
by
definition
excludes
every
other
platform,
but
that's
the
whole
feature
of
the
of
of
what
it
means
to
check
for
an
os.
It's
always
the
one
you
mentioned,
and
everything
else
is
implicitly
unsupported
right
versus.
A
E
K
A
A
G
G
A
E
So
I
think
I
understand
now
what
what
germany
is
saying
but
like
if
you
look
at
the
api,
it's
fine,
it's
wind
9x.
What
it
really
is
is
is
win
9x
or
older
right,
so
basically
you're
checking
into
the
past.
Basically
right
and
we
don't
have
this
concept
in
the
in
the
like
there's
no
idiomatic
way,
you
can
use
our
platform
compat
analyzer
and
have
them
understand
that
logic
like
ignore
the
guard
pattern
for
a
second
at
all
right
so
like.
E
If
you
just
look
at
the
the
we,
we
don't
have
checker
apis
for
that
by
vip.
Like
you,
you,
if
you
want
to
use
idiomatic
code,
you
would
have
to
have
a
method
called
this
nt
on
you
are
and
then
you
would
have
to
say,
if
not
nt,
on
your
throw
you
there's
no
way
you
can
write,
is
win9x
or
older
today,
right
and
so
then
so
there's
the
guard
pattern
that
buddhist
proposing
isn't
solving
that
problem
either
right.
E
E
If
that
makes
sense,
that's
right,
because
the
problem
fundamentally
is
both
supported
and
unsupported,
make
a
statement
over
the
things
that
aren't
returned
right
or
that
aren't
checked
right.
So
if
you
say
something
is
unsupported,
then
the
the
assumption
is
everything
that
you
haven't
said
is
unsupported
is
implicitly
assumed
to
be
supported
right,
that's
the
way,
unsupported
works
right
or,
if
you
say,
if
you
say
supported
well,
then
everything
that
you
haven't
mentioned
is
implicitly
unsupported
right.
E
So
there's
a
and
now,
if
you
allow
the
caller
to
indicate
what
true
or
false
means,
I
think
you
might
get
into
cases
where
those
things
no
longer
compose,
because
now
the
author
is
saying
yeah
yeah.
I
said
that,
but
now
I'm
giving
you
the
alternative
truth
table
for
the
other
three
platforms,
and
now
you
get
into
logical
inconsistencies.
A
That's
fair,
I
mean
like
it
really.
It
was
yeah
that
we're
assuming
or
we're
asserting
a
model,
but
if
you,
if
you
believe
that
the
current
support
attributes
are
already
locked
into
that
kind
of
model,
then
we're
at
least
consistent.
E
A
Well,
my
recollection
is
that
you
know
this
if
we
had
an
api
that
only
worked
on
winx,
get
rid
of
the
word
guards
here
and
that's
exactly
how
it
would
work,
because
my
recollection
is
if
the
lowest
thing
says
supported,
then
now
you're
describing
the
only
cases
that
it
works
and
then
the
higher
unsupported
says
it
stopped
working
at
this
point,
unless
we
got
rid
of
that
from
the
yes
from
the
feature.
No.
E
That
is,
that
is
correct.
So,
like
you
can
you
can
attribute
effectively
this
api
stopped
being
supported
in
the
windows
version?
What
you
can't
do
today
is
there's
no
way
you
can
author,
the
god
clause,
using
a
positive
right.
So
there's
no
way
for
you
to
I
mean
you
would
have
to
say:
if
is
not,
you
know
nt
or
higher,
throw
right.
E
A
If
I'm,
if
I'm
not
supported
because
you're
is
supported
of
the
positive
statement
and
like
that's
where
it
just
gets,
weird
of
things
where
you
can
talk
about
the
limiting
behavior
in
a
positive
spin
of,
is
single
threaded
and
is
single
threaded
is
really
is
not
multi-threaded,
because
multi-threaded
is
the
new
shiny
feature
that
you
can't
use,
and
it
just.
It
means
that
we
may
force
people
to
rewrite
all
of
their
logic
just
to
play
with
the
guard.
But
maybe
that's
fine.
E
G
G
So
an
example
to
use
the
is
single
threaded
concept
for
for
methods
that
can
only
be
called
if
you're
multi-threaded,
then
you
would
have
to
also
have
an
is
multi-threaded
property
somewhere
and
if
you
wanted
to,
if
you
had
a
code
path
that
could
could
either
do
single
threaded
or
multi-threaded,
depending
on
what
your
platform
supported,
you
would
have
to
do.
If
is
single
threaded
call,
my
single
threaded
thing
else.
If
is
multi-threaded,
call
my
multi-sided
thing.
G
K
E
How
would
you
attribute
that
thing?
Because
you
can't
just
say
now:
I
put
supported
os
platform
browser
on
it,
because
that's
not
true
right,
like
every
platform,
can
be
single
threaded.
It's
just
that
browser
can't
be
multi-threaded
right.
So,
like
you
can't
just
invert
the
field
with
like
without
the
boolean,
you
have
no
way
to
attribute
that
effectively
right.
K
A
Yeah
I
mean
like
it,
so
I
think
that
there
is,
if
we,
if
we
think
that
the
adding
the
boolean
is,
makes
it
too
complex
to
use.
I
think
that
there's
a
a
minor
gap
and
it
and
we
are
being
minorly
opinionated
on
how
people
should
write
their
code,
certainly
with
when
it
comes
to
public
api.
A
Not
you
know
the
the
analyzer
flow
here
we
have
said
we
want
positive
assertions
and
we
generally
want
assertions
that
only
get
more
true
over
time
again
assuming
you're
on
windows
that
once
you've
met
a
minimum
windows
version.
We
hope
that
functionality
doesn't
go
away,
but
certainly
as
anybody
who
likes
using
advanced
settings
in
windows
knows,
windows
does
like
removing
functionality
historically,
not
from
api,
though
but
the
so.
We
can
say
that
we
wrote
the
guards
or
the
existing
support
is
done
as
basically
positive
assertion
and
we
don't
have.
We
have
a
risk.
A
The
we
do
have
the
unsupported,
but
it's
a
positive
anti-support,
and
that
we
want
the
guards
to
be
when
it's
true
you've
learned
this
stuff
and
we
don't
have
a
if
it's
false
you've
learned
stuff
and
yep
invert.
Your
logic,
changer,
is
single
threaded
only
to
supports
multi-threading
and
deal
with
it
or
don't
use
the
analyzer.
A
A
I
think
it's
at
least
95
percent
of
cases
would
be
saying
when
true
so
like.
I
think
that
our
maybe
no
win
that,
like
at
least
95
percent
of
the
cases,
are
false,
but
we
went
ahead
and
left
ourselves
the
flexibility
to
say.
Maybe
you
have
a
if
this
is
true
null
can
come
out,
and
so
we
went
ahead
and
left
it.
But
maybe
we
don't
need
it
here
and
yeah.
We
can
add
it
later.
Yeah.
E
A
A
On
windows
and
not
windows,
at
the
same
time,
please,
I
can
assure
you
that.
E
Please
deal
with
this.
We
and
we
were
staring
at
the
current
attributions
for
methods
and
we
weren't
sure
whether
they
were
correct
or
sound
either
so
like
it's,
you
can
totally
create
like
world
where
that's
I'm
not
sure.
That's
actually
true
that
it's
trivial
to
understand,
because
the
thing
is
you
like
the
amount
of
flow
state
you
have
to
like
think
through
is
actually
quite
significant
to
do
that.
E
I
mean,
of
course,
we
can
analyze
that
as
well
right,
you
could
say
be
there
with
a
meta
analyzer
that
checks,
whether
your
support
the
rest
platform
guard
attribution
is
sound
right,
but
that's
that
might
not
be
trivial
to
author
either
right.
A
I
mean
ignore
the
compiler
doing
a
lot
of
over
analyzing
for
you,
if
you
wrote,
is
thread,
start
supported
and
is
single
threaded
and
wrote
one
of
them
as
negative,
the
other.
You
can
still
paint
both
of
them
with
contradicting
things,
and
you
can
add
them
together
and
learn
contradicting
things
so
totally
you're
still
in
that
same
state
but
yeah
I'm.
So
I
think
that
there's
value
in
adding
the
boolean,
I
agree
it
is
marginal
value
and
if
we
want
to
punt
it,
that
is
fine.
A
G
So
on
to
another
question,
it
occurs
to
me
that
it
would
be
really
nice,
if
I
could
say,
is
http
3,
supported
and
then
on.
My
method
that
uses
http
3,
I
can
just
say
you
know,
requires
guard-
is
http
3
supported
rather
than
having
having
this.
You
know
these
attributes
duplicated
essentially
everywhere.
I
need
to
use
them.
E
G
E
We
invented
some
attribute.
The
attribute
basically
allows
you
to
express
what
the
guarding
you
know.
Property
is,
and
then
you
apply
that
attribute
and
then
basically
the
call
side
will
get
the
flag.
If
you
didn't
do
that,
I
think
the
problem
with.
If
we
I
mean,
I
think
we
have
to
make
a
decision
like
what
we
what
we
promote
right,
because
the
problem
now
is,
if
you
have
both
capability
based
checks
and
west
checks,
you
know
they
clearly
intersect
right.
E
If
you,
if
you
look
at
booya's
feature
here,
the
idea
here
is:
we
have
these
internal
fields.
That
kind
of
do
the
feature
checking,
and
we
just
want
to
make
sure
that
when
you
check
for
the
feature,
we
still
know
what
it
means
in
terms
of
platforms,
so
we
don't
have
to
like.
You
know
now
also
attribute
every
single
thing,
with
these
capability
checks
and
you're
kind
of
asking
the
reverse.
Now
like
you're,
basically
saying
well,
I
want
my
callers
not
to
do
wealth
checks.
E
I
want
my
callers
to
check
the
capability,
which
I
think
is
fair.
I
think
that
that's.
I
think
the
original
reason
why
I
wrote
the
capability-based
spec,
because
the
idea
here
is
what
is
the
us
matrix
changes
over
time
right?
We
don't
want
callers
to
add
new
conditions
to
their
god
closes.
We
just
want
them
to
write
one
guard
and
just
be
done
with
it
right
and
I
think
that's
kind
of
the
world
we
maneuvered
ourselves
in
here
a
little
bit.
E
I
feel
like
what
this
analyzer
was
really
meant
to
solve,
is
our
specific
functionality
right.
I
think
if
we
start
using
this
analyzer
for
features
that
are
cross-platform
and
the
support
changes,
I
don't
think
the
platform
support
inlet.
That
makes
a
whole
lot
of
sense.
To
be
honest,
because
I
feel
like
that's
at
that
point,
you
just
you
basically
now
force
all
the
callers
to
do.
20
different
west
checks
right
over
time
right
and
I
think
that's
the
wrong
pattern.
Yeah.
I.
E
G
G
I,
I
guess,
there's
a
problem
with
this
today,
also
in
that,
if
you
have
many
methods
that
are
only
supported
on
certain
os's
and
let's
see
we
add
support
to,
I
don't
know
ios
for
http
3,
then
we
have
to
go
and
update
all
of
those
methods.
Yeah
yeah,
I
don't.
A
I
don't
quite
think
that
the
http3
scenario
is
probably
likely
to
get
used.
I
think
probably
a
single
os
assertion
is
going
to
be
more
likely
because
yeah
as
you
as
you
mentioned,
as
soon
as
you
say,
a
fourth
one
is
supported.
Now
you're
gonna
get
warnings
on
all
the
I'm
painted
as
the
three
things
that
we
previously
had
and
that
really
it's
just
more
for
the
like.
A
Oh
I
know,
I'm
I
know
browser
doesn't
work
or
or
browser
is
in
my
list
of
os's,
I'm
not
so
maybe
the
I
know
I'm
not
would
really
be
multi-painted,
but
the
I
I
expect
based
on
how
the
things
interact
and
how
much
painting
you
would
have
to
do
that
you're
really
only
going
to
do
it
for
oh,
I
know
I'm
linux
now,
once
you
can
get
down
to
one
then
you'll
be
like
this
is
a
substitute
for
a
os
platform
check
num,
but
I
mean
that
could
be
wrong.
G
Yeah,
I
guess
it
occurs
to
me
that
this
can
become
kind
of
infectious
and
that,
if
you
have
it
in
you
know
middle
tier
apis,
you
might
have
to
then
annotate
all
the
way
up.
The
call
stack.
A
Yeah
and
I
I
feel
again,
that's
where
the
the
feature
flag
may
be
at
a
high
level
api
and
then
you're
gonna,
probably
just
ignore
it
in
middle
layers
and
then,
when
you
get
to
the
end
and
you're
doing
your
p,
invokes
you're
gonna
be
like
well
whatever
I'm
I'm
palled,
like
I'm
already
conditionally
compiled.
I
know
this
is
sound.
Fine
debug
assert
I'm
windows
and
then
you
just
move
on.
I.
A
E
A
Yeah,
like
it
makes
sense
when
something
is
I
work
on
one
os
once
or
I
work
everywhere,
but
these
named
places.
Okay,
do
we
so
I
understand
method,
I
understand
property,
I
understand
field.
G
It
could,
let's,
let's
say
you
have
your
erp
invoking
on
into
an
api,
and
one
of
the
flags
is
only
supported
on
a
current
version
of
windows.
We
we
see
this
with
win
http
today
in
our
win
http
handler.
A
Right,
but
would
that
mean
a
flags?
It
has
to
be
a
flags-based
denum
and
you
tested
the
bit
and
if
it's
not
flags
that
you
tested
for
equality
like
this,
the
enum,
the
point
where
the
guard
is
allowing
this
to
come
in.
I
understand
the
not
the
guard,
but
the
current
restriction
of
this
enum
member
only
makes
sense
if
I'm
on
windows,
but
the
this
enum
member
tells
me
I'm
on
windows
that
feels
I
don't
know
how
this
fits
in
our
in
any
programmatic
model.
A
Happen
and
how
the
flow
analyzer
is
going
to
know
that
that
bit
mattered.
So
I
think
we
maybe
want
to
get
rid
of
attribute
target
enum
on
the
guard.
G
Yeah,
I
see
that
I
think
I
agree
if
someone
is
using
an
enum
for
that
they
can
just
create
a
full
property
off
of
it.
I
E
A
E
A
H
A
We
certainly
only
talked
about
stateless
or
we
didn't
talk
about
parameters
and
what
they
would
mean,
but
I
don't
know
that
it
would
matter
because
it's
if
this
method
returned
true
you've
learned
the
following:
you
don't
care
what
parameters
went
into
it,
you're
if
you're
you're
in
the
block
or
you're,
not
okay,.
E
I
mean
you
could
imagine
a
case
where,
like
they're,
actually
delete
recursively
right,
but
you
can
currently,
you
have
no
way
of
saying
if
you
call
the
method
with
false,
it
works
everywhere.
If
you
call
the
method
with
true,
it
only
works
on
windows
or
something
right,
but
we
we
basically
given
up
on
modeling
there,
because
it's
just
it
gets
very
quickly
very
complicated,
because
now
what
you're
really
saying
is
certain
inputs
to
this
method
require
certain
operating
system
support
and
that
gets
very
quickly
very
complicated.
D
E
Express
aesthetically
anymore
right,
I
mean
the.
E
We
had
was,
I
think,
named
pipes
where,
if
you
call
the
method
with
a
non-null
string,
it
only
works
on
windows.
If
you,
if
you,
if
you
don't
give
it
a
name,
it
works
everywhere
or
something
like
that
and
you
just
we
just
don't-
have
a
good
way
to
to
do
that.
Aesthetically
and
I
think
for
for
configuration
values
for
enums.
We
just
said
well,
if
you
know
value
is
only
supporting
windows.
Well,
then
we
can
clearly
articulate
that
by
just
marking
the
inner
member,
and
so
when
you
dereference
the
enum
member.
E
Well,
you
know
you
can
do
this
on
all
parties
on
all
platforms,
but
usually
you
would
use
it
to
actually
configure
your
connection
string
or
something,
and
in
that
case
you
get
a
warning
at
the
u
side
of
the
enum
memory,
which
is
probably
good
enough
because
with
booleans
right,
because
you
know,
oh,
you
can
only
express
true
on
windows
that
would
be
a
bit
draconian,
maybe
but
yeah
yeah.
It's
I
think,
for
those
cases
we
said.
If
we
really
want
to
do
this,
we
just
have
an
analyzer.
H
Okay,
cool
and
then
booyah
kind
of
question
for
you.
I
just
put
a
link
to
one
of
the
scenarios
in
the
chat
here
of
a
place
where
this
had
surfaced
where
we
had
a
combination
of
linux
and
then
narrowing
android
away
from
linux
from
I
just
wanted
to
get
kind
of
confirmation
from
you.
You
think
this
design
also
addresses
that
scenario
of
being
able
to
wrap
that
in
the
er
create
guard
method
to
capture
that
scenario.
I
I
A
I
B
E
E
E
A
All
right
to
follow
my
normal
style.
We
have
a
new
blocking
issue:
low-level
api
support
for
objective-c
scenarios,
issue
number
four:
four:
six:
five
niner!
If
we
can
get
someone
to
talk
about
it.
B
I've
tagged
aaron
waiting
for
a
response.
K
All
right,
yeah
I'll,
probably
be
the
one
who
ends
up
implementing
this
if
it's
approved.
So
the
basic
concept
here
is
pipe.
K
Readers
are
used
a
lot
for
parsing,
a
lot
of
things
that
you
parse
end
up
being
linked
prefixed
and
today,
if
you're
awaiting,
like
you,
know
a
certain
amount
of
data
in
like
a
message
pack
payload
or
like
an
hpv2
frame
every
time,
the
writer
writes
data,
it
wakes
up
the
reader,
assuming
it
hasn't
examined
the
data
yet,
which
is
you
know,
every
new
write,
that's
the
case,
even
if
the
reader
already
knows
that
it
doesn't
care
about
the
data
until
it
receives
a
certain
amount.
K
K
K
So
that
will
be
the
default
implementation,
but
the
idea
of
making
this
new
virtual
method
is
that.
So
if
yeah,
you
have
a
an
abstract
pipe
reader
right
and
then
you
have
the
default
pipe
reader
which
is
what's
created.
When
you
like
new
up
a
pipe
and
use
dot
reader
in
the
default
reader,
it
will
be
more
optimized,
so
it
doesn't
schedule
kind
of
the
re-loop
at
all
until
the
amount
of
until
there's
at
least
min
bytes
remaining
or
the
read
is
canceled
or
the
pipe
is
complete.
K
A
J
K
K
There
are
two
states
where
it
could
return
early
so
to
get
in
that
it's
the
eof
is
the
one
for
sure
where
we
return
early
with
less
than
the
amount
of
data,
but
you
can
still
examine
it
and
then
the
other
thing
is
if
cancel
pending,
read
is
called
and
that's
usually
used
for
kind
of,
like
janitorial
kind
of
work
like
basically,
sometimes
the
loop
might
want
to
exit
earlier
check
for
timeouts
or
do
some
random
thing,
and
regardless
of
the
data,
that's
there,
we
basically
want
to
wake
up
the
reloop.
A
A
So
one
piece
of
feedback
I
have
is
that,
since
it
has
a
attribute
that
should
or
a
parameter
that
should
be
validated,
that
it
should
use
the
template
method
pattern.
So
derived
types
don't
need
to
write
if
minimum
bytes
is
less
than
some
number
throw.
Zero
is
presumably
legal,
but
so.
K
A
G
K
Right
so
in
cash
flow
it
often
ends
with
being
four
kilobytes
at
a
time
because
that's
the
size
of
a
rebuffer
there
certainly
can
be
like
prefixes
longer
than
that.
You
know:
we've
gone
this
long
and
castro
without
it,
and
certainly
for,
like
you,
know,
jason
and
plain
text,
tech
and
power
benchmarks.
It
makes
no
difference
whatsoever.
G
K
It
really
depends
on
how
big
like
prefixes
are
so
for
hp2.
I'd
have
to
like
double
check
what
the
max
frame
size
is,
but
that
would
be
like
an
example
and
that's
far
more
than
4k,
I'm
pretty
sure,
for
you
know,
that's
modifiable
via
like
the
settings
frames
and
stuff
right,
but
I'm
just
thinking
about
casual
defaults
regardless
it
does
depend
on
the
scenario.
K
It
could
be
a
lot
if
there's
a
really
long
length
prefix,
but
in
the
vast
majority
of
the
cases
we
get
all
the
data
we
need
in
a
single
read,
at
least
in
the
things
that
we
heavily
benchmark.
A
All
right,
so
the
reader
already
knows
like
the
the
current
read.
Async
just
takes
a
cancellation
token,
so
obviously
it
reads
into
a
place
that
it
already
knows
how
to
read.
So
this
is
really
just
block
the
read
until
the
read
result
would
be
big
enough
or
one
of
the
other
terminal
conditions
happens.
K
Yeah,
so
for
a
little
more
context,
oftentimes,
you
know
we
end
up
having
the
thread,
pool,
dispatch
and
stuff,
because
we're
ultimately
like
giving
the
data
to
user
code
and
stuff
in
this
particular
stuff,
we're
in
in
the
parsing
loop,
it's
often
in
line,
but
it's
still
like
extra
work
when
the
we
can
just
very
quickly
not
dispatch.
If
we
know
how
much
data
the
reader
is
expecting.
K
We
could
have
it
return
false
for
try
read
if
you
really
wanted
to,
but
that's
not
something
we're
super
interested
in
at
the
moment.
Yeah
like.
A
Yeah
I
mean,
I
guess
well,
because
if
what
you
interpreted
it
as
is
I'm
gonna
keep
going
to
sleep
until
try
read
minimum,
you
know
10
24
returns.
True,
then
the
default
behavior
would
be
that
it
you
never
got
into
that
state.
So
it's
probably
weirder
to
add
it
than
agreed
like
we
need
like
supports,
limited
or
supports.
A
A
Done
all
right
is
bites,
the
right
thing
are
pipes
bites.
K
Yeah-
and
I
think
just
having
an
overload
on
rebasing
makes
sense
like
what
else
would
it
mean
there?
I
mean
it
has
a
name.
K
A
J
G
J
I
think
it's
more
discoverable
if
you
call
it
read
at
least
async,
otherwise
you
know
if
I'm
looking
at
the.
If
I
have
my
little
intellisense
and
I
look
at
my
drop
down
of
things
I
can
do
I
see
oh,
I
can
read
any
sync
well,
I
already
know
how
to
do
that,
and
that's
only
going
to
be
when
I
actually
get
around
to
looking
at
the
different
overloads
that
I
say,
oh
wait,
actually
there's
an
overload
that
kind
of
doesn't
just
read.
It
does
read
at
least.
K
A
K
K
I
I
really
want
to
hear
what
he
has
to
say
about
this
he's
like
I'm
not
in
this
meeting
right
now,
but
I
just
saw
this
pop-up
in
stream.
I
think
the
scenario
for
this
api
leads
the
developer
into
a
security
pit
of
failure
which.
G
K
Yeah
the
problem
with
that
is
then
castrol
couldn't
use
it
right
because
of
cancel
pending.
A
K
A
A
little
more
okay!
Well,
I
could
see
there
being
a
problem.
I
I
could
see
someone
making
bad
assumptions
if
this
was
I'm
giving
you
a
buffer
on
the
call,
tell
them
and
then
read
at
least
you
know
100
bytes,
and
it
says
I
read
seven
and
you're
like
well.
I'm
gonna
go
process,
the
first
hundred
bytes
and
now
I'm
reading
what
I
said:
93
bytes
that
were
just
garbage
that
was
already
in
the
buffer,
but
since
this
has
a
secondary
guard
of
what
state
is
the
reader
in?
K
Yeah,
I
wonder
I
I
think
levi
probably
does
understand
it,
but
there
was
a
similar
thing
that
came
up
in
the
pipe
writer's
side.
K
I
don't
know
like
you
know,
because
these
are
like
spans
in
memory
and
they
do
have
bounds.
It's
not
like
you
know
a
c
buffer
overflow,
but,
like
you
know,
you
do
drop
in
on
safeco,
sometimes
right,
especially
in
kestrel
and
so
forth,
like
it's
not
impossible
to
overrun
a
buffer.
If
you
remove
all
the
checks.
A
K
G
G
The
only
other
thing
I
could
think
of
is
you
know
if,
if
you're
not
checking
what
you're
parsing
and
a
frame
says
that
it's
two
gigabytes
in
size
and
you
just
blindly
plus
pass
two
gigabytes
to
this
and
it
just
hangs
for
a
while,
but
you
kind
of
have
that
issue
in
current
code
already,
I
guess
it's
just
a
little
more
explicit
than
current
code.
G
A
That
could
be
the
other
angle
that
he
is
concerned
about,
so
without
him
being
here
to
talk
about
it.
If
we
talk
about
this
from
an
api
perspective,
instead
of
from
a
feature
perspective,
I
think
we've
finished
the
api,
but
that
levi
may
want
to
make
a
follow-up
move
to
kill
the
feature.
A
B
Okay,
so
we
need
to
schedule
a
dedicated
api
review
session
for
that
one
aaron
feels
it's
going
to
be
a
long
one,
and
it's
going
to
need
the
entire
interop
team
and
david
wrighton
for
it.
So
we
probably
want
to
do
that
for
thursday
or
friday
if
we're
still
doing
backlog
and
otherwise
just
a
full
one
to
two
hour
session
next
tuesday.
A
Okay
make
sense
so
we
have
10
minutes.
I
assert
this
one
as
a
10-minute
issue,
all
right
put
on
your
stone
age,
hats
and
think
back
to
net
framework
1-1
before
generics
existed,
and
you
had
typed
collections,
okay,
x509
certificate,
two
collection
and,
to
a
lesser
extent,
x.
509
certificate
collection
are
typed
collections.
A
The
soft
typed
collection
into
something
link
understands
steve
suggests
we
just
go
ahead
and
make
the
change
now
to
say
it
is
you
know
by
innumerable
or
ionitor
of
the
generic?
There
are
some
tiny
edge
cases.
We
don't
care.
G
Remember
we
did
something
similar
with
the
regex
class
like
the
match,
class
or
match
collection,
and
it
created
an
ambiguity
in
an
overload
that
previously
worked.
Does
anyone
remember
that.
I
B
I
mean
you,
you
always
have
the
chance
of
providing
ambiguities
if
you've
got
something
that
takes
either
an
I
numerator
or
an
I
enumerator
of
x,
509
chain
element,
given
that
previously
would
pick
one
and
now
it
will
pick
now.
It
won't
know
which
one
to
pick,
but
I
feel
that's
enough
of
an
edge
case
that
users
can
fix
that
on
yeah
yeah.
E
A
A
B
E
A
F
A
F
Oh
no,
no,
it
was
just
a
I
don't
I'm
sorry.
I
wasn't
able
to
type
more
in
a
chat.
It
was
just
a
like
hey
if
you're
parsing,
an
untrusted
tlb
header
like
do
you
want
the
attacker
to
specify
the
length
type
thing.
A
A
All
right,
so,
according
to
my
schedule,
it
looks
like
our
next
meeting
is
in
48
plus
22
hours,
so
10
a.m.
Thursday
redmond
time
see
everyone
then
bye.