►
From YouTube: GitHub Quick Reviews
Description
Powered by Restream https://restream.io/
A
A
A
A
A
A
All
right
good
morning,
good
evening,
wherever
you
are
so
today,
is
another
iteration
of
our
api
review
backlog.
So
I
think
we
want
to
start
with
this
one
here
at
least
that's
the
one
that
I
also
have
to
think
about
how
to
pronounce
the
names
correctly.
Stephen
asked
me
to
review
yesterday.
B
B
You
generally
end
up
overriding
read,
write,
read,
async
right,
async
begin,
read,
begin
write,
all
of
which
take
the
same
arguments,
a
byte
buffer
and
into
offset
and
in
count,
and
you
need
to
validate
all
those
arguments,
so
you
do
it
in
at
least
six
places
in
each
stream
type.
B
And
if
you
look
at
that
at
runtime,
we've
got
you
know:
20
30
40
of
these
things,
each
of
which
either
duplicates
all
that
code
multiple
times
or
creates
its
own
helper
or
we
create
one
for
the
repo
and
then
you
know
end
up
using
that,
but
invariably,
when
they
each
do
their
own,
they
end
up
doing
it
slightly
differently
and
we
get
different
behavior.
B
Yeah,
so
I
mean
yes,
there's
some
haziness
there
in
that
different
streams.
Sometimes
do
it
slightly
differently,
in
particular,
when
validating
that
the
offset
and
count
don't
exceed
the
lengths
of
the
buffer.
Sometimes
they
end
up
throwing
argument
out
of
range
exceptions.
Sometimes
they
end
up
throwing
the
base
argument
exception.
Sometimes
they
include
the
name
of
one
of
the
one
of
the
parameters.
Sometimes
they
don't
so.
B
The
proposal
here
is
to
just
do
argument
out
of
range
exception,
for
you
know
that
joint
condition
and
probably
to
include
the
parameter
name
of
count
as
the
as
the
sort
of
we
just
declared.
That's
the
one.
That's
you
know
is
wrong
and
it's
possible.
There
could
be
some.
You
know
breaking
changes
there,
but
I
don't
think
it's
a
big
deal,
especially
since
we'd
be
changing
worst
case,
something
that
was
argument
exception
to
something
that
was
argument
out
of
range
exception.
D
B
Other
thing
is:
there
are
some
derived
types
that
do
the
wrong
thing
with
regards
to
they,
they
override
and
specify
a
different
name
like
network
stream,
calls
into
count
and
instead
overrides
and
calls
it
in
size
and
somewhat
streams
override
it,
and
it's
calling
it
bite
buffer
like
the
base.
They
call
it
bite
array.
B
I
was
talking
offline
with
emo
and
eric
st
john
and
jeff,
and
I
think
for
dotnet6.
We
should
accept
the
breaking
change
and
go
through
and
fix
all
of
them
to
conform,
because
it
ends
up
being
really
strange.
Well,
first,
this
helper
becomes
less
useful
if
you
can't
use
it
in
all
those
places,
but
secondly,
it's
really
strange
when
you're
using
you're
generally
using
stream
versus
via
the
base
class-
and
you
end
up
getting
parameter
names
that
don't
make
any
sense
because
they
don't
show
up
in
the
base
class.
B
It
also
leads
to
weirdness,
if
you're,
using
like
dynamic
or
something
because
then,
if
you
try
and
specify
an
a
name
parameter
at
the
call
site,
you
have
to
use
the
one
from
the
drive
type.
Even
though
you
have
no
idea
what
the
drive
type
actually
is,
if
you're
just
getting
back
a
stream.
So
the
proposal
here
is
to
just
use
the
names
of
the
base
from
the
base
type
and
we
go
and
fix
up
the
likes
of
network
stream
to
use
the
correct
parameters.
C
Sounds
all
reasonable
to
me
I
mean
this
is
introducing
a
protected
member
to
make
up
for
the
fact
that
it
didn't
use
the
template
method
pattern
in
the
first
place,
but
it
puts
us
in
a
better
state
we
can't
get
to
where
we
should
have
been.
A
B
I
mean
we
probably
have
a
similar
one
in
you
know,
text
writer
and
some
other
common
base
types.
B
B
We
want
to
go
and
do
something
with
other
types
as
well,
but
we've
been
doing
a
lot
of
stuff
with
stream
lately
and
this
popped.
C
Yeah,
my
guess
is
it's
that
it
doesn't
do
the
template
pattern.
It
is
extended
often-
and
this
is
the
class
that
is
held
together
with
the
most
baling
wire
and
duct
tape,
in
that
it's
gone
through
every
notion
of
async
that
we've
ever
had
and
then
it
the
spanification
and
yeah
like
every
bad
thing.
We've
ever
done
to
a
type
has
been
done
to
stream.
E
A
Want
like
do
we
think
that
having
validate
methods
is
the
right
pattern,
because,
basically,
that
has
to
contract,
because
they
just
throw
right
so
like
if
they
succeed,
they
return
nothing.
A
B
A
A
I
don't
have
an
alternative,
I'm
just
this
is
saying
like
if
this
is
the
pattern
we
want
for
argument,
validation.
Is
this
basically
what
we?
What
we
think
is
the
right
model.
So,
for
example,
would
we
say
we
have
static
helper
methods
on
the
type
or
what
we
have
you
know
similar
to
the
contract
stuff,
that
we
have
a
centralized
place
or
where
we
put
this
aesthetic
helpers.
D
Question
I
I
would
put
this
on
the
type
just
because
the
parameter
names
match
the
signatures
that
are
prevalent
on
this
type.
If
you
look
at,
I
think
I
think
steve
brought
up
other
types
like
text
reader
text,
writer,
those
tend
to
use
either
different
parameter
names
or
slightly
different
signatures
in
a
lot
of
their
cases.
So.
E
C
Yeah
I
mean,
like
the
the
byte
end,
end
right
that
can
be
called
buffer
array.
Buff
data
the
end
is
offset
or
start
or
start
offset
or
index
count
as.
D
A
C
A
I
mean,
I
think,
to
me
the
the
prefix
and
the
suffix
makes
sense.
The
question
is
just
like
do
we
know
like?
Is
it
obvious
from
the
method
names
which,
because
they're
basically
tied
to
particular
signature
right
so
like?
Is
it
clear
which
methods
they
apply
to
that
copy,
2
kind
of
makes
sense
right?
It's
the
copy,
2
method,
the
buffer
arguments
applies
to
probably
all
the
read
methods
right.
B
B
A
A
D
B
And
I
alluded
to
this
in
one
of
the
comments:
basically
copy
to
validation
isn't
just
about
arguments.
It's
also
about
the
state
of
the
source
and
destination
stream,
whether
the
readable,
writable,
disposed,
etc,
and
there's
this
complicated
sort
of
logic
that
a
dance
that
goes
through
to
say,
like
you
know,
if
the
sources
isn't
readable,
but
the
destination
is
writable
then
throw
this
if
the
source
is
readable
but
the
destination
isn't
writable
then
throw
that
so
it
needs
access
to
the
source.
B
Basically
this,
so
we
would,
if
assuming
we
want
to
do
this,
we
have
two
options.
Basically,
it's
static
and
you
pass
in
this
as
the
first
argument
or
it's
an
instance
method,
and
it's
you
know
it
just
uses
this
internally.
I
went
back
and
I
went
back
and
forth
on
that
and
decided
it
made.
It
was
better
for
it
to
be
consistent
with
from
a
static
perspective
with
the
other
validation
method,
but
I
don't
feel
strongly
about
it.
D
So
the
one
of
the
differences
in
between
these
two
methods
is
validate
copy.
Two
can
also
throw
invalid
operation
exception,
or
invalid
state
exception,
whatever
it
is,
whereas
valve.
D
C
I
mean
I
yeah
if
the
thing
that
you're
supposed
to
pass
for
source
is
always
this,
I
would
just
make
it
instance.
D
B
B
Initial
set
of
read,
write
methods,
didn't
necessarily
so
I
mean
we
could
choose
to
add.
You
know
a
can
read
check,
but
then
we
would
need
to
distinguish.
We
would
need
two
validation
methods,
one
for
read
arguments
and
one
for
right.
Arguments
and
you'd
need
to
validate
that.
You
know
the
can
read
and
the
read
and
write
and
the
right.
B
G
G
No,
I
mean
like,
like
you
know,
a
like
a
network
stream
is,
is
always
beautiful
and
ridable
unless
it's
been
disposed
right,
so
you're,
there's
no
point
in
checking,
can
read
and
can
write
because
they're
always
going
to
return.
True
in
that
case
or
buffer
arguments,
I
guess
you
could
make
a
similar
argument
for
copy
2
arguments.
C
C
Argument
no
exception
for
buffer
offset
is
negative,
count
is
negative,
offset
exceeds
buffer.length,
the
combination
of
offset
and
count
exceeds
the
space
remaining
in
buffer
and
then
and
then
the
various
things
that
the
methods
do
are
just
not
as
consistent
at
that
point,
especially
across
our
entire
hierarchy,
whereas
copy
two
we're
fairly
consistent,
so
we're
just
gonna
go
ahead
and
lock
that
in
as
a
pattern
or
lock
that
in
as
a
utility
method,
essentially
that's
that's.
B
The
argument
yeah
and
again
I
realize
you
know
I
mean
levi-
has
a
very
valid
point
that
these
two
methods
are
kind
of
doing
different
scopes
of
validation.
At
the
same
time,
we
build
this
stream
numbers.validation.cs
file
into
every
one
of
our
assemblies,
because
they're
all
doing
the
the
same
thing.
B
Now,
maybe
maybe
that
logic
could
be
simplified.
Maybe
we
could
say
you
know
it's
not
worth
it's
not
worth
doing
these
extra.
Can
we
can
write
checks
just
delegating
so
be
it.
I
think
one
of
the
reasons
that
doesn't
happen
is
so
that
early
errors
can
be
surfaced.
Synchronously
from
async
calls
so
like.
B
If
you,
if
the
destination
stream
isn't
writable,
you
generally
don't
find
that
out
in
copy
to
async
until
you're
already
doing
the
copy
you've
already
read
from
the
source
you're
already
running
asynchronously
any
exception
is
going
to
be
surfaced
as
part
of
the
task
and
so
like
you've,
already
mutated,
stuff
and
you're
no
longer
able
to
properly
propagate
the
exception.
Synchronously.
A
C
This
seems
reasonable
if
we're
gonna,
but
once
we're
taking
like
we
changed
some
arguments,
breaking
change.
I
wonder
if
there's
some
like
a
couple
exceptions,
maybe
get
thrown
in
a
different
order,
but
they're
all
basically
argument
and
state
exceptions.
So
they
don't
they
shouldn't
matter
anyway,
and
we
go
ahead
and
codify
this
is
you
know,
validate,
read
arguments,
and
this
is
validate
right
arguments
and
I
guess
the
problem
is
we
still
the
like
the
object,
exposed,
exception
and
stuff
in
most
of
our
streams?
C
Now
those
are
probably
actually
in
the
span
and
memory
ones
and
the
buffer
ones
are
just
validating
the
arguments
to
get
the
names
right
and
then
calling
the
span
ones
right
in
the
so
we
have.
We
do
have
different
scopes
on
them.
Like
copy2
does
the
work
and
the
byte
array
things
aren't
the
ones
that
do
work
in
our
on
our
modern
classes.
B
Yeah
I
mean
to
some
extent
on
on
our
newer
stream
implementations,
where
you
like,
as
you're,
saying
that
delegate
from
the
binary
ones
to
the
memory
ones
like
the
only
reason
this
validation
function
is
used,
is
to
get
the
right
argument
names
in
the
exception,
that's
thrown
memory,
annoyingly
uses
different
names
for
its
arguments
and
for
I
guess
perf
reasons
it
doesn't
actually
include
the
names
in
the
exceptions
that
are
thrown
at
least
some
of
them.
So
the
point
of
this
is
just
purely
usability.
B
C
Yeah,
so
I
think
I
would
do
what's
proposed
except
validate
copy
2.
I
would
make
instance
just
so
there's
never
a
weird
state
where
somebody
passes
something
other
than
this
is
the
first
parameter.
G
So
the
other
thing
we
could
do
is
we
could
just
get
rid
of
the
source
argument
and
then
the
issue
goes
away
completely
right.
I
mean
I'm
just
looking
at
that.
What
I
think
is
the
actual
implementation
here
is
it
is
it
steven?
Is
it
really
just
checking
can
read,
because
you
know
maybe
maybe
just
for
consistency.
G
We
should
just
drop
the
can
read
check
and
do
that
manually
and,
as
I
said
some
some
some
implementations
may
not
even
need
to
check
that
because
they
already
know
that
assuming
they're
not
disposed,
that
they
are
in
fact
readable
and
they
can
just
alive
that
check
completely.
B
Of
me,
but
this
is
a
good
time
to
do
it,
but
there
are
some
of
the
checks
in
that
method,
combined,
like
with
checks
on
destinations.
You
can't
write,
like
I
don't
remember
exactly,
but
there's
some
logic
about
whether
one
or
both
of
the
can
read
can
writes,
return
false
and
using
that
to
determine
whether
to
throw
an
invalid
operation
exception,
naming
the
source
the
destination
or
throwing
an
object
disposed
exception.
Instead,
I
don't
remember
the
exact
details,
but
someone
wants
to
look
it
up.
It's
in
the
that
stream
helpers
file.
G
A
Yeah,
I
have
to
say,
like
I'm,
not
a
fan
of
jeremy's
idea
of
making
them
instance
methods,
I
think,
for
algebra
validation.
I
would
probably
prefer
to
them
to
be
static,
so
it's
clear
what
you're
actually
passing
in
as
soon
as
you
have
an
instance
method,
it
might
check.
You
know
everything
in
the
world.
This.
A
G
Yeah,
just
stephen,
I
don't
know
if
you
had
a
chance
to
look
at
the
code,
but
it
looks
like
there's.
We
we
check
the
only
thing
we
check
source
can
read
and
we
check
source
can
write
if
they're,
both
false
we
throw
object,
dispose
if
only
source
can
read
is
false.
Then
we
throw
unreadable
stream.
B
Yeah
so
and
again
like
I'd
also,
I
mean
we're
more
open
to
this
level
of
change
between
versions.
If
we
wanted
to
establish
that
like
we
just
you
know,
always
throw
not
supported
exception,
and
if
you
want
to
do
anything
else,
you
do
it
before
the
call
or
the
call
I'm
okay.
With
that
I
mean
it
does
mean
we'll
have
some.
You
know,
differences
about
which
exception
gets
thrown
first,
if
you
pass
an
invalid
buffer
and
you're
on
the
disposed
stream,
I
don't
really
think.
C
Right
but
the
the
one
between
the
object
disposed
exception
and
the
not
supported
exception,
assuming
that
that's
written
because
streams
when
they
dispose
that
both
their
can
reads
and
can
rights
to
false,
like
that
means
that
anything,
that's
getting
an
ode
now
would
get
a
not
supported
exception,
which
would
be
a
bad
change.
B
Yeah
the
issue
here,
though,
that
logic
is
that's,
there
is
a
little
bit
iffy,
because
this
isn't
the
same
way.
This
isn't
the
same
stream,
that's
the
source
and
the
destination,
so
just
because
they're,
both
false
doesn't
actually
mean
that
they
were
disposed.
B
C
No,
I
don't
actually
think
what
we
do.
I'm
just
saying
anyone!
That's
actually
using
this
this
logic.
You
would
change
the
order
of
where
the,
if
you
get
the
object
disposed
exception,
which
tells
you
you
have
a
lifetime
management
problem
or
not
supported
exception,
which
you
you're
like
where,
where
did
this
come
from
and
what
happened?
It's
just
that
changing
an
object,
exposed
exception
to
an
unsupported
exception
feels
like
a
if
we
let
that
go
through.
C
B
Did
it
this
way?
I
actually
did
it
this
way.
I
went
back
and
forth
about
whether
to
propose
it,
propose
it
as
such,
and
I
did
it
just
to
figure.
If
someone's
you
know
looking
for
validation,
if
they
find
stream
dot
validate
buffer
arguments,
then
they
have
the
other
validation
methods
in
the
same
list.
G
G
Again,
if
the,
if
the
consternation
air
is
about
source,
let's
just
remove
source,
I
don't
think
there's
any.
You
know,
I
think,
there's
a
reasonable
argument
to
be
there.
That
gives
us
a
couple
things.
First
of
all,
we're
not
dealing
with
the
issue
of
what
to
you
know
what
to
call
this
and
how
to
think
about
it.
Second
of
all,
it
makes
it
has
a
nice
symmetry
here
where,
where
validate
copy,
2
arguments
takes
the
same
arguments
that
copy
2
takes
just
like
validate
buffer
arguments
takes
the
same
arguments
that
read
takes
sure.
G
But
we
can
still
do
the
object.
We
can
still
do
the
two
checks
on
the
destination
right,
it's
just
the
source.
We
can't
do
the
checks
on
and
I
think,
there's
a
reasonable
argument
to
be
made
here
that
a
stream
knows
its
own
state.
It
knows
whether
it's
readable,
it
knows
how
it's
whether
it's
disposed.
It
knows
how
to
check
those
things
properly,
whereas
we
don't
right,
we
don't
necessarily
know,
as
steven
said,
we're
kind
of
you
know
faking
the
dispose
check,
because
we
can't
actually
check
whether
something
is
disposed
or
not.
G
So
let's
just
remove
the
stream
the
source
argument
and
require
that
callers
need
to
do
that
themselves
if
they
need
to.
Most
of
them
are
probably
checking
disposed
here
anyway.
Right
because.
C
B
B
C
Okay,
so
so
steve,
your
suggestion
is
that
the
dispose
check
trumps.
The
argument
checks.
B
B
And
so
so,
if
we
did
that,
then
yeah
you
you
could
you
could
end
up,
throwing
in
a
situation
where
we
would
have
been
throwing
a
not
supported,
but
an
object
disposed
was
still
possible.
We
might
end
up
throwing
them
in
the
reverse
order,
and
I
think
I
I
think
in
general
we
were
okay
with
that
level
of
quote:
break.
B
I
B
B
That's
how
I
interpreted
this
question
and
I
think
it's
purely
historical
that,
like
there's
really
no
to
jeff's
point,
there's
really
no
need
for
these
validation
methods
to
do
it
because
the
caller
is
going
to
do
it
in
one
way,
shape
or
form
or
not,
whereas
whoever
wrote
the
initial
copy
to
did
this
long
series
of
checks
and
then
we
ended
up
putting
that
into
a
helper
and
propagating
that
to
every
stream
that
we
have
and
so
for
us,
it's
just
sort
of
become
the
canonical
thing
to
do.
These
checks.
B
E
A
C
I
think
that
it's
doing
more
upfront
checks,
because
is
just
because
it
can
verify
that
it's
in
an
okay
state,
if
it
calls
read
on
the
local
thing
before
calling
right
on
the
destination
but
destination
was
disposed.
You've
now
lost
data
out
of
this
like.
If
we,
if
we
delay
those
checks,
we
we
change
what
exceptional
behavior
does
to
side
effects.
B
Right,
no,
I
think
it's
important
to
validate.
I
think
it's
important
to
validate
destination.can
right
before
doing
the
reads
on
the
source.
So,
but
we
don't
lose
that
by
removing
this
from
the
from
the
signature.
A
C
A
B
B
This
is
pure
speculation.
I
I
bet
this
came
about,
because
this
validation
didn't
initially
exist
and
then
not
supported.
Exceptions
started
getting
thrown
in
the
middle.
C
C
G
A
G
We
need
new
static,
defines
for
hp
version
30
and
the
corresponding
alpn
name
for
hp3.
J
J
Our
own
static
internally
there's
really
no
no
need
for
a
public
api.
I
guess
it
lets
us
share
the
the
instance
with
between
kestrel
and
http
client,
but
the
memory
savings
there
aren't
really
compelling.
J
J
C
E
B
C
I
think
we
historically
made
a
mistake
when
we
called
things
version,
10,
11
and
20,
but
we'll
feel
that
pain
in
a
couple
years.
I
G
The
version
the
hp
version
has
been
around
forever
the
application
protocol
stuff.
I
don't
know
why
we
did
it
that
way.
C
A
C
Well,
so
if
they're
fields,
when,
let's
say
you
know,
this
gets
up
to
a
thousand
members
right,
the
fields
means
that
the
type
initializer
has
to
go,
build
all
thousands
of
them
before
any
of
them
can
get
used.
A
C
In
this
case,
they're-
probably
just
reading
off
of
the
the
read-only
memory
to
the
code-
page
initialized
data,
so
it's
probably
very
cheap,
but
the
more
public
read-only
field,
there's
public
static.
Read-Only.
You
have
like
that.
Just
slows
down
your
your
type
load
and
if
you
have
them
all
as
lazy
properties,
then
you
can
do
them
as
properties
that
are
initialized
in
the
initializer.
And
then
once
you
see
that
that's
a
perf
problem,
you
can
start
moving
them
to
lazy,
initialize
right.
C
Right
yeah,
I
know
when
we
were
revising
the
guidelines,
this
sort
of
came
up
because
there's
like
known
colors
or
something
that's
not
an
enum,
and
there
was
an
example
in
the
book
talking
about
static,
read
only
and
then
like.
I
even
gave
a
an
annotation,
that's
like
here
in
the
book.
We
call
this
static
read-only
in
reality,
they're
lazy,
initialized
properties,
because,
oh
my
god,
there
are
too
many
of
them.
D
D
D
Maybe
I
just
don't
want
you,
don't
you
don't
lazily
initialize
the
field,
you
have
the
field
act
as
a
sentinel
value,
and
then
you
have
the
instance
itself,
read
the
sentinel
value
and
do
initialization
in
the
constructor.
It's
it's
a
hack,
but
it
makes
it
cheaper.
If
you
have
lots
of
members
that
have
to
be
initialized
on
construction.
D
E
G
A
G
Disconnect
async
we
have
one
of
the
things
we're
trying
to
do
in
6.0
is
is
make
sure
we
have
the
complete
set
of
apis
in
socket
in
terms
of
all
the
everything
has
a
task-based
version.
Everything
has
span
and
memory
versions
and
cancellation,
token
etc.
So
this
is
a
small
gap
that
exists
today.
We
have
old
style,
async
and
sync
versions
of
disconnect,
but
not
a
task
base,
so
this
is
simply
add
the
task
base.
I
I
think,
if
you
scroll
down,
there's
an
updated
proposal.
G
C
Is
the
cancellation
token
not
defaulted?
It
should
be
we're
right.
J
C
And
I
forget
how
socket
extensions
works
how's
this
supposed
to
work.
J
It's
a
type
that
we
added,
I
think
so
we
could
have
a
nuget
package
for
task
compat
with
framework
we've
actually
talked
about
it
in
this
group
before
and
in
the
networking
team
of
just
not
using
the
socket
task,
extensions
anymore
and
putting
things
directly
on
socket.
We
might
consider
doing
that
here.
C
Okay,
so
this
was
a
a
thing
that
came
up
for
well,
that
fx
was
still
an
open
api
ecosystem.
A
C
B
B
To
bring
through
an
issue
in
the
near
future
to
add
everything
from
socket
task
extensions
to
socket.
I
think
it's
worth
kind
of
like
going
ahead
with
this,
but
kind
of
with
the
note
that,
should
we
decide
to
move
everything
from
the
soccer
test,
such
as
the
socket
in
this
release,
we
move
this
one
and
delete
it
from
socket
task
extension.
So
we
don't
ship
yet
another
obsolete
method.
C
Yeah,
I
think
that's
a
good
yeah
task
extension
should,
if
it's,
if
all
that
stuff's
being
moved
to
sockets,
then
it
should
ship,
exactly
as
it
did
in
five
like
remove.
G
A
J
C
A
D
A
few
other
notes,
the
this
parameter
should
be
named
socket
to
be
consistent
with
the
other
members
on
this
type.
Also,
this
should
return
value
task
instead
of
test
to
be
consistent
with
the
other
members.
On
this
type
I
mean.
D
Non-Generic
value
task
correct:
it
actually
depends
on
the
api.
C
Yes
right
well
right
so
I
mean
the
the
guidelines
and
since
steve's
here
he
can
say
if
he
disagrees
with
what
he
had
me
write
in
the
book
is:
if
it
is
not
generic
and
you
don't
absolutely
100
need
to
do,
I
value
task
completion
source.
Then
you
should
use
task
instead
of
value
task.
D
B
So
sorry,
most
pretty
much
all
the
methods
that
we've
added
here
after
value
tasks
existed,
have
been
returning
value
tasks
and
for
two
reasons
that
I
think
make
it
such
that
it's
not
an
exemption
to
the
book
guidelines,
and
that
is
one.
These
are
generally
disconnected
sync,
maybe
not
so
much,
but
these
are
generally
hot
path.
You
know
high
performance
apis,
two.
B
They
are
generally
expected
to
be
awaited
directly,
rather
than
using
continuity
or
blocking
on
them,
since,
if
you're
using
these
you're
generally
trying
to
write
sort
of
a
high
throughput,
asynchronous
scalable
server-
and
I
don't
know
if
I
said
two
or
three-
but
the
third
reason
is
we-
these
are
actually
ones
where
we
we
do
use
ice
high
value
test
source
under
the
covers.
B
If
you
look
at
like
the
send
and
receive
async
ones,
they're
using
a
custom,
socket
sync
event:
arms
that
itself
implements
the
right
interfaces,
and
then
we
just
reuse
that
instance
over
and
over
for
all
these
operations,
disconnect
async
is
a
little
odd
in
that
you
generally
use
it
once,
although
on
windows,
you
could
here
use
it
multiple
times,
but
we
even
in
cases
like
that,
like
connect,
we,
even
though
you
generally
only
use
connect
once
we
take
the
same,
socket
async
event,
args
that
was
used
for
the
kinect
and
then
we
reuse
it,
for
which
is
the
backing
for
its
value
task.
B
B
C
B
The
problem
with
the
steve
rule
is:
it
depends
on
how
steve's
feeling
in
any
given
day,
but
today,
I'm
doing
doing
very,
very
value-task-centric.
So
do
it
does.
D
A
B
C
J
B
I
think
we
should
not
only
keep
adding
the
defaults
but
go
back
and
add
defaults
to
places
that
it
makes
sense.
F
A
All
right,
then,
that
one
is
done,
is
mariam
on
the
call
she
is
then,
let's
maybe
do
this
one
here
so
she's
not
waiting
for
eternity
here.
H
Yeah.
Okay,
sorry,
I
was
muted
cynthia
and
I
were
looking
at
this.
The
two
issues
that
you
have
listed
and
just
commented
on
the
issue,
and
I
don't
think
it
would
be
kind
of
it
would
probably
won't
be
api
approved.
Today
I
mean
there's
a
bunch
of
things,
there's
a
little
kind
of
exploration
that
needs
to
be
done
before,
like
there
is
a
certain
risk
for
adding
this
insert
api
into
extensions
configuration
and
I'll
I'll
go
through
that
I'll
start
over.
H
So
basically,
what
the
ask
is
here
is
that
for
us
to
be
able
to
insert
key
value
pairs
like
in
a
configuration
values.
H
At
the
beginning
of
like
there's
different
ways
that
we
can
add
config
data
and
like
there's,
and
we
have
different
providers
and
extensions
like
command
line
environment,
variable
environment
through
command
line
through
environment
variables
and
others
or
like
in
memory,
and
when
we
have
a
combination
of
these
data.
H
What
the
ask
here
is
that
for
us
to
be
able
to
insert
in
the
front
of
the
list,
so
that's
why
the
api
is
called
insert
and
if
you
scroll
down
to
the
usage
you'll,
see.
H
A
bit
more
on
it,
so,
for
example,
it
says
if
insert
was
not
towards
the
end
of
the
after
the
code
blob,
it
said
if
insert
was
not
used
here.
Let's
say
adding
memory
collection
would
add
the
data
last
rather
than
what
they
want,
which
is
first,
but
what
needs
to
be
explored?
That
is
this.
H
A
H
Thing
that
there's
two
comments
on
it,
as
since.
H
So
david
had
a
comment
about
this.
Basically,
what
to
ask
here
is
that
when
you
have
configurations
you're
doing
configuration
setup
there's
if,
if
it's
not,
if
it,
the
validation,
happens,
so
the
we
use
microsoft,
extensions
configuration
and
then
like
on
top
of
that,
let's
say
there
are
libraries
like
espn
hosting
or
options,
but
then
configuration
itself
doesn't
make
sure
it
doesn't
have
apis
for
validation.
H
H
The
only
benefit
to
having
this
is
for
us
to
be
able
to
not
rely
on
startup
and
di
in
order
to
get
validation
on
configuration
so
like
the.
H
What
they're
asking
to
add
is
a
get
required
section
api
next
to
other
apis
such
as
get
section
and
get
section
where
it
does,
that
is
that,
like
it
will
give
you,
it
would
return
you
an
instance
with
default
properties
if
it
actually
didn't
find
them,
which
is
sometimes
not
ideal,
and
I
don't
think
I
I
can't
think
of
a
scenario
where,
like
this
is
not
not
having
this
api
is
blocking
and
that's
why
I
added
a
question
for
the
author
asking
what
their
specific
use
case
is
that
wouldn't
allow
them
to
have
use
existing
approaches
that
I
linked
so
same
same
kind
of
the
idea
I
had
was
probably,
as
you
said,
to
switch
this
to
api
needs
review
and
we
could
look
at
it
once
they
respond.
H
A
Yeah,
I
mean
that's
really.
I
guess
up
for
you
to
decide.
I
think,
like
the
you
know,
we
can
give
you
an
opinion
on
what
we
would
do,
but
I
think
the
general
idea
is
that
when
it
comes
to
api
suggestions,
like
you
make
the
determination
whether
you
feel
like
that's
a
good
api,
if
you
believe
it's
not
a
good
api,
you
should
totally
feel
entitled
to
just
reject
it
and
say
I
don't
think
it's
a
good
api
and
close
it
like.
A
If
customers
then
start
to
escalate
and
they
get
really
angry
or
whatever,
then
I
think
it's
fine
to
say.
Okay,
let's
take
another
look
at
this,
but
you
know
we
are
usually
like
I
mean
our
goal
really
is
to
just
review
the
apis
that
you
think
are
good
ideas
right.
So
if
you
think
it's
not.
A
I
mean
like
at
a
very
high
level.
I
think
the
idea
of
the
api
isn't
bad.
I
just
wouldn't
do
it
as
an
interface
extension,
but
that's
maybe
that
ship
has
sailed
on
extensions
anyway.
We
usually
would
do
these
things
as
extensions,
so
we
don't
break
people
who
implement
the
interface
and
it
seems
like
this
would
be
something
that
you
could
implement
all
the
existing
interface,
because
you
would
just
check
and
then
throw
presumably
right.
One
idea.
H
Yeah,
I
think
santia,
and
I
were
thinking
probably
if
there
is
a
there-
is
something
called
binder
options,
I'm
not
sure
exactly
if
it
would
yeah
actually
no
never
mind.
So,
as
you
said,
it's
not
gonna
be.
It
would
be
a
breaking
change
to
have
api
editions
like
this
right.
So
yeah.
A
A
I
don't
know
enough
about
validation.
I
think
followers
argument
here
is
also
that
these
are
independent.
Things
like
one
of
them
is
just
giving
you
access
to
the
data
and
then
there's
this
whole
other
thing
that
they
have
an
asp.net
right
with
options
which
I'm
not
actually
familiar
with
it
anymore
but
like
where
understand,
is
a
configuration
just
an
abstraction
over
the
storage,
and
then
options
was
the
thing
that
gives
you
like
a
strongly
typed
thing
for
that,
or
I
think
they
can
also
monitor
for
changes
and
stuff,
and
I
think
what
he's.
E
A
H
And
to
your
point,
the
options
which
does
helps
with
validation,
already
kind
of
covers
the
scenario,
and
probably
what
david
said
is
that
like?
That
is
something
that
happens
at
startup.
Unless
someone
wants
to
do
validation
with
pride
before
startup,
but
we'll
see
what
they
think,
what
what
their
response
is.
But.
A
A
Because
it
looks
very
familiar
okay,
then,
let's
just
do
the
same
thing
here.
Let's
just
say
this
is.
A
E
So
the
idea
here
is
that,
if
an
invocation
of
the
s
parallel
method
is
found
by
an
analyzer,
and
we
detect
that
the
previous
concatenated
invocations,
where
other
link
queries
like
select
or
where
we
should
suggest
to
move
the
as
parallel
invocation
to
the
first
position-
and
there
are
two
cases
for
this-
one
is
a
for
each
and
the
other.
One
is
when
saving
the
return
value
into
a
variable
and
there's
a
very
good
summary.
E
E
So
I
thought
that
this
could
be
split
into
the
two
cases.
One
is
when
you
find
it
when
the
analyzer
finds
this
case
in
the
forage
and
the
other
one
when
it's
found
anywhere
else,
and
we
can
decide
if
we
want
one
case
to
be
addressed
and
the
other
one
not
or
if
we
want
both
to
be
approved
for
the
analyzer.
A
Yeah
to
me,
this
kind
of,
like
I
think,
analyzer-wise,
it's
kind
of
up
for
you
to
decide
how
you
want
to
implement
this.
I
think
the
the
question
for
us
is,
I
guess,
more
about
whether
they
should
have
independent
diagnostic
ids.
That's
really
the
decision
point
for
the
user
experience
right,
because
if
you,
if
you
I
mean,
if
you
implement
them
as
one
analyzer,
you
can
still
have
that
different
diagnostics
ids
that
you
erase
from
name
from
from
these
cases.
A
My
personal
take
is
that
things
that
are
closely
related
like
these
ones,
I'm
fine
with
saying
they
have
the
same
diagnostic
id
like
the
question
really
becomes
like.
Would
you
suppress
one
but
not
the
other?
And
if
the
answer,
if
you
can't
come
up
with
a
case
where
you
would
do
that,
it
seems
like
having
them
in
the
same
id
makes
sense,
because
you
would
treat
them
as
the
same
thing.
A
I
don't
know
enough
about
the
rosin
fixer
infrastructure
to
see
whether
they
will
constrain
your
ability
to
fix
stuff
in
an
easy
way,
because
I
think
my
understanding
is
that
sometimes
when
you
register
a
fixer,
you
basically
say
I
only
fix
this
id
and
then,
if
the,
if
the
fixer
is
drastically
different
between
the
two,
there
might
be
some
benefit
of
having
different
ids
as
well.
But
you
can
probably
handle
that
either
way
would
be.
My
guess
I
mean
it
seems
like
a
reasonable
fix.
Sorry,
reasonable.
C
But
my
recollection
from
when
working
on
an
analyzer
is
that
manish
said
that
the
the
tool
tip
will
pop
up
if
any
analyzers
or
any
fixers
say
that
they
can
respond
to
this
diagnostic
and
then,
if
it
has
no
fix,
then
you
get
this
weird.
I
have
a
fix
for
you.
No,
I
don't
experience
so
I
I.
B
B
The
move
it
earlier
only
applies
if
there
were
operations
before
it
that
made
sense
to
move
to,
but
since
at
least
one
of
them
is
always
valid,
I
think
they
could
be
the
same
diagnostic
id
and
then
the
fixer
that
moved
it
earlier
would
just
not
offer
itself,
but
the
one
that
would,
but
the
one
that
was
for
removal
would
always,
I
think,
the
user
experience
would
be
fine.
I'd
suggest
fixers.
C
That's
the
where
you
get
the
lightning
bolt
or
the
lightning
bolt
the
light
bulb,
and
then
you
click
on
the
thing
and
it's
like.
Oh
nope.
I
actually
evaluated
that
thing
since
you
hit
the
fly
out
and
it
says
they're.
Actually
this
no
longer
applies
and
then
the
light
bulb
immediately
comes
back
because
you've
closed
the
light
bulb.
C
B
C
Because
the
again,
my
recollection,
the
fixtures,
have
titles
and
when
you
hit
the
light
bulb,
it
has
the
flyout
of
like
oh
here's,
this
title
of
a
fixture
that
you
can
run
and
then
you
hit
the
fix
and
it's
like
yeah.
It
didn't
actually
apply.
A
Well,
I
think
they
run
the.
I
think
what
ends
up
happening
is
the
light
bulb,
meaning
the
the
just
a
small
pop-up
that
you
can
click.
I
think
only
appears
when
any
analyzer
says
I
have
a
fixer
for
this
diagnostic,
but
as
soon
as
you
invoke
the
light
bulb,
I
think
the
analyzers
run,
and
so
basically
in
in
the
in
the
bad
user
experience
you
just
end
up
with
an
empty
menu,
but
as
soon
as
titles
show,
I
think
they
already
ran
and
decided
that
they
are
applicable
right.
B
A
C
C
C
C
Sorry,
what
was
the
question
jared?
So
if
you
have
a
a
so
select
where
as
parallel?
Obviously
you
did
that
wrong,
yes
select
as
parallel,
where
is
that
obviously
wrong?
No
right,
so
the
analyzer
only
wants
when
that's
parallel
is,
is
the
terminal
statement.
B
So
with
that,
that
is
one
valid
approach.
I
think
that
would
be
fine
there.
We
also
could
potentially
imbue
the
analyzer
with
some
knowledge
of
what
p
link
is
capable
of,
for
example,
if
it's
as
parallel
dot.
Two
array
end
then
there's
nothing
that
the
az
parallel
can
do
for
that
two
array:
that's
our
or
two
list
or
one
of
them.
I
forget
which
it
is
so,
but
I
think
we
we're
better
off,
starting
with
the
former
case
and
only
selectively,
adding
in
anything
from
the
latter
case.
If,
if
it's
meaningful.
C
And
it
and
again
just
thinking
through
things
so
mainly
carlos.
This
is
your
unit
test,
matrix
that
it's
fine
to
be
the
terminal
thing
in
a
statement
as
long
as
it's
being
assigned
to
a
parallel,
queryable
or
whatever,
though.
B
I
think
I
think
it
should
be
restricted
purely
to
four
reaches,
because
the
moment
you
assign
these
things
to
variables,
you
can
tack
on
additional
stuff.
Subsequently,
I.
B
Well,
no,
no!
It's
based
on
type
identity.
B
So
so
you
in
fact
there's
a
link.
P
p
link
has
an
as
sequential
operator
in
addition
to
as
parallel
and
all
it
does
return
this,
as
I
enumerable,
basically
nice,
so
yeah
I
mean
potentially
it
could
detect
that.
Your
to
your
point,
jeremy,
you
could
detect
that
case
as
well.
If,
as
parallel
is
being
assigned
into
an
eye
innumerable
it
could
detect
that
too,
I
guess.
E
I
think
messages
are
it's
just
an
implementation
detail.
We
can
decide
depending
on
how
we're
going
to
solve
the
problem.
If
it's
going
to
be
one
idea
or
two,
so
it
doesn't
matter
much
the
messages,
maybe
to
jeremy's
point.
We
should
make
sure
that
we
mention
that
it's
in
a
terminal
position,
but
what
matters
more
is
the
severity
yeah.
Is
it
something
that
we
need
to
decide
here.
E
Okay,
so
we
did
we've
suggested
to
use
a
severity
warning
in
my
comment:
would
that
make
sense.
A
A
C
Yeah,
I
mean
error
doesn't
seem
justified.
Warning
seems
reasonable.
A
C
C
B
I
mean
this
is
arguably
a
perf
fix.
However
you're
using
an
api
specifically
focused
on
improving
you
believe.
It's
improving
your
perf,
so
like
api
is
where
we
say
use,
you
know,
string
dot
index
sub
instead
of
string,
dot,
com,
compare
or
vice
versa-
and
we
say
that
better
for
perf
but
like
you
may
not
have
cared
about
perp.
So
we
really
shouldn't
treat
that
as
a
warning.
That's
really
just
a
suggestion,
but
here
you're,
obviously
caring
about
that
domain,
and
so
I
think
and
you're
doing
it
wrong.
B
A
C
But
this
is
yeah,
I
mean
the
category
listed
in
the
top
suggests
reliability,
but
I
think
performance
is
a
category
and
that
probably
more
appropriately
applies
like
there's.
Nothing
like
calling
this
api
has
no
impact
on
the
reliability
of
your
program.
It's
just
you.
You
added
an
object
creation
that
you
didn't
need.
A
A
Correctness,
though,
would
still
imply
that
the
user
would
see
different
results
right
as
you
like
you're
computing
you're,
calling
apis,
we
kind
of
know
what
you're
looking
for,
but
the
way
you
call
the
api
will
give
you
the
wrong
result.
This
one
will
not
give
you
the
wrong
result.
It
would
just
not
perform
in
the
way
you
expect
right.
So
I
guess
performance
would
still
be
fair
as
the
category.
C
Yeah,
so
when
we
say
warning
do
we
expect
this
to
be
using
the
whatever
we
call
waves
or
that
this
is
just
on
in
the
next
version
of
the
package.
A
So
my
understanding-
and
that
is
something
that
I
I
probably
should
double
check,
but
the
way
I
understand
the
setup
right
now
is
that
basically,
everything
that
has
a
separate
id
can
be
decided
to
be
in
or
out
based
on
tfm.
So,
basically,
it
means,
if
you're
in
dot
net
five
given
that
is
a
net
new
id
it
wouldn't
show
up
until
we
manually
decide
to
do
that
and
by
default
we
generally
wouldn't
right.
C
Thought-
and
I
could
be
wrong
that
whatever
we
write
in
in
the
class
itself
as
what
its
default
is,
is
what
happens
unless
we
change
that
in
config.
So
the
default
is.
If
we
write
that
it
is
warning,
then
it's
warning
and
then
it
applies
to
all
to
anywhere
that
can
find
the
appropriate
members
and
if
it's,
if
we
want
it
off
by
default,
I
think
that
means
we
have
to
encode
say
its
default
is
none
or
ide
suggestion
and
then
edit
the
config
file
to
say
that
for
netsix,
it's
warning.
A
I
mean
you
probably
know
more
about
the
infrastructure
than
I
do
like.
If
that's
the
case,
it
seems
kind
of
busted,
though,
because
it
means
you
basically
have
to
moving
forward,
configure
everything
in
the
file
somewhere,
because
I
mean,
unless
you
can
say
analyze
it.
This
is
applicable
to
this
tfm,
which
I
don't
think
you
can.
So
that
means
the
default.
A
C
C
Does
apply
to
existing
code,
and
so
if
we
wanted
the
tfm
model,
then
we
just
need
to
make
sure
that
that
what
we're
saying
is
it's
warning
with
net
six
or
higher
yeah.
A
A
A
A
A
Yeah-
I
wouldn't
do
this
for,
like
I
guess
I
mean
you
could
probably
do
it
prognostic,
but
I
would
more
like
have
a
generic
case
that
detects
that
oh,
we
shipped
five
with
500
warnings
on
or
500
diagnostic
ids
on.
Can
we
just
check
the
ids
and
say:
oh
yeah,
you
have
one
test
that
says.
Oh
sorry,
you
just
edit,
you
know
these
five
diagnostic
ids
or
these
five.
A
I
guess
the
question
is
not
yeah
the
ideas
you
would
say
these
analyzers
are
considered
on
and
they
weren't
considered
on
before
right
instead
of
running
them
all
you
would
just
statically
determine
that
there's
more
analyzers
in
scope
than
before
and
failed
that
one
that
seems
more
like
a
reliable
test.
Otherwise
it's
a
per
diagnostic
test
case.
Everybody
has
to
remember
doing
right.
I
C
A
A
F
Can
we
go
with
tracing
one?
Oh.
L
One,
it
was
already
the
one
at
the
top
good
for
you
do
you
want
to
talk
about
it
then
derek.
F
Yeah
sure,
if
you
go
down
a
little
bit
more
yeah,
there
is
a
comment
for
me
down
there.
Yeah.
F
F
Yeah,
here,
okay,
so,
basically
in
in
five
release,
we
have
exposed
the
new
ebis,
which
is
activity
source
and
it
had
method
method
is
called
start
activity,
which
is
have
a
couple
of
overloads
there,
and
one
I
mean
the
first
parameter
of
our
overload
is
always
the
name.
The
name
of
the
activity
is
that
if
you
want
to
create
a
new
tracing
activity,
so
you
have
to
give
it
a
name.
So
we
got
the
scenario
recently
about
like
we
will
need
to
to
have
the
caller
member
name
on
the
on
the
name
parameter.
F
So
they
don't
have
to
provide
the
name
and
they
want
to
get
the
caller
name
instead
automatically,
and
we
looked,
and
it
looks
like
this
will
be
like
kind
of
common
scenario
I
mean,
like
will
be
common
scenario.
We
will
start
using
it
like
across
across
different
components,
and
that
I
mean
like
it
would
be
helpful.
F
So
if
you
see
about,
like
you
know
in
the
top
of
my
comment,
we
have
these
two
overload,
which
is
we
currently
have
today,
and
the
proposal
is
for
the
first
overload.
We
will
just
add
the
caller
member
name
attribute
to
the
name
parameter,
so
we
it's
just
adding
the
attribute.
Only
to
this
to
this
signature,
I
talked
offline
with
with
the
jeremy,
and
we
believe
that,
because
we
don't
have
any
other
overloads,
that
takes
a
default
name
barometer,
so
this
shouldn't
be
a
breaking
change.
F
F
I
mean
like
activity
kind
and
we
are
proposing
the
second
extra
overload,
which
is
at
the
bottom
of
my
comment
here,
is
adding
this
overload
and
last
parameter.
It
will
be
as
a
string
name,
which
is
defaulted
with
the
caller
member
name
attribute.
F
So
that's
that's
the
proposal
so
to.
In
short,
I
mean
like
we
adding
just
attribute
to
one
of
the
existing
overloads
and
we're
adding
extra
overload
here.
E
F
C
F
Yeah
I
mean
parent
id
is
not
I
mean
like
it's
not
common
scenario.
Now
I
mean
we
are
trying
to
promote
the
activity
context
so.
F
A
So
it
also
seems
to
me
like
in
your
overall,
you
suggest,
parent
context
and
links
would
have
to
be
optional
as
well
right.
They
have
to
be
nullable
because
you
initialize
them
to
default,
otherwise
it
doesn't
make
sense.
F
F
F
A
F
A
Yes,
I
see
I
see
so
that
means
people
can
now
call
start
activity
without
passing
any
arguments
which
they
couldn't
before
they
would
before
they
would
they
would
they
could
call
one
with
only
passing
in
the
name.
We
would
make
that
optional
as
well.
B
F
C
Yeah
and
yeah
and
moving
it
to
being
the
last
parameter,
makes
sense
to
me.
If
we
do
expect,
the
overwhelming
majority
of
people
just
want
the
method
name,
because
that
way.
Now,
if
they
wanted
the
kind
in
the
parent
context,
they
don't
need
to
skip
over
the
the
name
parameter.
So
they
don't
need
to
use
the
name
parameter,
invocation,
syntax.
L
C
C
A
A
I
mean,
as
usual
as
as
reasonable
as
apis
to
take
like
12
arguments
are
but
yeah.
L
A
B
Of
mod
initializer
yeah,
so
can
you
hear
me
yep,
yep?
Okay,
we
added
a
new
feature
in
c
sharp
nine
that
lets.
You
declare
module
initializers,
which
have
always
been
supported
by
the
time,
but
they
were
impossible
to
sort
of
use
without
complicated
techniques.
B
Now
you
can
just
slap
module
initializer
on
your
static
method
and
it
becomes
one,
but
it's
become
clear
from
a
variety
of
discussions
that
we
would
not
advocate
this
for
being
used
in
general
libraries
and
in
particular
we
would
want
this
across.net
runtime
to
prohibit
people
like
me
from
accidentally
adding
these.
B
A
B
In
general
purpose
libraries,
the
problem-
is
you
end
up
with
you're
sort
of
subject
to
the
whim
of
the
run
time
as
to
when
these
run,
and
so
you
end
up
with
potential
ordering
issues
between
multiple
libraries
and
kind
of
yeah.
There
are
alternatives.
You
can
do
lazy,
initialization
with
static
constructors
and
things
like
that.
So
for
application
level
concerns
these
can
make
complete
sense,
but
for
library
concerns
we
and
I'm
using,
we
sort
of
liberally,
don't
don't
believe
in
them.
A
B
A
B
Sense
for
use
in
source
generators,
you
know
an
app
is
using
a
source
generator
to
spit
some
code
and
wants
some
other
stuff
to
run
when
the
app
loads
can.
B
K
The
compiler
emits
a
single
module
initializer
that
calls
all
of
the
annotated
methods
in
the
order
that
it
parsed
them,
which
is
generally
the
order
that
in
modern.net
sdk
product
projects
will
be
alphabetical
order.
K
But
that's
no
different
than
the
declaration
ordering
issues
with
static
field
initializers
across.
A
K
K
Yeah,
it's
it's
deterministic,
but
it's
technically
an
implementation
detail
in
what
order
that
a
compiler
decides
to
emit
them.
Some
other
implementation
of
the
compiler
could
decide
to
not
do
it
in
parse
order.
For
example,
I
was.
B
E
B
To
me
like
two
people
using
this,
and
maybe
they
should
know
what
they're
going
you
know
what
they're
in
for
so
I
don't
know,
I
don't
have
a
strong
opinion.
It
definitely.
K
B
Yeah,
you
have
the
option
analyzers
to
say
whether
it
applies
to
generated
code
or
not.
I
I
assume
we
would
turn
that
off.
C
K
In
which
case,
I
would
think
that
it's
fine
to
just
have
it
on
by
default
and
the
you
know,
unity
and
other
authors
that
are
probably
going
to
use.
This
can
just
disable
it
as
an
explicit
opt-in
to
I
want
to
use
initializers.
I
understand
the
the
issues
in
this
linked
document
et
cetera.
I.
A
C
Yeah,
I'm
good
with
warning
by
default
and
if,
if
there's
you
know
too
much
pushback
on
that,
then
I
would
think
a
warning
of
you
have
two
of
them
in
the
same
compile
unit
no.
C
C
So
yeah
definitely
two
plus
feels
like
a
warning
to
me
that
gets
weird
with
generated
code,
because
the
question
is
which
one
did
you
find?
First,
the
so
yeah.
I'm
I'm
happy
with
warning
by
default,
because
it's
a
it's
a
power
feature
and
the
people
who
would
want
to
use
it
know
how
to
turn
off.
A
A
C
Yep,
so
we
added
some
methods
at
the
end
of
five
for
making
it
easier
to
create
certificates,
specifically
from
where
you
have
a
certain
one
file
and
a
key
and
another.
C
And
then
someone
came
up
with
the
use
case
after
it's
too
late
to
put
it
in
five
that
if
they
have
a
certificate,
that's
pim
encoded
and
they
don't
care
about
the
key.
C
And
it's
already
loaded
in
as
a
string
that
I
mean
all
they
have
to
do
is
run
it
through
utf-8
get
bytes
or
ascii
get
bytes,
but
that's
not
obvious,
and
since
we
already
have
the
create
from
pim
method
family,
then
the
suggestion
is
add
create
from
pim
that
reads,
a
string
like
and
since
the
create
from
pims
that
we
added
that
read
the
string,
likes,
didn't
also
add
string.
This
one
doesn't
add
string.
C
So
it's
a
overload
to
an
existing
method.
The
existing
one
takes
a
cert
pim
and
to
keep
him
and
it
fails
if
it
can't
find
a
key
across
the
two
of
them.
This
one
does
not
throw
if
it
can't
find
a
key.
In
fact,
it
won't
look
for
a
key.
A
C
Yeah
and
actually
I
think,
the
current
one
cert
the
cert
pin
parameter,
it
will
only
look
for
the
certificate,
keep
him.
It
will
only
look
for
the
key
and
when
you
open
it
from
a
file,
it
passes
the
the
same
buffer
into
both
unless
you
gave
two
files.
So
so
we
don't
need
to
create
from
file
on
this
one,
because
it
honestly
it's
too
complicated,
so
cool.
C
And
create
from
pim
file
at
the
end
of
five
create
from
pem,
which
is
the
you
already
have
it
in
memory.
It
takes
cert
pim
and
the
keep
him
and.
C
Well,
it's
it's
adding
one
that
gets
rid
of
the
key
parameter.
So
just
the
cert
I
see
and
now
we'll
find
that
if
hemo
has
updated
this
or
not.
A
A
C
A
C
A
C
And
here
let
me
pretend
to
be
emo
yeah.
It's
crypto.
C
I
need
some
slightly
more
german
vowels,
but
otherwise
I
I
think
I
captured
emo's
care
level.
G
C
Awesome
as
part
of
spanification,
do
you
also
want
an
overload
that
takes
file
name
as
rosh
char,
or
is
that
not
reasonable
in
context.
G
I
didn't
even
consider
it,
I
suppose
we
can
consider
it.
J
C
I
asked
the
question
I
was
just
glancing
across
and
it's
like
we're
spanifying,
I'm
like
where
we
span
it
says
string.
C
A
C
A
D
Where
are
we
so
I
want
to
find
anything
other
than
a
space
or
anything
other
than
a
comma
stuff,
like
that,
it's
if
you're
implementing
something
like
a
really
naive
or
really
domain
specific
trim
function.
Something
like
this
could
be
useful
because
you
would
say
I
I
want
to
find
anything.
That's
not
a
as
I
mentioned
earlier.
I
want
to
find
anything.
That's
not
a
literal
space
character.
Just
like
tell
me
where
the
index
of
anything
not
of
space
is
not
of
any
is
similar.
D
It's
I
don't
want
a
or,
b
or
c.
I
want
anything
else
other
than
those
this
is
there
would
be.
There
would
be
no
linguistic
overloads
of
this.
Everything
here
would
be
ordinal,
so
there
would
be
no
equivalent
of
like
string
comparison,
dot,
invariant
culture
that
you
could
pass
in,
because
that
operation
just
doesn't
make
sense.
With
this.
D
J
D
There
is
not,
and
that
was
actually
one
of
the
one
of
the
things
that
was
brought
up
in
the
comments
here.
I
think
this
is
more
of
a
nice
to
have
for
libraries
that
might
that
might
have
written
such
code
themselves,
but
within
the
framework,
I
don't
think
we
have
much
use
for
it.
C
D
And,
to
be
honest,
there
was
a
discussion
in
the
in
the
issue
here
where
I
had
actually
advocated,
not
cindy
accelerating
it,
because
I
think
in
the
majority
of
cases
it
will
actually
terminate
early
all
right,
but
yeah.
A
D
A
I
think
my
concern
with
these
apis
is
like
ignore
the
naming
it's
just
like.
I
think
we
go
down
this
path
of
like
now
exponential
combinations
of
these
things,
and
at
that
point,
memory
extensions
becomes
like
tanner's
intrinsic
apis,
where
we
have
like
six
word
combinations
of
things
right
where
it
seems
you're
chasing
the
you
know
more
and
more
unlikely
cases.
K
So
with
regards
to
accelerating
it
or
not,
I
think
that
we'd
want
to
even
if
it
does
terminate
quickly,
because
there's
no
real
cost
to
doing
that.
You,
you
have
one
additional
check
in
practice,
but
I
also
agree.
I
don't
think
we
want
a
huge
explosion
of
apis
here
and
I
imagine
that
every
one
of
these
will
possibly
expand
if
we
end
up
getting
the
ref
field
and
value
array
support
with
c
10.
D
Yeah
like
this,
maybe
this
could
be
an
example
of
something
the
community
could
do,
but
maybe
maybe
in
a
a
non-net
package,
but
I
mean
I
I
shouldn't
say
we
have
no
use
cases
in
the
framework.
We
have
very
limited
use
cases
in
the
framework
and
I
don't
think
the
number
of
use
cases
we
have
ourselves
is
sufficient
to
justify
this
work.
But
there
is,
you
know,
a
potential
that
this
could
be
useful
to
third
parties
and
because
we
provide
building
blocks,
should
we
consider
providing
this
building
block.
D
K
I
do
think
the
knot
case
is
useful
for
some
scenarios,
particularly
with
buffers
where
you're
wanting
to
find
the
first
character
that
doesn't
match
something
else.
For
example,
you
might,
you
might
have
sparse
data,
for
example,
where
you
have
a
number
of
indices
set
to
negative
one,
and
you
want
to
find
the
first
non-negative
value
to
find
the
first
actual
entry.
You
want
to
work
with.
D
K
K
Maybe
it's
something
that
we
could
not
ship
as
part
of
the
framework,
but
maybe
this
is
one
of
those
cases
where
it
might
be
a
good
community
managed
project
which
contains
a
bunch
of
cmd
accelerated,
sort
and
search
functions
for
things
like
span
and
array,
because
I
don't
think
there's
anything
preventing
a
a
user
from
implementing
these
functions.
D
D
Earlier
example
like
I,
I
would
probably
get
value
out
of
a
function
which
was
give
me
the
first
index
of
any
non-negative
number
from
this
array,
which
would
also
handle
sparse
arrays.
Presumably.
D
Correct
and
that's
why
I'm
wondering
like
if,
if
we
actually
had
scenarios
for
stuff
like
that,
would
those
kinds
of
apis
be
more
useful
than
an
api,
which
is
give
me
the
first
thing?
That
is
not
this
exact
element
like
do
we
actually
open
the
door
to
a
wider
variety
of
things,
just
working
out
of
box
if
we
provided
those
other
apis
instead
of
us,
maybe,
but
because
we
don't
have
that
list
of
scenarios
off
hand,
I
don't
think
we
can
consider
it
here.
A
A
I
don't
think
you
would
use
that
for
sparse
or
raised
necessarily
like
the
example
that
ben
provided
was
clearly
parsing
right
because
he
was
looking
for
white
space
or
something
or
the
first
non-white
space.
I
guess
yeah.
B
D
B
Noticed
this
is
the
list.
The
one
case
that
I
can
think
of
in
the
framework
falls
into
that
category
and
that's
within
regex
like
when
you
say
you
know
when
there
are
loops
that
are
basically
fine
fine
consume
everything
of
the
following
thing.
Until
you
find
something
that's
not
and
so
like.
If
you
have
slash
s
or
you
know
white
space
star,
you
need
to
find
the
first
thing.
That's
not,
and
so
we
would.
You
know,
I
think,
that's
like
we
would.
E
B
A
D
Yeah-
and
this
was
also
discussed
in
the
issue
here-
we
would
not
write
string
doctrine
based
on
this
because
string.trim
we,
we
have
other
performance
tricks
that
we
do
in
order
to
make
that
fast,
and
we
have
assumptions
on
how
most
strings
are
generated,
that
this
would
not
be
able
to
do.
In
the
general
case.
K
Yeah,
I
I
think
realistically,
this
just
falls
into
the
category
of
the
implementation
is
trivial.
Unless
you're
wanting
a
performance
implementation-
and
in
that
case
it
might,
I
think
it
falls
into
the
general
category
of
general
array
operations
which
might
need
their
own
library.
C
A
Mean
honestly,
I
wouldn't
even
encourage
a
user
to
find
library
for
this.
I
would
just
say
this
is
not
a
good
candidate
for
the
bcl.
If
somebody
else
wants
to
do
it,
they
can,
but
I
don't
even
want
to
be
in
the
business
of
like
partially
api,
reviewing
some
community
editions
unless
we
have
an
actual
model
for
this.
A
I
mean
I
mean
both
to
me,
corefx
lab
and
runtime
kind
of
imply
that
there's
the
graduation
path
right
and
if
we
feel
like
we
don't
want
to
have
this
in
the
product.
I
would
honestly
just
say
good
idea,
but
sorry,
no,
I
mean
like
if
enough
people
say
this
is
useful
right.
We
might
change
our
mind,
but
I
think
at
this
point
knowing
ben,
I
would
say
it's
a
very
specialized
use
case
and
sure
at
the
surface
it
doesn't
look
bad,
but
I'm
I'm
not
convinced.
A
A
Let's
do
the
same
one,
all
right
and
that's
the
same
final.
It's
probably
eric
right,
yep,
let's
close
this
one,
okay!
So
then.
K
So
this
one's
pretty
simple,
some
hardware
provides
specialized
operations
for
performing
the
reciprocal,
so
one
over
x
or
one
over
or
or
estimating
the
square
root
or
one
over
the
square
root
of
x,
and
so
this
is
just
proposing.
We
expose
an
official
api
under
math
that
allows
users
to
easily
consume
these.
It's
not
guaranteed
that
it
would
be
an
estimate.
Some
platform
could,
for
example,
decide
to
implement
it
just
as
one
over
x,
but
on
our
hardware
that
does
provide
it.
K
We
would
just
invoke
down
into
that.
K
A
K
A
D
K
D
A
I
mean
I'm
kind
of
confused
like
to
me
if,
if
the,
if
the,
if
the
provided
functionality
is
never
slower
than
what
you
would
do
normally
I
think
it's
fine
and
then
the
problem
with
vector
was
that
if
you,
if
you
write
a
vectorized
code,
the
code
you
write
is
extremely
different
right.
So
the
software
fallback
is
sometimes
like
2x
or
3x
slower
than
what
a
naive
loop
would
have
been
if
it's
not
accelerated
right,
but
it
seems
in
this
case
you
do
one
divided
by
x.
A
A
K
A
D
D
A
A
I
think
that
to
me
I
would
like
to
avoid
this
whole,
like,
let's
add
a
boolean
summary
that
says,
with
ex
whether
it's
accelerated
or
not,
because
then
math
will
become.
You
know
super
convoluted
right,
api
wise.
I
think
this
is
meant
to
be
a
one-stop
shop
if
you
really
care
about
the
performance
at
that
point,
yeah
you
used
intrinsics
yourself.
If
you,
if
you're
at
that
level
of
care,
then.
K
And
if
we
were
to
expose
such
an
api,
given
that
it's
potentially
extensible
in
the
future,
I'd
probably
propose
it
as
it's
a
method
that
takes
an
enum
and
therefore
the
jet
can
constant
fold
it.
But
we
don't
need
a
ton
of
surface
area.
We
just
have
to
add
new
enum
values
as
we
move
forward.
C
You
don't
want
cpu
flags
that
tells
you
what
what
things
are
supported.
You
want
has
cpu
flag
and
yeah.
D
Yeah
tedder,
is
there
a?
Is
there
a
like
math
h
for
half.
K
No,
there
isn't
and
that's
something
that
we
that
we've
had
the
previous
discussions
around
and
we
didn't
decide
whether
or
not
we
were
going
to
add
a
math
h
or
whether
or
not
we
were
going
to
move
methods
onto
single
double
half
or
things
like
that.
K
Part
of
that
being
that
we
weren't
sure
what
c
sharp
was
going
to
do
with
shapes
and
if
they
were
going
to
need
to
implement
new
interfaces
like
was
proposed
by
the
mono
team,
or
if
something
else
was
going
to
happen.
K
A
K
C
D
Okay,
are
we
going
to
pull
in
the?
What
was
it
john
carmack
arc
sign
function.
K
Math
f
is
just
it's
x.
It's.
A
X
everywhere,
so
then,
presumably
we
would
also
make
this
one
d,
then
for
simplicity
or
if
we
leave
this
as
x,.
K
A
C
A
K
There's
also
the
potential
you
could
theorize
we
ship
an
analyzer
that
says:
hey
we've
actually
renamed
the
the
parameter
in
reciprocal
estimate
from
x
to
value.
Let's
offer
a
code
fix
for
if
they
were
explicitly
calling
a
method
named
this
with
the
wrong
name,
then
offer
the
code
fix
to
fix
it
across
the
solution.
C
D
Right
tanner
follow-up
question
is
there?
Is
there
anything
that
needs
to
be
noted
with
regard
to
exceptions
interrupts
whatever,
with
these
apis.