►
From YouTube: GitHub Quick Reviews
Description
Powered by Restream https://restream.io/
A
B
I
don't
know
what
to
sing
so
with
that
cold
open
good
morning,
everyone
we
are,
as,
as
we
were
discussing
before
the
stream
started.
Still,
we
have
a
lot
of
red
issues.
B
C
C
Sharing
so
part,
one
was
all
about
when
you
were
type
target
typing
interpolation
to
strings.
You
know,
string
s
equals
blah.
C
This
issue
is
about
taking
advantage
of
the
syntax
to
do
other
stuff
that
you
couldn't
do
in
c,
sharp
prior
to
c
sharp
ten
and
I've
basically
outlined
three
additional
logically
three
additional
scenarios
to
support,
one
of
which
involves
adding
utilizing
the
existing
interpolated
string
builder,
that
we
did
in
part
one
and
augmenting
it
with
a
few
additional
public
apis
to
support
customization
of
interpolating
into
strings
and
then
two
additional
scenarios,
one
for
using
interpolated
strings
to
write
into
existing
spans,
so
you're
doing
your
own
formatting
into
spans,
and
the
other
is
using
interpolated
strings
to
append
to
string
builders.
C
So,
let's
kind
of
walk
through
them.
If
you
can
scroll
down
a
little
bit
jeremy,
so
we'll
start
with
writing
into
spans.
Today,
if
you
were
implementing,
you
got
a
type
like
struck
point
that
had
an
x
and
a
y,
and
you
wanted
to
implement.
I
span
formattable
on
it,
so
you
were
implementing
your
try
format
method.
You
have
to
write
code,
something
like
this.
C
Where,
first,
you
call
try
format
on
the
x
and
then,
if
it's,
if
it
fails,
you
return
false.
If
it's
successful
you
slice
to
the
remaining
portion,
and
then
you
test
to
see
if
there's
enough
space,
to
write
your
comma
space
to
separate
the
two
values.
If
there
is
you
you
copy,
then
you
increase
the
number
of
characters.
C
C
If
we
enabled
you
to
do
instead
write
the
one
liner,
that's
on
the
bottom
of
the
string,
which
is
try
and
write
this
interpolated
string
to
this
span
using
the
iformat
provider
and
getting
out
the
number
of
characters
written
and
we
could
enable
that
exact
syntax
by
providing
a
new
try
right
method.
That's
the
name!
I've
chosen.
We
could
come
up
with
a
different
name
and
a
builder
that
is
able
to
do
this
translation.
C
So
you
can
scroll
down
a
little
journey.
There
is
sort
of
a
public
facing
part
here
and
a
compiler
services
part
here
again.
This
is
all
some
of
this
is
up
for
modification,
and
some
of
this
is
required
by
whatever
the
pattern
is
the
compiler
requires.
C
So
we
expose
these
extension
methods
just
like
everything
else
on
memory,
extensions
that
operates
on
a
span
and
then
the
key
argument
is
the
interpolated
span
builder,
and
by
taking
that
in
the
place
where
we
have
interpolated
scan
builder,
we,
the
compiler,
is
you're
able
to
write
an
interpolated
string
and
then
the
compiler
does
all
its
magic
to
generate
usage
of
that
related
spam
builder
sorry
hold
on
one.
Second,
let
me
just
do
what
my
dog's
barking
about.
C
He
just
has
trouble
with
eyes
sorry
about
that.
He
was
stuck
outside
so
yeah.
So
then
we
have
this
interpolated
span
builder,
which
has
the
relevant
factory
methods.
These
would
potentially
become
constructors.
We're
having
that
discussion
with
the
c
sharp
folks,
but
either
factory
or
constructor,
that
takes
the
relevant
state,
gives
back
the
span
builder
and
then
the
same
exact
depend
literal
append,
formatted
methods,
as
we
saw
on
interpolated
string
builder.
C
So
the
real
thing
to
discuss
here
is
a
do
we
care
about
the
scenario
I
vote?
The
answer
is
yes
and
then
what
exact
overloads
with?
What
name
do
we
want
to
expose,
as
extension
methods
for
span,
I
have
suggested
we
have
two
overloads
one
that
takes
the
span
and
the
builder
and
one
that
takes
the
spanned
I
format
provider
and
the
builder
and
yeah?
That's
basically,
that's
basically
it
for
that.
C
D
Well,
that's
an
interesting
question.
Now,
isn't
it
we
are
still
having
this
debate.
This
particular.
C
B
Okay,
I
was
going
to
say,
which
is
why
it's
not
last,
maintaining
both
waterfall
parity
and
allowing
it
to
go
to
a
default
argument.
But.
C
You
look
at,
for
example,
string.format,
and
it's
got
overloads
that
take
the
format
and
then
the
object
arguments
and
it's
got
overloads
that
take
the
provider.
Then
the
format
and
then
the
object,
arguments
and
then
stringbuilder.pen
format
does
the
same
thing.
It's
got
overloads
that
take
the
format
and
the
arguments,
and
it's
got
one
that
take
the
provider,
the
format
and
the
arguments.
So
I've
mirrored
that
here,
which
happens
to
be
the
happy
path
for
not
having
to
discuss
when
the
arguments
come.
First
can
come.
Second.
D
Yeah
there
are,
there
are
a
couple
of
bcl
apis
that
are
going
to
be
a
problem
with
that
rule
of
putting
the
thing
before
the
putting
the
arguments
before
the
string,
namely
utf-8
formatter,
because
all
the
existing
try
write
apis
on
that
take
the
spans.
Second,
they
take
value
to
write
and
then
the
span.
So
if
we
wanted
to
do
this
for
utf-8
formatter,
it
would
have
to
be
well,
it
might
have
to
be
span
and
then
interpolate
a
string
value
which
is
different
from
the
rest.
That's.
C
C
A
D
The
the
the
way
I'm
doing
it
at
the
moment,
well,
the
way
I
will
currently
planning
on
implementing
it
is
the
order
in
which
it's
specified
in
this
in
this
attribute
is
the
order
in
which
they
will
be
specified.
There
will
be
a
value
like
so
it
say,
say:
provider
and
span
were
swapped,
but
they
weren't
swapped
in
the
method.
Signature
in
like
the
original
method
signature,
I
would
evaluate
them
in
lexical
order,
and
then
it
would
be
as
if
you
had
used
name
parameters
to
swap
the
order
of
those.
A
Yeah,
I'm
just
trying
to
get
a
sense
from
what
we
can
do
in
the
apis
and
how
much
like
how
strongly
the
the
the
builder
is
tied
by
the
language
rules.
But
it
seems
like
we
pretty
much,
have
arbitrary
flexibility
here.
We
can
have
any
order
of
arguments
on
the
method,
and
then
we
just
have
to
you
know,
have
the
correct
order
effectively
in
the
attribute,
which
I
think
is
perfect.
B
Where
else
would
you
put
it,
I
mean
it's
just
in
my
head,
it
said:
try
right
of
t
span
of
t,
and
I
don't
know
why,
because
that
wasn't
going
to
make
any
sense,
but
I
was
like
a
try
right
showing
up
on
all
spans
feels
weird,
but
it's
on.
H
I
And
what
what's
the
benefit
of
having
a
extension
on
span,
rather
than
calling
try
format
on
the
type
that
you're
actually
formatting?.
C
C
I
C
It
does
speak
to
the
name
that
I
chose
so
everywhere
else.
We
have
tri
format,
it's
you're,
basically
formatting
some
value
into
the
destination
span,
and
here
it's
logically
reversed
here,
you're
you're,
you're,
basically
calling
it
on
the
span.
You
want
to
format
into
and
you're
passing
in
the
thing
that
you
want
to
format.
C
A
B
B
D
B
I'm
just
looking
at
it
as
order
of
execution
and
and
when
are
things
happening,
and
when
did
the
work
happen
right,
so
it
the
from
the
method
perspective.
This
is
really
I
have
a
span.
I
have
a
builder,
that's
already
in
the
state
that
I
want
you
to
write,
or
that
already
represents
the
data
that
I
want
to
go
into
the
span
and
just
take
the
data
out
of
this
builder
and
write
it
into
the
span.
So
try
right
makes.
C
Sense,
oh,
that
is
an
active
discussion
and
we
we
plan
that
that's
actually
not
necessary.
So
I
there
are
some
things
that
I've
taken
some
liberties
with
here,
but
the
evaluation
of
x
and
y
are
pretty
close
to
the
position
that
I've
included
them
here.
So
if
appending
formatted
x
returned
false,
we
would
not
evaluate
y.
D
B
Right,
but
it's
thinking
of
the
try
right
method
of
of
ignoring
what
it
or
thinking
of
it
just
from
its
pure
implementation.
It
receives
a
builder
that
is
done,
so
it's
this
builder
already
represents
the
data
that
I
want
you
to
write,
or
in
the
case
that
the
builder
says,
I'm
sorry,
I
entered
a
fail
mode
to
not
write.
Then.
B
C
The
try
right
is
is
basically
saying
if
builder
dot
success,
copy
builder,
dot
format
account
into
charge
written
else
charge
written
equals
zero
return
false
right,
so
the
writing
was
already
done.
The
writing
was
already
done
and
we're
just
handing
we're
just
filling
in
the
two
return
values.
That's
part
of
try
right,
but.
B
C
C
Get
your
pen
formatted,
it
would
have
to
store
the
data
somewhere
for
try
right
to
do
so.
It
could
have
a
collection
that
wouldn't
work
very
well
if
x
or
y,
was
a
something
that
couldn't
be
stored
in
the
collection
like
a
spam.
I
I
D
It's
not
that
from
from
the
programmer's
point
of
view,
they're,
not
calling
some
other
thing
right,
they're
calling
try
right.
Yes,
the
implementation
of
try
right
is
maybe
not
necessarily
what
they
were
expecting,
but
that's
not
what
that's
not
the
code.
They're
writing
the
code.
They're
writing
is
try
write
this
thing.
K
D
K
B
D
B
D
Right
but
then,
if
you
try
to
use
this
feature,
you
wouldn't
get
it
in
the
first
place.
So
I
don't.
I
don't
really
like
right
like
you,
you
couldn't
pass
a
string
there.
So,
yes,
we
need
to
design
the
ide
experience
around
this
as
well.
But
that's
that's
part
of
the
feature
right.
C
C
K
K
B
Yeah,
I
mean
really
it's.
It
is
a
little
unfortunate
that
the
try
right
needs
the
destination
purely
because
the
the
pattern
says
it
has
to
be
there,
because
by
the
time
we
get
to
this
try
right
the
destination,
and,
I
guess
steve
said
on
the
provider.
Doesn't
matter
it's
it's
returning
the
boolean
off
of
this
guy
and
using
that
boolean
to
determine
what
to
write
to
this
guy.
C
Yeah
the
compile
the
developer
could
write,
make
the
try
right
call
as
if
it
was
passing
everything
in
the
constructor,
but
the
only
thing
the
method
actually
took
was
the
interpolated
span
builder.
You
know
maybe
something
like
that
could
be
made
to
work,
but
that's
not
currently
how
it's
proposed.
A
I
mean
it's
generally,
it's
somewhat
unfortunate
because
I
mean
it
would
be
nice
to
have
language
syntax.
It
just
allows
you
to
effectively
construct
the
builder
right,
because
then
you
actually
have
it
as
a
value.
Now
the
problem
is
always
tied
to
the
method.
Call
itself
right,
so
you
can't
quite
just
get
the
builder,
which
kind
of
makes
it
a
bit
odd
in
the
sense
right,
because
it's
all
based
on
an
expression
that
has
a
value
but
realistically
the
whole
compiler
feature
is
about
the
method
call
being
rewritten
right.
B
Yeah
I
mean
yeah,
I
I
I
think
that
I
can't
come
up
with
a
name,
that's
better
than
try
right,
because
you
know
if
we
jump
to
10
years
from
now,
when
the
feature
exists
and
we've
all
been
using
it
and
we're
all
happy
with
it
and
10
years
is
probably
enough
time
that
I
would
remember
that
the
feature
exists
in
the
language.
B
No
from
fred
the
you.
B
C
If
we're
happy
with
the
name,
we
will-
and
you
know
we
know
we
want
to
pass
in
the
destination
span.
We
know
we
want
to
pass
and
provided
we
know
we
want
to
get
out
in
charge
written
everything
else
we
will
do
whatever
it
is.
The
compiler
needs
us
to
do.
If
we
decide
you
know,
all
these
arguments
can
be
moved
to
the
builder's
constructor
great,
we'll
do
that.
I
think
we
just
need
to
decide
from
an
api
perspective
if
we're
okay,
regardless
of
what
it
ends
up.
C
A
A
It
takes
all
the
data
in
in
this
in
this
in
this
one
thing,
but
I
think
if
we
don't
do
that,
I
think
also
the
proposed
name
makes
sense,
because
it's
honestly,
I
don't
care
what
the
what
the
rewrite
is
that
the
compiler
does
it's
more
important
what
the
user
sees
when
they
actually
call
the
method
right,
because
that's
the
user
experience.
We
don't
really
expect
people
to
write
the
builders
by
hand
right.
A
There
will
be
a
very
small
number
of
people
that
have
to
build
methods
like
the
try,
write
method,
but
those
are
the
kind
of
people
that
do
unnatural
acts
today
right
they
basically
have
to
understand
the
compiler
feature
and
for
them
I
don't
think
it's
super
weird
that
the
method
takes
the
destination
and
the
provider
because
they
know
it's
just.
You
know
the
wire
through
to
the
to
the
builder
right.
So
I
think
that's,
it
seems
fine.
B
Yeah
because
you'd,
basically
in
order
to
do
the
right
thing,
we
would
need
like
attributes
that
are
like.
Oh,
I
have
a
proxy
parameter
that
is
before
something
like.
So
you
end
up
with
fake
methods
appearing
in
intellisense
that
make
the
target
work,
but
I
think
that
would
just
be
insane
so.
A
Are
there
any
cases
where
the
the
condition
that
that
caused
the
buildup
of
the
appends
is
not
a
discard.
C
No
basically,
the
the
pool
just
says
whether
the
pen
successfully
appended
or
or
not,
and
if
it's
not,
that
means
the
whole
operation
is
failing.
So
basically,
the
builder
in
this
case
is
both
returning
and
storing
whether
whether
it
was
successful
and
if
anything
failed,
then
try
right
is
going
to
return
false
because
the
build
it's
going
to
say,
return
builder,
dot
success.
Basically.
A
B
I
mean
it
could
have
been
like
we
could
build
this
whole
thing
with
string
builder
right
and
if
you
build
this
whole
thing
sure,
and
it
would
always
succeed
there
wouldn't
be
a
failure
mode.
You
wouldn't
ask
it
the
question
and
when
you
get
into
try
right
it
would
then
ask
how
many
characters
do
I
need
to
write,
and
it
would
say,
oh
too
many
and
then
be
false,
like.
C
B
C
B
C
A
C
Not
quite
so,
like
interpolated
string
builder,
the
one
we
discussed
last
time,
all
of
its
append
methods
are
void
returning,
but
it
is
a
ref
struct
because
we
want
to
be
able
to
seat
it
with
with
a
span
of
scratch
space.
So
we
want
to
be
able
to
store
a
span
inside
it.
B
C
Also,
the
bool
that
create
can
output,
which
it
can
be
used
for
things
like
logging,
to
say
whether
you
want
to
short
circuit
the
whole
thing
anyway.
So
there's.
A
B
So
I'm
I'm
going
to
ask
a
meta
question,
which
is
really
a
language
question
with
regards
to
the
feature:
are
we
concerned
with
short-circuited
builders,
confusing
people
as
to
side-effect-induced
interpolation
parameters.
D
Very
very
long,
three
hours
worth
of
discussion
between
last
wednesday
and
yesterday,
and
the
answer
is
not
particularly.
B
A
B
B
C
Case,
like
you
pass
to
log
your
log
method,
your
your
interpolated
string
and
it
says
log
level-
is
too
low.
So
I'm
not
going
to
run
this
at
all,
and
none
of
your
your
mutation
happens
in
your
holes
occurs.
Yeah
and
we
discussed
this
at
length
and
basically
the
answer
is
yeah.
It's
possible.
This
could
bite
someone
just
like
it's
possible.
Someone
can
be
bitten
by
conditional
attributes
on
methods.
B
C
But
in
general
the
cases
where
first,
it's
relatively
rare,
to
have
side
effecting
operations
in
holes
and
even
then
we
believe
that
it's
more
common
for
someone
to
believe
that,
for
example,
in
that
log
case,
that
the
things
you're
doing
aren't
you
know
aren't
happening
if
logging
was
disabled,
then
to
expect
that
side
effects
would
happen
regardless
right.
I.
A
C
C
A
I
would
mostly
base
it
on.
Would
you
reuse
it?
I
mean
if,
if
basically,
the
only
method
that
would
use
it
is
try
writer
memory,
extensions
and
the
only
thing
they
would
ever
use
to
type
explicitly
is
the
compiler.
Then
I
think,
having
a
nested
type
makes
perfect
sense.
It's
kind
of
like
to
get
enumerator
stuff
that
we
do.
If
you
expect
to
reuse
this
builder
from
other
types
that
are
not
memory
extensions,
it
would
be
a
bit
weird
if
it's
a
necessary
type
on
the
memory.
C
My
expectation
is
this:
is
the
one
and
only
place
it's
used,
whereas
the
interpolated
string
builder.
I
know
there
are
a
couple
places
I'd
like
to
use
it
and
we
put
that
one
at
compiler
services.
It.
C
D
B
C
B
Right,
but
you
know
if,
if
we
add
char,
eight
or
whatever,
as
a
you
know
more
primitive
concept,
then
then
the
try
right,
eight
builder
or
whatever
would
presumably
also
make
sense
on
memory
extensions.
So
it's
I
think
they
could
both
be
nested
there.
C
C
B
That
charm,
so
this
is
this
tri
format-
is
assuming
that
x
and
y
can
both
be
two
stringed
or
choose
to
string
or
try
formatted.
C
So
in
a
so,
this
call
will
be
append,
formatted
t
for
that
x.
So
if
x
was
int,
for
example,
it
would
end
up
being
append
formatted
int
that
takes
the
x
as
an
argument
and
then
append
formatted
says:
if
t
is,
I
span
formattable
t
dot,
tri
format
into
the
remaining
space
in
the
span.
B
C
B
Right
but
yeah,
okay,
so
the
builder
itself
didn't
need
to
get
passed
around.
No
so
for
this
one.
B
C
For
consistency,
there's
there's
no
state
that.
B
B
The
other
one
I
was
important
to
be
ref
because
it
was
doing
work,
I'm
fine
with
putting
ref
here,
because
maybe
one
day
it
matters.
A
I
think
I
mean
the
one
thing
like,
depending
on
where
the
ide
goes.
With
the
experience
I
I
would
say
that
interpreted
spam
builder
or
stream
builder,
whatever
you
want
to
call,
these
types
is
probably
not
the
most
helpful
name.
If
the
expectation
is
you
want
people
to
know
that
that
means
dollar
signs
something
right.
So
I
think
that,
because
I
mean
the
builder
sounds
very
mechanical
like
something
I
would
actually
new
up
myself.
A
So
if,
depending
on
where
the
ide
feature
lands,
if
we
don't
get
one,
I
think
we
should
consider
having
a
different
naming
convention
for
those
builders
that
makes
the
bit
more
pop
that
you
know
you're
supposed
to
write
dollar
signs,
something
so
maybe
interpolated
string
something
or
something
right
like
I
don't
know.
C
A
B
Well,
but
that
one
no
one,
I
guess
I
guess
you
do
have
the
proposal
of
letting
the
interpolation
builder
be
passed
into
places,
because
that's
why
it
needed
to
be
ref.
Okay,
I
was
going
to
say
that
one
no
one
ever
sees,
but
you
you
want
to
do
that.
A
But
fred
do
you
have
any
on
that.
D
I
don't
know
yeah
it's
a
hard.
I
I've
been
thinking.
Interpolated,
something
or
other
has
been
would
kind
of
be
enough,
but
I
can
see
the
arguments
around
well.
Interpolated
span.
What
does
that
mean?
I
don't
I
don't.
I
don't
understand
what
that
means.
I
can.
I
can
see
the
arguments
there.
It
does
feel
weird
to
have
a
type
named
interpolated
string.
D
C
Yeah-
and
we
could
say,
if
we're
not
concerned
about
these
names
being
too
long,
we
could
say
that
all
of
them
need
to
begin
with
interpolated
string
and
end
with
builder,
and
then
we
optionally
add
additional
stuff
in
the
middle.
You
know:
interpolated
string,
try
right
span
builder
and
interpolated
string
builder,
just
for
normal
strings
and
interpolated
string
string
builder
builder.
A
B
Assuming
that
intellisense
that's.
D
C
B
B
B
Then
the
then,
whatever
these
names
are,
would
only
be
seen
by
current
and
market
vs's
and,
as
fred
said,
they
can't
use
the
feature.
They
could
knew
the
thing
up
themselves
and
and
call
it
if
they
really
wanted
to
and
if
they
did
it
perfectly,
then
future
decompilers
might
turn
it
back
into
the
the
dollar
sign
quote
literal
for
them,
but
but
the
yeah.
I
I
think
that
if
everything
goes
to
plan,
then
the
default
dev
experience,
I'm
aware
there
are
other
ids
the
default
dev
experience
would
never
really
see
these
names.
B
B
B
Yeah,
like
just
taking
it
out
of
the
default
view,
experience
on
just
the
types.
B
Services
yeah,
I
agree
because
compiler
I
mean
compiler
service
is
all
big,
noisy
things
that
you
probably
don't
care
about
anyway.
So
exactly
I.
C
B
C
I
was,
I
was
suggesting
it's
within
it
being
a
nested
type.
We
call
it
interpolated
try
right
builder,.
L
A
C
I
think
I'd
prefer
to
stick
with
builder
now,
as
the
suffix
pending
further
discussion,
based
on
what
the
id
experience
is.
Like
I
mean
renaming
these
things,
renaming
interpolated
string
builder
is
a
little
bit
harder
because
that
would
involve
the
compiler
knows
that
name,
but
everything
else.
The
compiler
is
unaware
of
the
name
for,
and
we
can
change
that.
You
know
at
the
drop
of
a
hat
before.
A
I
D
That
gets
into
the
question
of
order
of
evaluation,
and
I
really
really
really
don't
want
to
see
us
like
I'm
already
pushing
for
us
not
to
allow
arguments
from
the
interpolated
string
to
come
after
the
the
interpolated
string
itself.
And
that
would
necessitate
that
the
arguments
come
after
the
interpolated
string.
B
Yeah,
we
also
have
a
scoping
and
binding
problem
if
we
made
just
a
static
to
hold
a
bunch
of
these
things,
because
you
end
up
it
needs
to.
You
can't
have
overloading
on
the
interpolation
type,
because
the
I
assume
the
compiler
would
be
like.
Oh
my
god,
there
are
two
conflicting
things
that
would
take
a
dollar
sign
expression.
B
Here
I
fail
and
then
there's
no
way
out
of
that
hole
ever,
and
so
we
really
do
want
the
things
to
be
as
tightly
scoped
to
the
methods
that
want
them
as
possible
and
in
the
case
of
interpolated
string
builder,
that's
the
global
scope.
D
D
You
you
shouldn't
just
dot
off
any
interpolated
string
and
see.
Oh,
what's
this
try
right
thing
or
you
know
that
doesn't
feel
it.
It
feels
much
more
appropriate
that
this
should
be
I'm
working
with
a
span.
Oh,
let
me
dot
off
of
it
and
see
what
I
can
do
as
opposed
to
dotting
off
a
string
and
then
going
what's
this.
What's
this
method
here.
B
Yeah
looking
at
it
from
the
extension
syntax,
I
try
right
makes
more
sense
than
try
format,
because
try
format
is
take
the
object,
expression
and
figure
out
a
way
to
turn
that
into
a
string,
and
this
is
take
the
arguments
and
shove
them
into
the
object
expression,
which
is
right
right.
B
E
H
D
You
can
choose
whatever
argument
order
you
want,
but
if
try,
if
the
thing
you're
dotting
off
of
is
the
interpolated
string
and
the
thing
that
you
and
the
thing
that
you're
writing
into
is
the
first
is
the
first
argument
after
it's
been
substituted
right.
That
means,
by
necessity,
that
the
interpolated
string
has
to
come
before
the
span.
Okay,.
H
D
Yeah,
okay,
which
I'm
also
not
certain,
will
just
work
in
general
with
the
rules
as
they're
written
it
might,
but
I'm
honestly
not
sure.
I
I
A
C
Also
concerned
that
we
will
then
be
basically
saying
that
anything
that
has
to
do
with
processing
interpolated
strings
needs
to
go
on
to
that
type.
When
I
think
in
general,
these
are
going
to
be
much
more
distributed,
like
there's,
some
string
builder
functionality
related
to
this
and
there's
some
span
of
char
functionality
related
to
this,
and
some
string
functionality
and
some
logging
functionality,
and
I
don't
want
everyone
to
have
to
go
to
interpolated
string
dot
in
order
to
use
that,
especially
if
they
can't
extend
it
for
their
own
stuff.
A
Yeah,
I
would
agree
with
that
too,
like
I
think
for
the
I
would
just
say
like
for
the
span
case.
It
kind
of
makes
sense
to
me
that
it's
a
static
helper,
because
you're
you're
usually
not
having
right
methods
on
the
span,
but
usually
you
have
static
methods
that
take
a
span
right
or
an
instance
method
that
takes
a
span
and
you're
going
to
write
something.
A
B
Yeah
well
to
be
fair,
I
think
it's
only
an
extension
over
span
like
the
we
did
do
a
bit
of
thinking
of
what
it
when
we
want
extension
methods
versus
you
know,
pure
statics
or
instance,
methods,
and
this
is,
it
doesn't
apply
to
all
spans.
It
only
applies
to
span
of
char,
so
this
is
really
we
wanted,
as
an
instance
method
on
span
of
char.
It's
a
special
version
of
fill,
which
is
an
instance
method
on
span
that
writes
into
the
span.
B
That
and
clear,
are
the
only
ones
that
modify
it.
I
think
everything
else
modifies
an
argument
the
so
this
fits
in
the
we're
just
saying
that
the
span
span
of
char
has
a
way
that
it
understands
how
to
take
an
interpolated
string
and
write
into
that
span,
and
that's
that
that's
what
steve
proposed
here.
If
we
wanted
it
as
a
pure
static,
then
we
would
have
to
take
this
interp
now
currently,
memory
extensions
plus
interpolated
try
right
builder,
using
il
syntax
to
show
it's
a
nested
type
that
the
like.
I
B
I
So
if
we
add
support
for
chart
eight
or
span
byte
in
the
future,
we're
going
to
continue
down
this
path
of
having
a
an
extension
on
span
byte
or
would
we
say
we
would
only
ever
do
that
if
we
had
charity.
F
B
One
well,
so
I
think
if
we
had,
you
know
if
we
had
char
8
or
you
know
whatever
as
a
thing
that
is
not
just
an
alias
for
byte,
then
we
would
have
try
right
this
span
of
char
span
and
we
would
have
try
right
this
span
of
char
8
span
and
we
would
probably
need
two
different
builder
types,
because
the
spans
that
they
use
are
different,
but
that
would
be
hidden
by
intellisense
because
they
both
take
dollar
tiny
things
and
there's
no
compiler
ambiguity
because
a
chart,
a
span
of
char
and
span
of
char
8
can't
unify
so
it
knew
which
target
you
wanted,
and
there
was
only
one
dollar
sign
target,
etc.
D
Again,
we
might
have
some
ordering
issues
where
everything
on
utf-8
formatter
is
is
is
thing
to
write
test
than
the
destination,
whereas
this
will
probably
want
to
be
destination
than
thing
to
write,
but
other
than
that
inconsistency.
It
should
be
possible.
B
I
mean
to
be
fair.
Our
general
guidelines
for
span
were
written
after
that
and
they
say
that
the
destination
comes
first
well,
the
source
span.
Then
the
destination
span.
Then
everything
else,
so
the
utf-8
formatter
ones
are
actually
backwards.
For
our
current
guidelines.
B
C
Not
to
that
part,
why
don't
we,
since
we've
been
talking
about
custom
builders?
Why
don't
we
jump
down
to
the
third
part
on
stringbuilder?
That
should
be
quick.
Now
I
think,
and
we'll
come
back
to
this
middle
part.
Okay,.
C
All
right,
so
the
idea
here
is:
we
allow
you
to
make
a
single
call
to
stringbuilder.append
format,
accepting
an
interpolated
string
and
have
the
compiler
translate
that
to
dependent.append,
rather
than
you
having
to
split
it
up
manually.
So
if
you
scroll
down
a
little
bit,
you
can
write
sp,
append
format.
You
know
x,
comma
y,
rather
than
having
to
write
sp.append
x,
dot,
append
comma
space
dot
append
y.
C
The
other
thing
this
enables
is
to
use
a
provider
which
you
can't
currently
do
today,
which
means
there's
no
way
to
say
to
efficiently,
say
today:
stringbuilder.append
the
hex
value
of
an
integer,
because
there's
no
way
to
say
append
with
the
integer
and
the
the
iformat
provider,
you
have
to
use
append
format,
box,
the
integer
etc.
C
So
this
would
enable
that
scenario
as
well,
and
basically
this
would
end
up
being
translated
down
to
a
builder
that
passes
in
the
string
builder
and
then
builder.pen.
Whatever
just
translates
to
calling
the
relevance
functionality
on
your
on
on
the
underlying
string
builder,
I
propose
doing
this
as
an
append
format
method
on
stringbuilder.
C
If
you
can
scroll
up
a
little
bit,
jeremy
there's
a
conversation
to
potentially
be
had
about
doing
this
as
append,
instead
of
as
append
format.
C
Append
format
makes
sense,
because
it's
logically
overloads
of
the
existing
support
that
takes
a
format,
string,
provider,
arguments
etc.
But,
as
I
mentioned
earlier,
there's
a
fair
amount
of
usage
for
stringbuilder.append.
That
just
takes
an
interpolated
string
and
all
of
that
would
just
get
better.
B
Yeah
so
fred,
representing
the
compiler
and
language,
will
an
interpolated
builder
argument
target
beat
string
in
overload
resolution.
D
The
specific
design
was
that
code
gets
better.
So
when
you,
when
you
upgrade
this-
and
you
have
one
of
these
things,
it
just
gets
better.
The
question
I
have
around
these
types
of
things
is
at
least
personally.
I
almost
never
use
a
pen
format
and
I
almost
always
use
append
or
pen
line
on
string
builder
yep.
Just
from
my.
C
B
C
Well,
yes,
that
that
will
have
an
empty
body.
If
we
didn't
append
line,
then
its
body
would
just
be
sp
dot,
append
line
right.
B
Yeah,
I
guess
that's
true
append
format's
body
is
returned
this
and
well,
even
once
it's
renamed
to
a
pin
that
depends
append.
Taking
an
interpolated
builder
would
just
say,
return
this
and
yeah.
I
mean.
C
B
D
The
the
dirty
little
secret
of
this,
of
course,
is
that
it's
actually
just
a
limited
form
of
aspect-oriented
programming
right,
it's
it's!
The
design
of
it
is
specifically
that
it's
injecting
code
at
the
call
site
not
at
the
method
body,
and
so
that
naturally
ends
up
meaning
the
method
body
is
kind
of
not
doing
much.
C
Now,
if
we
really
wanted
to,
we
could
add
some
validation
to
the
methods,
pure
overhead,
that
you
know
check
that.
The
builder
contain
that
the
string
builder
contained
in
the
interpolated
format
builder
is
the
same
one
as
this,
and
if
the
provider
was
passing
stuff,
but
I
don't
think
that's
worthwhile,
I
think
that's
just.
B
I
guess,
in
the
case
of
a
of
a
logger,
you
actually
would
end
up
doing
work
in
the
in
the
end
method,
because
you're
you're,
probably
just
actually
composing
the
formatted
message
in
your
builder
just
doing
the
like,
I
I
know
I
have
a
fixed
length
or
you
know
whatever
work
you
want
to
do
and
then,
at
the
end
now
you're
like
great
I've
actually
composed
this
thing
now
go
push
it
on
the
wire.
B
A
Is
this
the
right
name
for
the
for
the
parent?
I.
D
Yeah,
that's
an
interesting
question.
I'm
currently
thinking
this
is
the
way
to
go
and
that
if
you
wanted
to
have
a
parameter
named
this,
you
need
to
escape
it,
but
that's
pretty
c-sharp
specific.
On
the
other
hand,
I
don't
know
a
word
like
any
word
that
we
choose.
There
has
to
be
something:
that's
not
a
legal
identifier.
The.
C
D
D
You
can,
then
you
can't
customize
the
order
in
which
it's
passed
right.
If
you
want
to
pass
this
as
the
second
argument,
so
the
specific
word
there,
I
think,
still
needs
to
be
decided
if
we,
if
we
use
this,
it's
very
c-sharp
specific,
which
I'm
not
a
huge
fan
of
so.
C
C
C
G
C
As
append
and
then
did,
folks
also
want
an
append
line
or
just
a
hand.
B
I
think
we
should
also
do
a
pinned
line
yeah
because
otherwise,
otherwise
you
would
write
append
and
you're
like
oh,
but
I
want
the
new
line
after
it.
Now
you
add
l-I-n-e
and
now
it
goes
through
the
old
string
build
or
it
goes
through.
The
other
string,
interpolation.
D
So
that's
a
good
point
and
I
know
that
I'm
personally
guilty
of
doing
stuff
like
this
in
like
test
code,
where
I
don't
really
care,
you
know
it's
just
like
yeah.
B
C
Okay,
so
then
there's
the
the
middle
section.
B
Yeah-
and
I
guess
I
don't
know
what
string
builder
pin
looks
like
do-
we
need
the
I
format
provider
on
append.
C
Yes,
I
would
like
it
to
be
there.
Okay,
so
we'll
do
append.
C
I
All
right
are
we
also
going
to
add
a
similar
overloads
on
top
of
textwriter.
C
I
hadn't
considered
it.
We
could.
I
B
C
Corey,
do
you
want
to
open
an
issue
for
it
sure
thanks
good
suggestion,
I'm
sure
there
are
actually
even
other
places
where
we
could
leverage
interpolation.
These
were
just
the
main
ones
that
occurred
to
me
that
I
saw
being
used
relatively
frequently
that
we
could
make
better,
but
text
writer
is
a
good
example
of
another
one.
We
talked
about
utf-8
writer,
it's
potential
one
for
the
future
around
you
know,
formatting
stuff
is
utf-8
and
there
are
probably
other
places
as
well.
C
We've
talked
about
maybe
doing
something
with
microsoft,
extensions
logging
and
yeah
all
right.
So
then,
the
middle
portion
is
basically
just
two
things
where
I'm
proposing
new
string.format
overloads
and
basically
to
be
able
to
do
two
things:
to
be
able
to
do
string
interpolation
into
a
string
but
with
a
format
provider
and
to
do
string
interpolation
into
a
string,
but
seated
with
some
scratch
space
like
stack,
alec
or
a
buffer.
You've
got
lying
around,
so
basically
a
string.format
method
that
allows
you
to
pass.
D
C
B
The
yeah,
I
certainly
didn't,
do
homework
to
look
up
what
a
good
name
for
scratch
buffer
was.
I
don't.
C
B
B
Enough,
I
just
wonder
if,
in
other
apis
we've,
either
us
or
win32
or
anywhere
has
exposed
it.
Just
as
like
you
know,
temp
or.
B
I
C
C
I
mean
it's
a
little
strange
because
a
lot
of
the
static
apis
on
string
are
about
creating
strings
yeah
and
it's
you
know.
How
are
you
creating
it?
Are
you
reversing
it
or
removing
something
from
one
to
create
another
or
you're,
giving
a
delegate
to
create
it?
So
format
is
largely
like
you're,
giving
it
something,
that's
format
related,
and
you
want
to
produce
a
string
from
it,
which
is
why
I
chose
that.
C
But
if
we
want
to
you
know,
if
we
want
to
sort
of
de-emphasize
it
and
make
it
more
advanced
and
only
for
advanced
users
to
know
to
look
for
this
thing,
we
could
make
it
string.create.
We
could
put
it
on
formattable
string,
which
is
a
little
strange
because
that's
sort
of
the
old
interpolated
string
thing,
but
we
could
put
it
there.
C
A
C
B
I
think
I
I
think
emo's
suggestion
of
string.create
is
good
good.
It's
the
same!
There's
a
span
here
things
you
need
to
sort
of
know
a
little
bit
of
what
you're
doing
not
a
whole
bunch,
because
if
scratch,
buffer
or
temp
space
or
whatever
is
too
small
you'll
work
around
it,
but
it's
it's
still.
Maybe
maybe
you
should
be
in
you
know:
programming
102
before
you
call
this
method
and
string
that
format
is
definitely
dev101.
A
C
A
B
B
Okay
again,
because
the
the
format
verb
in
current.net
is
that
you
take
a
format
string
and
then
the
stuff
to
shove
in
the
positional,
placeholders
and
the
whole
purpose
of
this.
Is
there
aren't
positional,
placeholders
and
you're
not
doing
all
of
the
after
the
fact
work
of
counting
them
and
temp
space
and
and
all
that
you're
building
it
up
in
a
forward
manner
and
hoping
that
you
can
do
so
in
a
efficient
manner.
So
it's
not
a
format.
It's
it's
just
string,
dot
manifest
and
manifest
is
create.
So.
A
Okay,
I
mean
it
is
kind
of
a
continuation
of
what
we
have
done
in
the
past
right
because
the
I
mean
when
we
edit
interpolation,
basically,
people
replace
the
format
verb
with
just
the
raw
value
right
so
like
if
you
move
to
the
old
syntax
or
the
current
centers.
Depending
on
your
viewpoint,
basically,
you
just
replace
string
dot
format
with
just
you
know.
The
dollar
sign
quote
right,
or
if
you
call
you
know,
string
builder,
dot,
pen
format.
C
Okay
and
jeremy,
did
you
want
to
do
a
little
research
on
scratch
and
come
back
with
a
different
name.
B
Yeah,
I
don't
like-
I
can't
get
to
it
today
because
of
complicated
scheduling,
but
I've
definitely
I've
taken
down
a
note.
We're
not
fully
happy
with
the
name
scratch
buffer,
but
not
sure
what
a
good
answer
is.
The
adjective
temporary
received
a
minor,
happy
response,
temporary
buffer
question
mark
and
that.
B
But
yeah
I'll
I'll
take
a
note
to
myself
to
look
for
any
sort
of
temporary
scratch,
etc,
thing
that
we
have
in
api
that
we're
maybe
happy
with
or
even
not
happy
with
and
see.
If
we
can
solve
this
over
email
sounds
good.
B
B
B
C
B
C
Yeah
this
one
is
about
being
able
to
customize
how
the
formatting
happens.
So
do
you
want
to
use
invariant
culture?
Do
you
want
to
use
you
know
frfr
or
enus
or
whatever.
C
It
also
allows
you
to
there's
some
neat
super
advanced
features
like
you
can
pass
an
I
format
provider
that
implements
I
custom
formatter,
and
then
you
get
to
customize
every
every
value
that
comes
through
every
hole.
If
you
really
want
to
so
you
can
implement
your
own,
like
you
know,
b
for
binary
format,
specifier
and
then
your
integers
would
all
be
if
you
format
it
as
binary
or
something
sure.
B
Okay-
and
the
note
we
had
last
time
was-
allow
multiple
false,
which
you've
already
incorporated.
B
You
were
a
steve,
so
you
didn't
like
that.
A
single
argument
was
gonna,
allocate
an
array
somewhere.
I
assume
the
compiler
can
agree
to
handle
that
resolution.
Fred.
B
C
The
the
honestly,
the
main
reason
I
didn't
just
have
the
params
one
is:
if
memory
serves
array,
constructor
arguments
to
attributes
are
non-cli
compliant.
C
D
That
came
up
with
unmanaged
colors
only
which
only
has
params
and
is
not
a
cls
compliant.
B
Could
buy
what
I
said
so?
Does
that
mean
as
a
nod
to
cls
compliance?
We
want
to
add
like
six
overloads
to
this,
or
do
we
stick
with
this
until
whoever
manages
cls
these
days
gets
touchy.
A
C
D
A
A
C
I
think
there's
some
minor
things
that
aren't
worth
bringing
back
through
here
like
we're
debating
whether
to
use,
create
or
a
constructor
same
arguments
just
is
it
called
create,
or
is
it
called
ctor,
I'm
assuming?
I
don't
need
to
bring
that
back
through,
but
anything
more
than
that
yeah
we'll
come
back.
A
D
Yeah
I
can,
I
can
do
that.
I
mean
we're
we're
still.
There
are
still
other
parts
about
this
proposal
that
are
being
debated.
So
hopefully
we
don't
need
to
come
back
with
major
changes
to
all
this
stuff,
but
yeah.
D
B
And
I
think
I
missed
a
bunch
of
eb
nevers,
because
I
was
trying
to
avoid
dead
air.
I
also
only
updated
one
of
the
string
that
creates
to
be
restringed
formats
to
be
string.create.
A
D
D
The
the
one
thing
about
enumerators
unless
you're
doing
extension,
enumerators
is
you're,
not
gonna,
see
them
on
these
types
right,
because
you
can
call
extension
methods
without
using
them
as
an
extension
method.
So
I
don't.
I
don't
necessarily
know
as
though
in
the
enumerator
cases
is
quite
as
good
a
comparison.
A
Yeah,
it's
more
like
when
you
dot
into
the
type
right
like
so
so.
Take,
for
example,
the
let's
say,
memory
extensions
right.
If,
if
I
dot
into
it
today,
I
would
find
interpolated
try
right
builder
in
there
unless
you
apply
the
attribute
right
and
the
same
can
be
said
for
let's
say
list
of
t
right,
but
I
guess
your
argument
is
you?
Don't
generally
do
statics
on
those
things
so.
D
I
guess
yeah
my
my
argument
is
that
you
know
extension
methods
are
perfectly
valid
to
call
by
saying
memory:
extensions,
dot,
try
right
instead
of
saying,
span,
dot,
try
right
and
then
control
dotting
or
using
import
completion
to
get
the
using,
and
so
it
seems
more
likely
that
someone
would
dot
into
memory
extensions.
Then
they
would
dot
into
necessarily
like
list
of
t
right.
B
The
question
is:
where
am
I
missing
a
space
way
up
there
and
there?
Okay,
I
think
I
captured.
D
Things
all
right,
I
have
another
meeting
to
run
to
folks,
so
that
sounds
good
thanks.
B
Append
format
should
instead
be
append.
We
also
want
to
pin
line
string
format,
a
string
create-
and
we
have-
I
have
homework
of
looking
for
prior
art
on
things
like
temporary
and
working
and
whatever
buffers.
A
And
you
capture
the
we
need
to
rethink
through
this
right.
I
don't
think
you
did
right
need
to
rethink
what
we
need
to
think
about
this.
How
do
we
call
this?
I.
B
Mean
that's
string
or
that's
going
to
be
the
the
compiler.
The
compiler
and
language
are
going
to
come
up
with
what
the
answer
is
on
that
and
we
just
we
need
to
have
the
attribute
painted
correctly.
So
I'm
sure
I
don't
think
we
as
the
group
care
it's.
The
code
has
to
work
in
the
end
and
steve
will
make
that
happen.
B
All
right,
so
that
was
easy.
We
have
30
minutes
left,
does
any
more.
H
C
F
A
B
H
Sure
in
tls
I
think
1.1
and
1.3
there's
a
way
to
ask
for
the
client
certificate
after
negotiation.
They're,
they
work
differently
in
any
of
those
protocols
but
generically
the
api
is.
I
don't
have
the
client
cert
in
the
initial
handshake
and
the
client
will
ask
after
the
request
is
made
for
the
the
the
search
happens.
H
So
this
api
essentially
lets
the
caller
ask
for
the
cert
from
the
server
side
from
the
client
and
typically
it's
used
in
scenarios
where
you
want
to
be
able
to
ask
for
a
certificate
by
looking
at
request
information.
So
normally
in
the
excel
handshake,
you
only
have
the
domain
name
the
host
name
of
the
request.
H
This
is
typically
used
later
in
the
request
path
after
the
hashtag
has
happened,
and
you
have
more
information
about
the
request
to
then
renegotiate
the
certificate,
and
this
api
is
about
triggering
that
from
from
the
server
side,
we
have
customers
who
basically
are
moving
from
iis
and
htv
system
castro,
and
this
works
on
those
servers.
H
So
the
intent
here
is
to
expose
exposing
the
api
on
a
cell
stream
that
capsule
can
expose
in
asp.net,
so
that
that
feature
comes
back.
B
N
Yeah
you,
you
basically
ask
for
client
certificate
as
boolean
and
a
client
might
or
might
not
send
it,
and
it's
up
to
the
server
to
decide
what
to
do
when
you
don't
get
it
in
handshake,
so
the
remote
certificate
validation
callback
could
be
called,
and
if
there
is
no
custom
validation,
the
engine
could
fail.
If
this
ever
asked
for
a
client
certificate.
B
B
Right
there,
it
is
remote
certificate.
N
So
the
thinking
was,
if
you
or
have
the
certificate
this
this
method
will
blessing,
essentially
ask
or
would
give
you
that
and
if
not,
then
it
would
basically
start
your
handshake
or
attempt
to
study,
handshake
or
re-handshake
or
renegotiation,
and
if
the
client
gives
you
the
certificate
back,
it
will
give
you
the
certificate.
If
not,
it
would.
B
Okay
and
then
from
a
from
a
protocol
level.
This
is
it's
just
a
renegotiate,
so
all
the
same
mechanisms
we
have
for
how
the
client
chooses
what
certificate
to
specify
still
makes
sense,
and
we
don't
need
any
complicated
parameters
or
a
new
thing
for
the
client
to
be
able
to
do
the
client
half
of
this
correctly.
N
Well,
sort
of
yeah,
mostly
the
exception,
is
still
a
similar.
Three
there
are
basically
renegotiation
doesn't
exist.
However,
there
is
a
extension
which
allows
you
optionally,
to
say
I'm
willing
to
do
post-handshake
authentication,
and
this
could
piggyback
on
the
post-handshake
authentication
extension
and
it
hinges
on
client
willing
to
support
it.
C
I
I
N
Okay,
so
they
already
screwed
this
http
do
corey,
as
david
said.
So,
basically,
when
you
start
multiplexing,
this
gets
trickier
and
this
is
the
aed
gateway,
so
they
have
like
thousands
of
sites
and
whatnot
and
it's
basically
legacy-ish
behavior,
so
it
brought
them
migrating
to.net
core.
N
That's
why
I
just
promise
it
for
six,
and
it's
kind
of
you
know
bigger
deal
and,
as
david
said,
the
old
asp
did
support
it,
but
kestrel
can
because
the
ssl
stream
cannot
do
that
at
this
moment,
but
then
who's.
H
Code
infrastructure,
no,
no,
it's
so
it's
your
own,
so
we
expose
the
api
through
through
apis
and
spin
it.
But
your
code
basically
has
to
say:
okay,
I
read
the
path
path
is
slash.
Give
me
the
cert,
no
called
get
called
get
client
certificate,
async
in
your
in
your
actual
controller
code,
on
the
server
side.
So
it
is
their
code
calling
this
api
at
some
point
in
time.
N
About
it
from
wcf,
but
again
it
doesn't
exist
right
now,
so
people
been
asking
about
it
at
different
forums,
but
I
think
mostly,
we
consume
by
our
error
layer,
not
necessarily
directly.
A
H
You
don't
call
it
yourself,
you
configure
it
based
on
on
incoming
path,
so
you
say:
slash
foo,
slash
bar
requires
cert
and
it
does
the
actual
it,
and
I
guess
that
it
happens
there
on
http
sys,
there's
an
explicit
call,
an
api
call
into
the
kernel
to
say
like
get
the
cert
async
so
depending
on
which
api
you
use
or
what
server
you
were
on
it's
exposed
in
different
ways,
but
in
casual
we
plan
to
expose
it
as
a
a
call
that
you
make
yourself.
I
B
Or
read
or
like
a
renegotiation,
is
now
in
flight.
What's
read,
I
guess
would
be
easy.
There's
no
data
ready,
but
right
is
it
does
it
are?
Are
we
tracking
it
renegotiates
some
progress?
I
need
to
enqueue
rights
and
we
just
say
like
yep
totally
got
this
we'll
deal
with
it
later
or
are
you
inconsistent
or
what.
N
You
sort
of
do
either
on
as
implementation.
What
chris
ross
was
proposing
is
to
basically
throw
if
you
do
that
and
there's
outstanding.
There
was
a
link
somewhere
in
it
that
the
old
implementation
had
a
problem
that
if
you
have
large
incoming
requests
and
you
parse
the
url
and
you
stop
reading
and
you
trigger
the
negotiation
right,
the
renegotiation
could
be
blocked
behind
all
the
data
you're
receiving
and
it
might
deadlock
you
in
the
past.
So
again
the
proposal
was
possibly
throw
or
document
that
you
need
to
keep
reading
and
writing
from
a
stream.
N
The
ssl
stream
and
the
s
channel
seems
to
be
okay.
If
you
keep
sort
of
writing
to
it,.
N
B
Okay,
I
mean
just
making
sure,
because
you
know
it's
yeah
right
now-
it's
proposed
as
an
async
only
and
since
we
already
have
synchronous
right
and
stuff
do
we
want
the
the
synchronous
blocking
like
because
I
can,
it
seems,
like
many
things
are
going
to
be,
there's
nothing
I
can
do
until
after
and
there
are
synchronous
users
of
ssl
stream.
So
we
probably
want
the
synchronous
version
of
this
method
as
well.
A
H
Mean
that's
going
to
happen
right
because
choice,
you
choose
your
poison,
I
mean.
Ultimately,
the
sync
version
is
waiting
for
io
anyway,
like
it's
not
very
different.
Is
it
like
it's
not
like,
and
by
waiting
for
io,
I'm
not
saying
it's
waiting
for
back
pressure
to
be
released.
I
mean
it's
waiting
for
a
certificate
to
be
received
from
the
client.
B
H
B
Do
then
that's
fine,
but
making
the
caller
do.
It
means
that
the
caller
either
starts,
assuming
that
this
is
generally
okay
or
they
they
need
to
figure
out
how
to
know
if
it's
okay,
and
so
we
just
we
have
the
suggestion
that
async
api
should
have
sync
api,
especially
on
types
that
are
already
mixed.
So
I
think.
J
This
one,
the
guideline
is,
I
understand
it.
Steven
please
jump
in,
but
the
guideline,
as
I
understand
it
is,
if
you
can
do
something
smarter
than
just
you
know,
get
a
waiter.getresult,
then
you
should
expose
the
sync
api
in
order
to
do
that,
we
certainly
do
that
here
in
the
sense
that
we
can
do
a
sync
operate
or
sync
read
on
the
underlying
stream
right
right.
So.
H
H
B
C
C
How
many
people
actually
need
to
call
this
and
are
any
of
them
going
to
use
the
synchronous
method?
No
they're
all
going
to
be
a
thing
I
would.
I
would
err
on
the
side
of
just
exposing
the
async
one,
and
if
we
actually
hear
someone
wanting
synchronous,
we
can
add
it
later,
but
it
this
sounds.
Super
corner
case.
J
H
N
It
impacts
dom
devicelogin.microsoft.com,
you
know
and
touching
that
it's
really
like
difficult,
so
yeah,
but
those
are
solid.
Current
cases
and
legacy
behaviors.
J
So
we
should
call
this
api,
something
like
request,
client
certificate,
dangerous!
Don't
do
this
ever
asic.
J
H
B
I
think
the
the
problem
would
be
if
you
just
want
one
you
would
like
or
you're
expecting
one
or
you
think
it's
the
optional,
like
you
said,
oh,
be
an
optional
client
certificate.
You're
like
oh
there's,
get
client
certificate.
That's
exactly
what
I
want
to
do
and
it's
not
obvious
that
you're
doing
renegotiate
if
they
didn't
give
one.
C
What
if
we
were
to
instead
have
renegotiate
and
renegotiate
async,
and
then
you
know
a
parameter
that
specifies
whether
you
just
like
you
have
in
the
initial
handshake,
whether
you
require
a
client
certificate
and
then,
if,
if
one
is
provided,
it
ends
up
just
being
available
via
the
property.
Is
that
feasible
horrible.
N
So
that's
sort
of
how
we
scale
down
not
to
call
it
beginner
renegotiation.
We
call
it
get
certificate
because
there
is
a
tls
velocity
extension,
which
is
not
renegotiation.
I
H
M
May
or
may
not
be
ever
supported
by
anyone
window,
so
I
have
working
prototype.
N
In
openssl,
yes,
correct,
because
it's
not
renegotiation,
it's
a
post,
authentication,
a
positioning
authentication,
so
the
mechanism
is
different
and
therefore
the
api.
It's
version
specific.
N
B
B
N
Our
expectation
was,
you
would
basically
get
you
know
if
you
ask
nicely
and
the
client
says
no,
I
don't
have
certificate
for
you
and
it
would
throw
if
you
get
a
underlying
os
error.
N
So
basically
the
pool
will
be
the
the
noodle
value.
Essentially.
N
Because
this
is
movable
right,
so
it
says:
x59
certificate,
question
mark.
I
B
N
My
original
plan
was
to
just
return
the
existing
certificate
in
that
case,
or
you
know
in
this
case
finish
the
task,
but
I
don't
think
it
matters.
It's
really
a
matter
of
preference.
I
prefer
to
throw.
J
N
Don't
think
this
is
necessarily
dangerous.
As
you
know,
jeff
was
suggesting
it's
just
the
center
pro
calls
like
http,
2
and
gp3
decided
that
they
don't
want
to
support
it
because
of
the
multiplexing.
But
aside
from
that.
B
B
A
A
I
N
Okay,
like
I
think
both
say,
should
be
2
and
hp3
or
aquatic
explicitly
said.
The
extension
exists
on
tlc
3,
but
do
not
use
it
or
do
not
enable
it,
and
we
could.
We
could
immediately.
B
I
mean
you,
you
say
that
as
a
joke,
but
I
mean
if
we
really
think
that
it's
that
this
is
entirely
about
enabling
legacy
pipelines,
do
we
want
to
start
it
with
obsolete
of
you
really
really
don't
want
to
call
this?
No,
let's
just
leave
it,
as
is
it's
fine.
H
A
H
B
A
A
H
Over
maybe
you're
doing
tls
over
something
else.
Maybe
it
is
you're
doing
sql
and
they
support
it
in
their
protocol
like
don't,
I
wouldn't
call
it
obsolete
just
because
the
scenarios
that
are
trying
to
use
it
are
those
scenarios
that
that
that
we're
aware
of
yeah.
I
do
think
the
obsoletion
argument
might
be
a
little
too
http
specific,
especially
if
there's
this
extension
in
tls,
one
three
and
so
forth.
N
B
B
B
I
don't
think
the
client
can
say:
hey
server.
You
previously
did
anonymous
tls,
which
doesn't
really
exist
anymore.
Please
please
anonymize
yourself.
I
don't
know
that
they
have
the
ability
to
do
that.
Maybe
the
client
can
trigger
or
renegotiate
that
the
server
should,
but
the
server
gets
a
blank
context
yeah.
So
it
wouldn't
know
you
were
really
trying
to
control
a
certificate
out
of
it
unless
you
just
drop
tls10
and
now
it
has
to,
but
all
right.
So
I
think
this
covered
everything.
H
N
Maybe
last
comment:
I
don't
think
it
will
work
on
mac
os,
so
it
will
throw
a
platform
not
supported
exception
and
same
for
android
and
probably
some
immobile
devices.
So
we
can
make
it
work
for
linux
and
windows.
N
I
don't
think
I
hope
it's
not
big
concern,
but
it
covers
most
of
the
cases.