►
From YouTube: .NET Design Review: GitHub Quick Reviews
Description
00:00:00 - Approved: Review System.Buffers.SequenceReader(T) proposals https://github.com/dotnet/corefx/issues/40962#issuecomment-530060857
01:15:19 - Needs Work: SequenceReader(T).AdvanceTo(SequencePosition) https://github.com/dotnet/corefx/issues/40843#issuecomment-530066043
01:25:49 - Needs Work: Allow custom format strings for boolean values https://github.com/dotnet/corefx/issues/8126#issuecomment-530066335
01:29:56 - Approved: SequenceReader(T).ReadToEnd / AdvanceToEnd https://github.com/dotnet/corefx/issues/37156#issuecomment-530067301
01:32:38 - Approved: SequenceReader(T).TryRead overloads to read a specified number of elements https://github.com/dotnet/corefx/issues/40870#issuecomment-530068389
01:35:02 - Approved: SequenceReader(T).TryPeek overloads for look ahead https://github.com/dotnet/corefx/issues/40845#issuecomment-530069306
01:37:29 - Approved: SequenceReader(T).TryPeek overloads to read a specified number of elements from any position https://github.com/dotnet/corefx/issues/40871#issuecomment-530070064
A
A
Sure
and
David
you
can
chime
in
again
as
appropriate.
The
first
one
is
relatively
simple:
there.
It's
it's
pretty
costly
to
advance
the
reader
all
the
way
to
the
end,
doing
it
yourself,
you
know
if
we
have
a
method
on
it,
it
little
far
simpler
than
doing
it
yourself,
and
we
can
just
reset
the
state
to
the
end
of
the
sequence
and
consume
did
all
that
which
is
pretty
fast.
What.
A
When
they're
like
parsed,
when
their
parsing
through,
for
example
and
they're,
like
looking
for
something
like
let's
say,
you're
reading
through
something
that's
calm,
semicolon
delimited
or
whatever
and
you're
going
through
there
and
you
get,
you
don't
find
another
one.
You've
gone
through
all
the
ones
who
have
properly
terminated
in
some
cases
you
don't
want
that
last
chunk
or-
and
you
would
just
want
to
push
it
to
the
end.
So
the
thing
that
passed
you,
the
reader
will
be
finished,
I,
say.
A
Yep,
so
that
this
one's
come
up
quite
a
bit
where
people
request
to
do
quite
a
bit,
you
can
do
it
right
now,
if
you
want
to
like
advance
it
a
X
amount
of
bytes,
but
you
have
to
calculate
that
yourself
and
it's
of
course,
pretty
expensive
or
can
be
as
opposed
to
just
setting
it
to
end
right.
Essentially,
what
it's
doing
internally
is
setting
the
end,
setting
the
current
position
to
the
end
of
the
sequence
and
saying
that
it's
finished
right,
there's
a
pool,
the
journaling
and
updating
the
consumed
account
and
all
that.
A
A
D
F
I
play
yeah
I'm,
anxious
I,
think
is
not
great.
I
mean
honestly,
like
offset,
is
probably
the
most
sensible
wrong,
because
offsets
are
usually
relative
to
something
where
the
user
not
just
relative
to
zero.
So
I
think
when
reader,
it
makes
sense
to
say
their
relative
to
where
you're
currently
at
right.
C
A
A
A
D
This
is
a
Ferrari
HP
Networking
for
parsing
up
form,
we
parse
and
then
the
peer,
so
you
do
a
token
equals
token
and
and
the
added
optional
there's
no,
and
you
want
the
entire
and,
in
sequence,
from
the
e
value,
this
key
equals
value
and
keepers
value.
The
last
one
doesn't
have
an
end,
you
scan
for
ants,
there's
no
and
you
grab
the
whole
and
in
sequence,
to
parse
the
end
of
it
last
key
value
here.
A
So
it's
really
a
convenience
than
Yoram.
You
can
do
it
right
now
is
giving
less
than
slicing
by
the
position,
but
so,
as
unread
span,
hundreds
bands
of
convenience,
one
as
well
so
they're
kind
of
they
kind
of
go
together.
Although
you
know
under
head
spam
is
the
current
section
when
you
know
hundred
sequences
everything
Oh.
A
A
I
C
F
A
D
D
A
D
A
F
C
C
C
C
M
A
So
whatever
you
have
methods,
I
guess:
I'll
get
my
heartache
now,
whenever
you
have
methods
like
this,
where
you
have
the
same
signature
except
for
out
something,
it
prevents
the
WTO's
out
the
bar
anywhere
like
it
means
that
you
already
knew.
You
have
to
explicitly
write
the
type
of
the
thing
that
you're
outing
and
there's
also,
potentially
the
risk
that
somebody
will
call
out.
On
the
same
instance.
That's
also
the
roughness
parameter
to
one
of
these
methods,
which
means
you
could
actually
be
mutating
this
struct.
While
these
methods
are
running.
A
D
C
A
F
F
I
But
we
already
have
api's,
where
out
is
the
first
parameter,
but
those
api's
have
optional
arguments,
so
the
other
alternative
is
maybe
we
make
out
T
and
how
do
we
only
spend
an
hour
in
a
sequence?
The
first
argument:
we
have
that
yeah
travel
to
32
has
out
sequence
or
span
as
a
personal
event
and
delimiter
and
then
advance
pass
is
the
optional
okay.
Maybe
so.
G
A
D
D
C
K
N
A
C
G
D
F
C
A
M
A
C
F
I
I
D
A
F
A
Of
an
overall
framework
design
guidelines,
what
happens
if
you
have
a
structure
type?
It
has
a
method
on
it
that
has
an
out
parameter.
That's
of
that
exact,
same
type
team,
because
that
could
allow
you
to
mutate
a
struct
while
the
method
is
actually
running.
Even
if
it's
a
restaurant,
which
we
normally
assume
can
never
happen.
A
I
ran
into
this
problem
with
utf-8
Spanos.
Well,
I
have
some
api's
about
a
utf-8
span
in
it
like,
oh,
my
god
they
can.
They
can
mutate
ref
this
while
it's
running
and
now
yeah
that'd
be
here.
It's
it's
a
feature
but
I
think
something
those
people
wouldn't
expect.
So
we
should
have.
We
should
at
least
consider
it
for
a
future
restraint.
H
A
C
A
P
I
C
A
The
other
part
of
it,
too,
is
that,
like
sorry,
which
I
didn't
really
think
of
until
it's
thinking
it,
but
like
the
the
ones
that
return
a
span
are
going
to
be
much
faster
than
like,
usually
much
faster
than
getting
the
sequence
and
turning
it
into
a
spam,
because
the
the
whole
thing
is
designed
around
the
fact
that
you
don't
cross
the
the
segments
that
often
so
quite
frequently,
when
your
try
picking
and
taking
a
span
out
yours
can
beginning
a
slice
of
the
current
spam.
Getting
the
span
out
is
pretty
expensive,
potentially
hugely
expensive.
A
A
D
C
Guess
the
situation
would
be
like
if,
if
I
unread
span,
which
I
understand
only
returns
the
rest
of
the
current
segment
right,
if
count
was
zero.
Sorry,
if
skip
was
zero,
then
try.
Peek
would
presumably
be
the
same
thing.
But
if
count
pushed
you
past,
the
current
segment
then
could
just
use
on
read
spanned
on
slice,
because
you'd
be
returning
the
wrong
thing
correct.
C
C
A
C
A
Try
copy
to
swirl
awkward
and
people
didn't
like
it.
That
was
the
original
answer
for
things,
because
then
they
have
to
me
and
it's
that
a
lot
of
cases
people
don't
care,
which
is
what
the
feedback
was.
They
don't
really
care
that
it
allocates
in
those
rare
cases.
They
didn't
want
to
optimize
it
that
far
it's
just
then
they
they
disliked
having
to
deal
with
it
themselves.
I
A
A
D
Think
the
questions
like,
for
example,
in
in
Kestrel
and
the
process
in
a
court
where
we
used
to
go
Sreedharan
or
new
sequences.
What
we
do
is
we
have
kind
of
two
cases,
one
case
where
we
do
the
whole
thing
where
you
know,
if
you,
if
you
are
in
a
single
span,
don't
copy
you
spend
dry-cleaning.
Otherwise,
if
you're
less
than
hundred
twenty
eight
bytes,
Colin
otherwise
report
the
issue
with
putting
data
physically
is
already
having
cyclic
inside
the
API
you're
forced
to
use
to
a
couple.
D
D
I
D
A
That's
actually
from
some
of
those
examples
is
where
I
went
ahead
and
made.
That
thing
to
essentially
to
array
is
really
the
the
span
has
an
optimized
one
that
like
looks
to
see
if
it
fits
within
the
current
span,
yeah,
and
then
it
basically
falls
back
to
the
one
that
returns
the
sequence
and
then
does
it
to
array
on
it.
It's
that's
essentially
the
logic
for
this.
D
Other
up
and
that's
kind
of
kind
of
what
it
is
that
you
can
have
an
empty
and
empty
segment
in
between
the
sequences,
which
makes
the
thing
super
painful,
but
the
reader
kind
of
papers
over
all
those
issues.
You,
if
you
try
P,
hey,
look
skip
over
a
connect,
D
sequence
in
the
middle
of
your
sequence,
but
hopefully
no
one
creates,
but
it's
in
case
it
happens.
If
you
try
P,
you
know
one
and
the
next
character
in
the
sequence
is
an
anti
character.
A
Yeah,
the
the
the
segment
crossing,
like
those
cases
that
he's
talking
about
in
particular,
I
mean
it's
difficult
anyway
period,
but
only
when
you're
having
to
cross
multiple
ones.
You
have
the
empty
ones
in
it.
You
know
that's
the
kind
of
level,
one
of
the
big
points
or
selling
points
of
the
secret
readers
that
you
just
don't
have
to
think
about
that
at
all.
H
K
A
A
B
I
F
A
Had
an
API
on
this
that,
like
outed
a
read-only
sequence
and
took
a
span
as
a
as
a
a
input,
is
a
optional
buffer.
So
you
had
to
provide
it
a
it.
Would
just
slice
or
use
the
buffer,
but
we
it's
really
awkward
to
communicate
how
to
use
that
we
can.
We
can
still
look
at
that
again
and
see
whether
we
can
come
up
with
a
reasonable
way
to
express
that
in
the
API
surface.
A
D
A
I
A
L
I
A
N
A
N
A
A
A
This
exists
for
other
ones
that
take
them,
but
if
the
sequence
position
isn't
actually
in
the
sequence,
you'll
you'll
air
out
and
you
go
backwards
with
the
safety
I.
Suppose
yes,
but
not
pass
all
only
in
one
API
there's
only
you
can
remind
that's
it,
but
you
can't
go
you
can't
back
up
before
the
current
segment
correct
you
can
it's
just
super
expensive.
A
F
A
A
I
A
Is
still
a
reference
back
to
the
origin,
the
sequent
is
you
see
the
sequence.
Reader
has
a
property
on
it
for
the
original
sequence,
okay,
the
sequel
reader.
Does
what
really
sequin
doesn't
know?
No
I
get
that
yeah,
oh
sequence
position.
Did
we
do
that
in
order
to
figure
out
quickly,
if
your
sequence
position
was
it
within
the
same
sequence?
Is
that
why
we
did
that?
Well,.
A
The
sequence
reader
itself
has
the
original
sequence,
and
then
it
has
two
additional
sequence:
positions
for
the
current
and
the
next
segment.
But
regardless
it
sounds
like
it
sounds,
like
sequence,
reader
has
as
a
contractual
guarantee.
You
can
always
back
up
to
the
origin
of
the
city
library,
because
if
we
also
expose
the
original
sequence,
that
is.
G
M
N
A
F
A
A
Like
the
typical
pattern,
like
certainly
from
the
originating
thing
and
what
most
people
are
using
it
for
because
they're
using
it
on
a
pipeline
yeah,
if
you're
getting
a
sequence
from
the
pipeline
and
you're
processing
data
from
it
and
then
you're
getting
a
new
sequence
from
the
pipeline,
because
you've
reached
the
end
of
the
data.
Yeah,
okay,
like
failable,
things,
are
basic.
A
Yeah
so
I
mean
there
is
a
cost
to
recruit,
to
creating
a
sequence.
Reader
and
effectively
set
position
is
doing
that
you're,
essentially
just
abstracting
the
fact
that
you're
creating
a
whole
nother
sequence
reader,
but
with
the
with
the
with
the
difference
being
that,
like
you,
have
a
different
start.
A
A
F
G
N
G
A
G
M
A
I
I
I'm
one
concern
I've
been
given
a
bunch
of
in
the
other
issues,
they're
a
bunch
of
API
is
they
were
taking
sequence
position
like
try,
peek
tried
monster,
etc.
We
didn't
populate
up
here,
but
once
instead
of
passing
sequence
position
to
this
type,
is
we
have?
Actually
you
don't
have
any
other
API
other?
I
A
A
With
pattern,
there
is
Mike
Reider,
you
know
so
like
you're,
you're
iterating,
you
you've
gotten
a
sequence.
You
created
a
reader
and
you're
doing
some
parsing
you
get
the
reader
back.
You
get
the
current
position
for
passing.
That
is
consits
consumed
right
on
when
you're
getting
the
next
sequence
from
the
pipeline.
You
have
to
tell
it
how
much
you
eat
out
of
the
current
sequence
and
that's
what
position?
That's
the
primary
thing
to
use
position
for.
That's
the
critical
one.
What's.
P
C
I
B
A
It's
just
this
would
be
the
first
time
that
would
be
exposed
on
this
thing,
but
because
this
is
a
wrapper
run,
read
only
sequence:
I,
don't
see
it
as
a
bad
thing
like
it's
a
passable.
So
no,
if
that's
not
the
critical
part,
the
critical
part
for
me
is
simply
that
it's
like
encourages
using
this.
In
a
way,
that's
not
performing
sure.
F
But
I
would
argue
you
just
gave
the
counter
example,
which
is
constructing
a
sequence.
Position
is
not
like
you
know
as
easy
as
possible
after
somehow
get
it
from
somewhere.
I
can't
just
new
it
up
easily.
So
I
think
that
that
is
that
means.
Generally
speaking,
it
will
probably
do
the
right
thing,
because
they're
not
easily
prone
to
just
compute
a
number
and
pass
it
in.
A
Always
always
resets
to
the
beginning
that
lingers
forward
correct.
No,
because
the
it's
it's
calm
so
like
we
would
want
the
second,
it
does
not
theirs.
Internally
speaking,
there's
an
object
and
an
index
essentially
on
each
sequence.
Position.
Yes-
and
you
know
in
our
internal
implementation
of
this,
we
would
be
checking
that
to
see
like
in
optimizing.
You
know,
you
know,
is
that
sequence
position
actually
in
the
current
segment,
then
we
can
do
it
pretty
fast
compared
to
like
seeking
outside
of
that,
we'd
have
to
scan
all
the
way
from
the
beginning
again.
So.
A
A
Well,
we
don't,
but,
like
we
call
length
on
there's,
Lake
County
folks
are
no
greedily
sequence.
So
what
if
we
actually
do
the
same
thing
that
you
did
for
the
Jason
api's,
where
we
don't
have
the
ability
to
seek
a
sequence
reader,
but
we
have
the
ability
to
clone
the
current
state
of
the
sequence
or
that
you
do
and
that's
the
way
you
do
it
now.
How
do
you
clone
the
sequence
reader?
It's
a
retro,
just
just
a
sequence:
reader,
the
sequence
reader
yeah,
it's
a
hundred
locks.
A
We
do
it
internally,
but
that
I
can't
do
this
across
in
a
way,
for
instance,
so
read
only
H
read
only
sequence
is
not
a
restaurant,
but
sequence.
Reader
itself
is
correct,
which
means
sequence.
Reader
can't
be
boxed,
for
instance,
but
one
Essen
did
for
the
json
api
s.
Is
he
introduced
basically
like
a
state
that
could
be
boxed
and
unboxed
and
the
idea
is
you
could
use
that
to
throw
a
copy
across
a
heap?
If
you
needed
to
and
it's
oh
yeah,
we
could
always
consider
adding
that.
A
A
But
yes,
you're
right.
If
you're,
if
you're
reading
in
a
loop
like
it,
this
sequence
is
going
to
change
so
the
primary
the
primaries
situation.
I
would
see
people
actually
wanting
to
use
that
position
is
like
calling
other
API
is.
It
actually
came
up
initially,
because
people
were
calling
index
of
on
the
read-only
sequence
and
wanting
to
set
that
for
sequence,
readers.
So
that's
one
thing.
P
A
Well,
that's
one
option
or
you
can
just
presuming
that
your
position
is
actually
post
where
you
actually
have
it.
You
would
forward
it
the
amount
of
bytes
that
are
to
you
they've
done,
and
you
can
calculate
that
by
getting
the
count
event
again,
that's
kind
of
expensive,
it's
not
terrible,
owning
underneath
the
covers
the
sequence.
Positions
are
just
like
indexes,
so.
A
The
way
that
you
would,
if
we
didn't
have
this
API,
the
way
that
you
would
see
is
you
start
off
with
some
sequence
or
you're
you'd
get
back
the
current
we'd,
only
sequence
and
the
current
spam
index.
You
persist
those
two
properties,
you
create
a
brand
new
sequence,
reader
of
passing
them
to
read,
only
sequence
that
you
persisted
and
then
call
and
dance
the
number
of
bytes
in
the
current
spam
index,
and
now
your
states
are
identical.
Well,.
N
A
Would
get
the
total
consumed
you
would
get
the
total
cousin,
not
not
the
current
spam.
No
current
span
index
that
property.
No,
you
wouldn't
you
would
get
the
curt
you
would
get
totally
consumed
from
current
span
in
ducks
No.
There
is
a
consumed
property
on
sequence,
reader,
yeah,
I'm,
not
I'm,
not
looking
at
that
property,
the
only
properties
I'm
looking
at
our
sequence
and
current
span
indexed.
That's.
A
A
A
I
So
it
looks
like
for
set
position,
even
though
setting
the
position
on
this
underlying
sequence
is
not
of
any
just
one.
One
setting
the
state
of
the
leader
requires
you
to
go
through
segments
anyway,
for
example
conceal,
so
it
becomes
all
and
for
the
number
of
seconds
you
have,
and
that
happens
all
this.
A
Wood,
if
you're
doing
it
yourself,
like
you,
know,
hacen
and
I,
looked
at
this
briefly
yesterday,
if
you
happen
to
set
for
a
position,
that's
in
the
current
segment
yeah
we
can
see.
That
is.
Is
there
a
scenario
where
I
want
to
back
up
to
a
position
where
the
sequence
reader
already
was
at
some
previous
point
in
time?
A
A
Community,
it
is
feasible,
you
can,
you
can
serialize
the
state
of
the
sequence
reader,
the
sequence
reader
is
generated.
The
constructor
of
the
sequence
reader
is
itself
generated
from
dog
restaurants.
You
know
the
old
like
be
loved
one
presuming
you
don't
care,
you
don't
have
to
cross
an
ASIC
boundary.
A
A
Now
there
there
is
more
state
in
this
thing
that
like
to
get
back,
that's
not
obvious,
there's
because
you
need
to
you
need
to
curtain
the
next.
Ok,
so
there's
four
there's
dissent:
you
have
the
original
sequence,
then
you
have
two
positions
and
consumed.
Is
another
part?
How
would
like
the
like?
You
can
recalculate
again
if
you
want
it.
F
Looks
like
set
position
requires
a
bit
more
thought
yeah.
How
about
we
just
remove
the
API
from
the
current
proposed
improve
the
rest,
because
it
seems
the
rest
and
nobody
has
a
disagreement
yeah,
and
then
we
just
come
back
with.
You
know.
How
do
you?
How
do
you,
basically
you
know
snapshot?
Then
you
zoom
effectively
in
an
efficient
way
right.
A
H
I
A
In
his
letter,
I
didn't
I
was
uncomfortable
with
the
set
position.
I
see
the
less
pages
it
makes
it
it
just.
It
makes
it
difficult
to
write
good
code,
and
it
also
like
makes
it
difficult
to
comprehend.
What's
going
on
in
the
reader.
What
performance
characteristics
of
things
are
more
difficult,
though,
very
hesitant
to
add
things
at
the
sequence
position,
but
serious
logging
and
they
move
the
concept.
A
K
I
K
F
F
F
K
F
I
I
was
mentioning
that
sequel
geo
is
meant
for
forward
only
in
line
with
the
one
API
that
we
added
for
escape
hatch
for
you
to
revert
so
after
you
have
to
remember
to
really
keep
a
copy
of
sequence
reader,
and
that's
the
only
one
that
has
these
so
perfect.
When
you
say
it's
Orion
like
what
is
the
end
number
of
segments,
no.
N
A
N
A
The
number
the
number
of
segments,
but
that
is
controlled
by
that's
a
one
of
the
most
the
most
common
scenario.
In
the
part
of
the
reason
we
added
it
soul
and
if
you
set
the
position
from
the
beginning,
but
the
most
common
scenario
is
that
you're
actually
not
going
to
be
crossing
a
psyche
as
a
segment.
So
that's
why
we
added
that.
P
E
F
A
Your
sequence,
reader
is
meant
to
be
used
in
a
loop,
which
means
you're
already
end
segment
in
because
the
learners
had
to
iterate
that
number
italians
and
someone
like
you
now
have
to
say
rewind
one
byte,
for
instance
like
if
someone
is
sending
new
data
chunked
one
bite
at
a
time.
They
have
now
coerced.
G
F
A
A
Most
of
the
time,
that's
true,
but
when
we're
designing
api's
that
are
intended
to
be
used
over
network
data,
for
instance
like
we
have
to
assume
that
the
worst
case
is
something
that
can
happen,
but
we
have
to
assume
that
the
worst
case
is
something
that
the
other
end
can
coerce
into
happening
with
high
probability.
I,
don't
know
that
you
can
do
that
with
a
read-only
sequences
to
have
it.
Your
Rita
Lee
sequence
is
a
sequence
of
buffers
that
are
not
remote.
A
M
F
Better
understand
what
I
mean.
My
point
is
just
rest,
kids,
who
would
obviously
the
API
call
people
to
the
other
API,
and
then
that
will
be
unfortunate,
but
you
know
there's
certainly
worse
things
we
have
done,
I
mean
it's
not
the
end
of
the
world.
I
mean
egg
I.
Think
I
can
even
consider
like
a
you
know.
Maybe
I
I
think
detecting
whether
in
off
set
of
five
pipes
within
the
same
segments
should
be
relatively
cheap,
though
right.
F
A
F
M
A
F
A
A
A
A
F
A
F
It's
just
not
going
because
it's
exploding
they're
having
to
be
rather
than
having
it
Wow
I
mean
this
was
more
to
the
I
mean
this
is
competing
things
by
this
usability
and
then
there
is,
you
know:
kenick!
Am
I
successful,
because
when
I
use
the
api,
I
know
that
I'm
not
accidentally
writing
myself
and
oh
and
square
about
them
right
and
I.
F
Think
the
problem
of
these
kind
of
API
is
is
that
I
think
none
of
them
are
designed
on
usability
from
the
point
of
view
that
if
you
really
just
want
to
parse
a
file
like
you
would
not
bother
with
easy
API
it's
because
there's
way
easier
ways
for
the
time
we
do.
The
exact
same
thing
yeah
like
if
you
care
about
profile
than
you
care
and
then
we're
willing
to
avoid
100
lines
of
code.
P
F
I
mean
on
the
outside,
though,
like
if
you
are
in
this
domain,
I
think
it's!
Okay,
if
you
use
a
sequence,
meter,
people
kind
of
have
to
have
a
mental
model
of
what
this
is
backed
by
right
like
it's
not
like.
You
can't
really
abstract
away
that
it's
a
linked
list
of
buffers
right,
that's
something
you
have
so
I
mean
once
you
look
at
your
performance
profile,
which
the
other
thing
is.
A
We
spent
a
great
long
long
time,
ass
on
I
mean
going
back
and
forth
on
this
thing
and
profiling
that
the
characteristics
are
reading
the
JSON
through
so
right
like
Pete,
it's
a
reasonably
educated
guess
but
like
about
like
what
the
performance
characteristics,
the
allocations
are,
but
we
did
find
that
it
was.
It
wasn't
worth
the
hassle
basically.
F
I
mean
the
other
question
is
like.
How
often
does
this
happen
right
if
the
buffers
are
reasonably
large
and
the
things
usually
get
out
a
reasonably
small
than
the
chance
of
you
actually
running
in
crossing
buffer
is
where
even
if
it
is
happening?
Well,
you
know
allocating
4k
you're
allocating
something
on
the
realm
of
like
100
bytes
like
and
in
a
case
like
who
cares
right,
yeah.
A
A
F
To
people
and
though
I
think
I
think
we
need
to
get
into
a
habit,
I
mean
used
to
turn
off
time.
Writing
you
know
one
line
useless
documentation
or
just
telling
people
like
who's
API
is
not
thread
safe,
which
is
true
for
99%
of
my
opinion,
that's
right,
but
what
the
extract
with
the
complexity
is
or
whether
allocates
or
not,
is
in
some
areas
and
much
more
useful
information.
If.
A
We
we
used
to
have
an
types
like
list
of
T
string
and
so
on.
We
would
actually
document
the
methods
as
a
whole
of
whatever
right
there.
We've
kind
of
fallen
out
without
helmet,
unfortunately,
but
for
API
is
like
this,
where
we're
promoting
their
use
in
high
performance
scenarios,
it's
important
for
people
there.
F
F
I
C
C
The
request
here
is
to
do
the
same,
with
boolean,
so
to
make
bold
bool
bi
formattable,
which
it
is
not
today
and
therefore
add
the
relevant
rule
to
string
that
takes
a
string
format
and
then
also
do
the
same
with
a
try
format
for
span
and
have
the
format
be
to
take
the
string.
The
whole
exact.
Thank
you
to
take
the
string
that
was
after
the
colon
and
allow
that
to
basically
contain
both
the
true
and
false
value
that
you
want
to
be
used.
G
F
G
G
G
F
M
H
G
String,
all
it
knows
is
semicolon
and
colon
and
cynical,
and
it
basically
does
a
split
and
the
first
half
is
true.
The
second
half
is
false.
Whatever
that
text
is,
is
the
request
here:
it's
not,
you
should
recognize
specific
patterns
like
on
and
off,
or
things
like
that
is,
you
should
take
any
string
and
true
should
be
the
first
half
and
false
should
be
des.
That
can
happen
for
notable
of
you.
It
doesn't
like
hold
out.
F
G
G
F
F
I
think
it's
it's
it's
less
ugly
than
a
function.
Call
like
all
I'm
saying
is
I
would
probably
just
write
a
function.
Call
like
I,
don't
know,
translate
or
some
other
method
that
I
make
an
extension
method
over
pool
and
Malibu
bool,
and
then
it
takes
two
or
three
arguments
and
I
be
done
with
it.
I
mean
yeah.
Why
would
not
be
horrible.
Q
N
Q
Q
P
P
F
Guess,
in
this
case,
I
mean
the
other.
The
other
types
are
by
definition,
open-ended
input.
Space
I,
mean
sure,
constraint
my
business,
but
practically
speaking-
and
you
know
n
number
of
ladies-
but
is
this
one?
It
only
has
two
states
right,
so
that's
a
boolean
only
has
realistically
two
ways.
Anybody
cares
about
so
neck.
Has
it
kind
of
is
not
you
know
horrendous
to
say?
Maybe
we
should
have
api's
ANBU
that
honor.
That
and
specialize
is
that
for
personal
reasons,
right
but
I
think
I
think
the
mechanism
is
just
the
wrong
way
of
doing
it.
F
We
really
really
care
for
the
scenario.
I
would
say
it's
still
better
to
have
in
an
extension
method
somewhere,
because
we
can
define
it
over
inaudible
as
well.
If
we
really
had
to
because
we
can't
put
it
anywhere
else-
and
you
know
for
bool
I
mean
yeah.
We
just
have
an
API
the
text
to
strings
and
gives
you
back
a
string.
I
mean
like
that.
F
That
I
mean
but
again
like
the
implementation
is
in
one-liner,
which
is
very
obvious
to
write
and
I
would
generally
say
if,
if
your
domain
has
to
do
something,
a
lot
I
think
it's
okay
to
say
yet.
Define
yourself
a
two
line:
helper
method
to
save
you'll
save
two
lines
100,000
times,
and
then
you
only
have
to
write
50,000
lines,
but
I
mean
that's
that's
what
programming
is
I
mean
we
don't
have
to
provide
every
single.
F
P
P
C
C
F
C
A
G
G
I
P
C
F
A
F
F
Basically,
because
API
suggestion,
so
the
idea
version
from
the
process
was
that
you
know
API
suggestions
are
basically
catered,
but
so
I,
okay,
what's
the
turn
shepard
by
the
area
owner
yeah
to
the
point
where
they
become
a
ready
for
you
right,
and
so
the
question
is
now
given
that
some
of
them
are
you
know,
years
old
and
there's
nothing
happening
of
those?
How
are
we
going
to
move
them
forward?
I'll
be
moving
them
all
to
the
new
repo.
Are
we
actually
cleaning
them
up?
F
M
F
H
F
And
then
we
should
just
push
on
them
and
then
you
know,
depending
on
I,
don't
know
when
the
repo
merger
is
happening.
We
could
do
this
before.
But
if
everybody's
busy
with
three
over
I
know,
maybe
that's
a
bad
time
to
do
it,
but
somewhere
between
now
and
then
we
should
do
it
and
then,
if
that
happens
after
the
merger.
Well
then
too
bad.
We
just
migrated
moistures
and
we
had
to,
but
even
that
it's
basically
get
up
on
the
back
end.
F
C
P
C
We
we've
been
a
little
inconsistent
about
API
suggestion
versus
API
needs,
work,
so
I
think
a
bunch
of
new
ones
that
have
been
opened.
I've
just
been
tagged
as
API
needs
work.
No,
so
we
basically
got
about
700
proposals
that
aren't
ready
to
be
reviewed
yet
and
I
some
of
them
have
been
sitting.
There's
this
2015
separate.
A
G
A
Together,
Ryan,
but
that's
actually
a
good
point,
though,
because
I
imagine
the
future
Airi
owners
are
going
to
have
are
probably
going
to
be
able
to
filter
out
as
a
first
pass
a
quarter
of
the
mating
and
then
for
the
remainder.
They
might
have
questions
that
this
committee
can
then
help
with
making
a
final
determination.
Maybe.
G
We
should
have
a
separate
label
for
identifying
things
which
are
suggestions
from
community,
because
I
think
that's
the
logic
that
the
bots
currently
using
for
and
what
some
people
are
using
for
like
if
this
is
just
an
API
suggestion
from
the
community
market
as
API
suggestion.
Maybe
we
should
have
something
separate
for
this
is
an
issue.
That
is
something
that
we
want
to
move
forward,
but
it
needs
work,
but
it's
not
been
reviewed
yet
I.
G
F
I
F
Yeah
I
think
that's
the
inconsistency
because
when
we
started
with
too
many
labels
I
think
moving
forward.
The
idea
is
an
API
always
starts
an
API
suggests
right,
but
even
that
to
me
is
kind
of
fishy.
Why
do
we
even
care
about
this
label?
Because
to
me
it's
like
there
is
somebody
filed
an
issue
for
the
area
on
that
everyone
has
to
decide
what
to
do
with
it
and
if
it's
a
bug
it
stays
open
as
a
mark.
G
I
guess
it's
not
clear
because,
like
I've
got
16
issues
under
numerix
that
our
API
suggestion
there's
a
couple
of
them
that
I'm
going
to
end
up
closing
is
I.
Don't
think
this
is
applicable,
there's
a
couple
where
I
think
it'd
be
good,
but
the
community
needs
to
come
in
and
write
a
proper
spec
proposal,
because
I
don't
have
time
to
do
it
and
then
there's
a
couple
where
I'm,
where
it's
a
good
suggestion,
but
we
probably
need
more
data
and
I,
don't
think
it's
necessarily
good
to
close
the
issue
on.
I
F
That's
it
that's
a
general
issue
that
we
have,
which
is
regardless
of
API.
If,
if
we
think
the
color
is
on
to
something
that
might
look
interesting,
but
we
are
not
the
ones
who
drive
it
for
that,
we
need
to
have
some
sort
of
label
that
says:
ok,
you
have
some
time
and
if
you
don't
reactor
will
close
automatically
because
I
think
it's
the
idea
of
like
okay.
F
G
Maybe
I
I,
don't
think
up
for
grabs
is
right,
because
a
lot
of
people
interpret
that,
as
this
issue
is
extra
grabs
to
be
implemented.
Yes,
not
I,
think
we
really
need
something
like
a
needs.
More
data,
yeah
tag,
yeah
we're
something
or
something
that
says
like.
We
want
more
input
from
the
community
on
why
this
is
a
good
idea.
F
That
we
could
do
that,
but
I
think
that
this
is
the
general
thing
where
I
think
what
is
the,
what
are
using
right
now
for
autumn
urging
when
CI
passes
like
that
same
board,
has
basically
the
same
thing
that
the
pro
board
has
for
stale
is
right
and
I
think
there's
some
controversy
around
when
we
close
issues
but
I
really
think
for
issues
waiting.
We
think,
okay,
the
the
the
you
know,
the
the
ball
is
on
the
core
of
the
issue
open
around
somebody
else.
F
You
have
some
time
we
can
agree
on
what
time
frame
is
with
that
sixty
days
or
30
days
or
10
days,
and
we
just
closed
it
and
it's
like
yeah.
So
you
had
time.
If
you
want
it,
you
can
be
open.
It
I
mean
it's
not
a
one-way
street.
But
to
me
it's
a
bit
weird
that
we're
in
the
state,
if
you
have
like
600
right,
800
or
900
open
issues,
and
we
just
create
effectively
work
for
ourselves
to
go
over
things
that
nobody
cares
about.
It
seems
like
backwards.
F
I'd
rather
spend
the
time
looking
over
things
that
anybody
actually
cares
for.
He
actually
make
the
product
better
and
I
think
that's
the
idea
of
like
basically
having
a
bought
clothes
things
it's
like.
Well,
you
just
focus
on
the
things
that
are
actionable
and
you
exclude
the
things
around
so
I
think
that's
a
gentleman
for
API
approach.
I
think
what
I
just
said
is
not
just
for
API.
F
Is
it's
for
any
issues
that
are
being
filed
right
if
somebody
files
a
buck,
that's
the
deal
with
didn't
nobody
can
reap,
or
nobody
thinks
is
important
same
thing
like
you
have
some
time.
If
you
don't
respond,
if
you've
gone
this
way
be
at
least
you
know,
this
is
what
we
used
to
do.
In
the
old
days,
I
mean
I,
centralized,
backed
records
and
I
think
it's
a
has
been
proven
to
be
at
least
the
process
that
we
stay
on
top
of
what
it
what's
going
on.
F
P
P
F
I
I
F
Closes
the
issue
needs
to
write
while
they're
closing
it
right
and
then
you're
busy
saying
well,
we
think
this
is
a
bad
idea
closing
and
then
well.
Somebody
opens
the
same
issue
again
like
nobody
said
we
won't.
If
you
don't
want
to
do
it,
just
keep
closing
it
right
and
if
people
are
just
you
know,
idiots
about
it
and
just
keep
opening
new
issues
at
some
point,
you
start
them
stop
or
you
kick
you
out.
Like
I
mean
this
is
not
a,
it
was
the
observation.
I
F
But
that
can
happen
right,
but
I
mean
sometimes
what
also
happens
if
the
first
person
does
a
really
bad
job,
explain
what
the
scenarios
and
then
the
third
person
who
does
a
good
job,
that's
also
fine
right,
I
mean
also
the
product
is
not
the
same.
You
know
in
every
year,
but
sometimes
or
our
priorities
shift
from
programming.
What
happened
to
us
I
mean
if
you
didn't
care
about
prop.
Originally,
nobody
really
deeply
care
about
perf
and
it's
also
okay
to
file
issue
again.
F
I,
don't
see
a
fundamental
problem
when
you
have
duplicates
over
like
for
six
years,
because
while
priorities
have
shifted,
team
members
have
shift,
the
strategy
has
shifted,
and
maybe
it's
actionable
now,
but
I
also
think
that
having
an
issue
that
is
four
years
old
and
open
forever,
like
it's
not
going
to
help
anybody
because
we're
not
going
back
and
assign
our
own
you
work
Oh
is
there
other
issues?
We
could
associate
this
work
with?
No,
it's
going
never
going
to
look
at
again.
F
That's
why
I
think
that
we
need
some
sort
of
like
mechanism
to
just
take
care
of
stale
issues,
and
ideally
we
have
a
label
that
can
say
yep
somebody
else's
on
the
hook
and
if
nobody
is
ever
responding
to
this,
we
just
closed
it.
You
say:
well,
we
gave
you
a
chance
and
then,
but
again
it's
not
a
one-way
street.
People
can
reopen
it
if
they
feel
like
it.
F
G
F
H
B
B
I
B
I
B
G
I
think
with
this
one
in
particular,
it
was
marked
up
for
grabs
because
we
weren't
going
to
prioritize
implementing
it,
but
it's
a
commonly
requested
enough
one,
but
it's
also
complex
enough
that
the
average
community
member
is
not
going
to
be
like.
Oh,
this
one
is
one
I
could
actually
go
and
implement
in
a
day
or
two
hey,
there's
whatever
student
ID,
you
give
it
for
Joseph
soon,
as
we
actually
end
up
doing
that
already.
F
E
F
Q
F
Basically,
we
should
probably
put
some
of
the
information
the
wiki
I
mean
we
do
have
the
API
review
process
written
up
I'm,
not
sure
they
actually
reflective
of
what
we
actually
do
now,
but
I
think
it's
still
somewhat
up
today.
I'm,
not
sure
I
think
parallel
wanted
to
write
up,
basically
what
the
tags
are
supposed
to
mean,
because
it
feels
quite
strongly
about
the
tags.
Yeah,
but
I
also
think
that
supposedly
get
another
major
revision.
Let
me
actually
merge
to
repose
because
we
want
to
have
a
unified.
You
know
labeling
strategy,
not
legging.
G
F
F
Yeah
other
Rosen
is
also
not
like
you
know,
actively
working
on
a
lot
of
things
that
are
fought
by
the
community.
In
terms
of
you
know,
api's
and
feature
requests
minutes
which
is
partially
I,
think
an
outcome,
and
you
have
the
backlog
that
be
all
right.
So
then
we
have
five
minutes
left
so
think
of
reference.
We
don't
do
anything
useful.
F
Anything
else
of
what
I
will
do
is
I
will
just
send
an
email
now
for
us,
an
email
ability
to
talk
to
the
end
of
like
when
the
right
time
is
to
send
that
email,
because
I
don't
want
to
serve
anybody
from
fixing
three
old
bugs
yeah
but
I
think
after
that
is
largely
one
down.
We
should
probably
do
triaging
of
the
remaining
issues.
F
F
G
Blog
post
should
be
part
of
a
series
like
I
imagine
what
we're
going
to
do:
a
blog
post
once
that
repos
emerge.
So
maybe
it's
a
subsequent
follow-up.
There
should
be
a
blog
post,
explaining
like
here's,
how
API
proposals
are
now
done,
yeah
and
it
can
explain
things
like
here's
the
recommended
pattern
for
creating
an
issue.
Here's
the
good
template
feel
free
to
log
issues,
questions
things
like
that
things
that
people
may
not
know
or
that
may
get
frowned
upon
on
other
repos,
but
we
say
are
okay
for
our
repo.