►
From YouTube: .NET Design Reviews: GitHub Triage
Description
00:00:00 - Rejected: Add TransformationStatus enum from corefxlab https://github.com/dotnet/corefx/issues/22412#issuecomment-340833769
00:05:11 - Approved: Productizing APIs for {ReadOnly}Memory(T) and friends https://github.com/dotnet/corefx/issues/23862#issuecomment-340845398
00:41:10 - Approved: Add Overlaps/Within extension methods for ReadOnlySpan(T) https://github.com/dotnet/corefx/issues/24103#issuecomment-340856211
01:15:51 - Approved: Memory and ReadOnlyMemory validation errors not matching https://github.com/dotnet/corefx/issues/24296#issuecomment-340868030
A
B
A
D
A
C
D
F
D
C
G
D
C
D
C
Well,
so
Levi
initially
had
some
objections
and
then
he
kind
of
you
know
last
meeting.
He
said
that
he
conceded
after
looking
at
you
know
with
us
on
at
the
API.
So
I
don't
have
a
strong
opinion,
but
I
in
general
I
find
it
weird.
It
says
you
know
it's
still
open,
because
it
is
a
dependency
on
the
API
that
we
already
approved.
Well,
this
one
Steve
indentation
his
API
was
a
check.
C
D
C
D
A
I
What
is
this
one?
This
type
is
already
checked
in,
so
there's
two
questions
right.
The
first
one
is,
should
we
add
the
bulk
operations
that
we
haven't
span
like
fill
clear
copy
to
index
off,
etc.
A
second
is
we
want
to
discuss
where
to
use
a
span.
Mit
use
the
property
method
versus
a
property
for
span
to
memory,
convert
entire
memory
dimensions,
yeah
I,
see
I.
C
Can't
operate
I'm
kind
of
torn
I
understand
that
it
would
be
convenient
to
have
these
operations,
but
they
are
potentially
a
performance
trap
in
a
sense
that
getting
calling
these
operations
on
memory
can
be
expensive.
The
better
way
to
do
it
is
to
get
a
span
and
then
call
operations
on
this
path.
So
you
pull
several
of
these
operations
in
one
Star
Trek,
it's
better
to
get
this
fun.
If
you
call
just
one
they
are
pretty
much
equivalent,
but.
G
C
C
C
G
C
I
D
C
A
C
A
G
E
A
A
C
C
C
G
C
H
C
I
A
I
G
A
C
I'm
saying
that
there
are
scenarios,
there
are
many
scenarios
where
you
want
to
kind
of
cast
in
quotes,
cast
array
to
span
and
then
call
methods
and
for
memory,
it's
quite
rare
big
for
the
reason
that
we
were
just
discussing.
You
don't
call
methods
on
memory.
You
shouldn't
be
doing
this.
You
should
call
them
on
span
because
they
are
more
efficient,
so
usually
like
in
a
local
routine.
When
you
have
an
array,
you
don't
cast
it
to
memory
and
then
start
calling
methods.
So
what?
What
kind
of
message
are
you
calling?
Okay,
like.
C
F
G
C
H
G
H
A
H
C
So
to
me
it's
my
argument
is
not
that
one
is
rarer
than
the
other.
Calling
methods
on
memory
is
rarer,
for
the
reason
that
mine
is
to
get
a
span
out
of
it.
It's
basically
it's
a
factory
for
spans.
Therefore,
why
would
you
first
create
a
factory
and
then
get
a
span
out
of
it?
You
can
just
get
this
fan
into
three
squares
and.
G
G
C
For
calling
methods
that
take
parameters,
I
agree
with
you.
What
I'm
saying
is
very
often
there
are
two
different
groups
of
scenarios.
One
group
is
what
you
mentioned:
you'd
have
an
array
and
you
just
want
to
call
a
method
that
accepts
either
array
or
a
memory.
Yes,
both
of
them
work
the
same,
and
we
don't
need
an
API
state.
Just
we
have
castes
there's
a
second
group
of
scenarios,
which
is
you
have
an
array
you
want
to
wrap
it
in
something
and
then
call
methods
that
don't
exist
on
array
and
either
don't
whatever.
C
G
O
G
H
G
Span
and
slice
is
more
expensive
than
just
using
the
span.
Constructor
your
balance
check
twice
and
there's
there's
multiple
temporaries,
which
we've
already
seen
or
hurting
us
with
the
jet
zeroing.
So.
C
I
thought
we've
done
like
the
experiments
5
times
over
and
it's
not
true
that
they
are
expensive
I
by
the
way,
I
was
arguing
that
we
should
not
use
first
expand
and
then
slits
and
Yun
keeps
saying
that
they
are
equivalent
in
performance.
When
we
have
one
method
or
two
and
then
we
do
experiments
and
yannis
right,
I
will
does
pretty
good
job.
It's
not
a
sin
that
you,
like,
you
know
stupid
things
twice
in
a
row
and
then
just
gets
rid
of
one
of
them
and.
A
This
other
one,
some
high
level
thing
for
us,
because
I
hate
it
to
me
I
really
with
the
principal
amount,
putting
extension
methods
on
fives
but
I'm
like
its
original
purpose
types.
But
I
can
this
feature
area
like
I'm,
not
convinced
this
actually
would
be
bad
to
begin
with,
I
mean
if
you
feel
that
super
controversial
like
we
can
just
fund
the
extension
methods
for
now
and
see
you
every
landing
and
add
the
platter,
but
as
a
principal
it
strikes
me
as
like.
A
Arrays
people
don't
call
methods
on
arrays
that
much
so
it's
not
like
you.
You
know
thought
into
something
that
you're
surprised.
When
you
see
there,
it
seems
logically
erase
and
span
and
memory
they're,
all
related,
they're,
more
less
the
same
feature,
they're
all
types
of
the
same
thing.
Maybe
they
use
a
race
today.
A
Maybe
they
should
you
spend
a
memory
depending
on
what
they
do,
I
mean
they
seem
related
versus
some
of
the
stuff
we
talked
about
here,
like
extension,
methods
on
the
street,
Spano
buys
all
of
the
string
that
one
I
will
see
more
of
a
problem.
In
this
case,
it
seems
like
it
raised
substantially
low
level
enough
and
related
enough
that
I,
don't
think
I'm
just
generally
hesitant
to
do
like
almost
a
probabilistic
approach.
A
C
C
There
are
methods
to
cast
to
span,
but
not
to
memory,
and
then
we
have
a
choice
of
removing
this
from
span
right,
I'm,
really
not
a
fan
of
the
lot
the
ladder,
because
unless
we
do
what
Jeremy
is
proposing,
which
we
don't
have
a
cast
to
span,
we
have
a
slice
on
the
right,
but
we've
been
there.
We
changed
our
mind
on
it.
Unwinding
it
now
would
be
hard
because
the
pattern
of
toning,
like
men,
you
know
like
first
you
have
to
cast
before
you
can
slice
inside
that.
I
H
C
So
I
I
think
that
we
do
have
a
bit
of
a
problem.
The
code
is
very
busy
like
I
agree
with
Jeremy
when
I
write
code,
it's
exactly
the
same,
it's
always
as
found
slots
and
then
you're
trying
to
eat.
Like
you
know,
you
want
code
to
like
when
you
read
code
to
just
have
information
about
like
the
like
what
the
code
is
for
denim.
I
I
mean
that,
like
you,
cook,
Ian,
Paice,
you're,
sure,
they're
local
right,
if
you're
slicing
over
over
again
or
if
you're,
taking
a
span
insider
argument
as
an
argument
that
would
be
on
anokhin
method
that
you
were
sliced
once
or
yet.
You
can
dispense
once
you
know
there
do
a
spent
slice
over
and
over
again
have
you
asked
that
we
got
once
great
well.
C
A
A
G
O
K
A
A
G
C
F
D
A
D
D
I
P
C
Many
of
those
would
be
compacting,
I
would
say
like
one
of
the
principles
that
somebody
proposed
is
that
if
it's
a
conversion
in
the
broad
meaning
of
the
world
and
it's
fine,
otherwise,
it's
not
because
we
do
have
many
of
these
types
and
like,
depending
on
your
scenario,
you
want
to
kind
of
convert,
move
data
between
them
once
you
like
start
doing
like
something
with
the
data
like
the
index
off
and
sequence,
and
so
on,
you
should
use
expand.
That
could
be
the
principle.
C
A
M
A
F
D
A
D
F
Q
C
One
additional
thing
that
I
would
do
if
we
keep
the
methods
and
it
will
also
highlight
the
benefit
of
just
not
having
them
at
all.
I
think
we
want
to
memo
it
to
extensions
types
for
both
span
and
memory.
They
are
close
enough.
We
should
put
everything
on
like
you
know,
span
extensions
yep
and
that
memory
is
a
kind
of
span.
Can
we
yes.
C
H
H
A
H
P
H
You're
saying
kill
that
one
as
well
then,
and
then
I'd
kill
the
instance
members
to
like
essentially
Christoph.
Certainly
your
archives
and
Christoph's
earlier
argument.
Ire
delete
everything
on
the
screen
because
it's
just
faster
to
go
through
this
band,
or
at
least
it's
more
informative
to
this
man.
Now
the
other
argument
that
C
sharp
is
a
very
descriptive
cluttered
language,
and
so
are
these
worth
big
disagrees.
I
The
buck
appears
were
added
because
why
to
have
parity
between
span
and
memory,
I
think
emo
in
our
previous
description
mentioned
that
we
should
say
feed
both
us
on
the
same.
These
will
versus
for
completion
that
all
other
API.
If
he
hasn't
spent
transition
memory
as
well
and
as
memory
ones
were
or
F
sure
like.
If
this
explicit
operations
for
implicit.
I
So
copy
and
secret
sequel
etc
will
all
be
pocketed
in
the
same
reason,
which
is
very
deep
in
Spanish
abs.
Take,
for
example,
somebody
mentioned
how
they
copy
from
memory
to
another
memory
and
because
the
codecs
exceed
the
API
is
the
solution
was
can
expand.
You
can
do
it,
so
maybe
that's
a
learning
curve,
but
they
might
show
how
to
do
that
and
the
way
to
do
that.
Like.
H
I'm
personally,
fine
with
the
we
always
make
them
look
essentially
the
same
all
the
thing
everyone's
doing
is
saying
you
know
internally,
it's
dropped
to
span
and
do
the
thing
like
that's
fine.
We
just
need
principle
in
the
principle
of
saying
we're,
not
gonna
have
sequence
equal
cuz,
it's
faster
to
go
up.
This
fan
says
that
we
should
do
want
this.
I
H
C
C
C
A
C
G
A
F
I
F
C
B
A
H
D
D
C
Another
reason
to
rename
it
is
Steve
has
been
asking
for
us
to
design
extensions
on
spans
of
char,
like,
like
other
extension
methods
and
I,
think
that
memory
extension
kind
of
can
contain
lots
of
extension.
That
I
think
we
will
be
adding
more
and
more
extension
methods
and
it's
good
to
have
one
type.
That
is
a
grab
bag.
For
you
know
similar
extension
methods,
I.
C
C
I
J
I
C
I
G
I
H
A
A
H
Right
so
I
guess
a
whatever
aid
in
the
anti
AR
are
irrelevant,
yeah
quite
a
bit.
Well,
a
is.
This
entire
span
exists
in
before
that
entire
span
and
I.
Don't
I
can't
think
of
a
time
that
that's
useful
somebody
who's,
not
a
hacker.
So
the
old
crackers
I
can't
think
of
a
time
that
special
to
somebody
who's
not
trying
to
actively
break
your
code.
C
E
C
C
H
C
H
J
A
In
their
text
span,
which
is
basically
an
offset
in
the
length
determining
whether
one
is
opening
or
the
other
distribu,
because
he
just
happens,
but
if
you
write
the
conditions,
which
is
what
you
still
have
to
write
with
these
ins,
you
always
have
to
stare
at
this
like
for,
like
30
seconds
to
a
minute
to
determine,
did
I
get
the
monster
correct
because
it's
not
intuitive.
It's
like
oh
star,
less
than
like
it's
or
less
like
you
read
the
conditioning
like
it
took
me.
Always
five
tries
to
get
the
overlaps
into
secresy.
C
A
Like
it,
when
we
want
to
talk
about,
have
to
have
the
message
I
mean
like
people
could
do
it
to
do,
which
method
like
what
you
would
do
is
basically
a
tribute
you
just
you
just
extract
the
pointer
into
the
Delta
right
like
how
hard
is
that
for
the
caller.
It
is
hard
and
it's
unsafe
code.
Oh
we
can.
I
yeah
so.
C
The
the
reason
like
one
thing
we
should
talk
about
this
with
the
scenarios
are
so
overlap.
Like
the
moment,
you
have
talked
elapsed,
pants
and
you
want
to
move
data
between
them.
You
need
to
be
careful
how
you
do
it
if
they
are
not
overlapping,
then
you
kind
of
like
you
know
the
code
is
you
can
write
naive
code,
then
within
I,
wonder
whether
like
what
the
scenarios
are
even.
A
C
H
No
work
and
then
it
handles
like
oh
you're
copying
into
like
two
bytes
to
the
left
of
you.
I'm
gonna
shift
everything
that
way
and
it
handles
you're
copying
everything
two
bytes
to
the
right
I'm
going
to
handle
app.
So
these
two
cases
you
definitely
need
to
know,
and
then
certainly
it
can
just
pick
an
algorithm
between
these
two
of
like
a
you're
off
on
your
off
and
never
never
let
that
I
don't
care
what
you
do.
H
But,
yes,
when
you
need
to
know
the
overlaps,
if
overlap
says
true,
you
you
probably
want
to
know,
is
it
left
or
is
it
the
same?
It
is
a
lefty
overlap.
Your
righty
overlap
see
because
that's
gonna
change
do
next
right
or
left
like
that,
so
I,
just
so,
I
think
that
overlaps
with
overlaps
returns
false
you're
in
a
good
state.
The
moment
returns
true
you're
screwed,
unless
we
give
you
more
information
for
a
lot
of
that's
what
I
was.
C
Arguing
that's
like
in
majority
of
the
code
that
I
imagine
people
writing.
They
just
want
to
know
whether
it
overlaps
if
it
overlaps,
they
need
to
make
a
defensive
copy
and
if
it
doesn't
overlap,
they
can
call
like
base64
encoding.
Like
all
the
like
transformation
methods,
you
can
just
really
call
them
the
moment
it
overlaps.
H
C
I,
just
don't
know
how
to
design
an
API
that
like
returns,
you
you
know
something
different,
then
those
integers.
If
they
happened
to
be
an
array,
I
mean
that's
even
more
difficult,
API
to
use
I
mean
and
if
they
have
managed
right.
Yes,
the
integers
would
be
very
far
away
from
each
other
in
the
algorithm.
Your
higher
level
algorithm
will
tell
you,
don't
worry.
Yet
they
are
different
memory
locations.
You
can
just
don't
transfer.
Maybe.
I
H
You
have
like
the
say
us
covert.
I,
see
that's
fair,
because
you
know
the
length
of
both
things,
and
so
you
just
need
to
know
how
different
their
starts
are
right,
so
so
overlaps
false,
always
out
zero
and-
and
if
it's
true
it
outs,
the
left
distance
and
you
can
compute
the
right
distance.
If
you
need
it
so.
I
C
H
C
C
A
P
H
H
I
I
F
H
Its
overlapping,
its
with
it
I
think
you
know
that
said
Italy,
because
you
can't
just
say
if
be
downlinked
is
less
than
eight
it
like.
If
be
downlinked
is
bigger
than
it
out
links.
You
know
it's
not
a
or
it's
not
nested,
but
you
don't.
But
in
order
to
determine
the
true,
you
have
to
go
through
the
all
the
same
work
as
overlaps,
so
the
false
path
can
be
faster,
but
nonetheless.
D
H
A
C
H
C
C
H
C
G
N
R
G
C
H
C
E
D
H
H
C
H
A
C
I
C
I
C
H
H
F
C
H
I
H
C
S
C
D
S
D
G
M
S
D
C
H
C
H
C
C
F
H
H
D
H
M
C
H
C
H
A
F
F
Q
H
F
H
H
H
C
M
G
One
I
can
speak
to
this
came
about
because
Tim
had
put
up
a
PR
where
he
was
relying
on
memories,
constructor
to
validate
the
array,
offset
and
count
arguments
which
makes
sense
except
they're
named
differently.
So
if
they
fail
validation,
the
exception
that
gets
thrown
contained
the
wrong
parameter
names,
so
I
had
suggest
that
he
should
still
be
validating
at
the
call
site,
the
the
inputs
to
throw
the
right
exceptions.
But
then
you
know
we're
duplicating
checks,
which
is
unfortunate,
so
this
came
about
as
well.
G
You
know
you
do
the
validation
yourself
so
that
it
still
just
happens
once
or
should
we
not
care,
and
we
just
do
the
double
validation
or
should
we
not
care-
and
you
know
it
doesn't
matter
what
the
argument
names
are
you
get
an
exception
and
you
may
not
be
able
to
correlate
it.
It's
done
the
except
did
parameter
name.
H
C
C
Every
single
time
you
construct
an
here,
no
I
would
like
if
we
wanted
to
solve
this
problem,
so
one
I
think
solution
is
to
just
punt
this
problem
like
yes,
you
you
have
to
do
the
check
twice
and
you
know
because
you're
adapting,
like
some
existing
code
to
new
code,
you
have
some
inefficiencies.
The
second
one
is
I
kind
of
like
the
proposal
to
add
a
method
to
create
span
without
validating,
especially
for
arrays,
because
it's
not
like
memory
unsafe
I
would
just
not
put
it
directly
on
span.
I
C
C
S
G
What
goes
so,
I
look
at
the
beginning
of
any
method
today
that
takes
you
know
any
stream
read
a
sink
or
anything.
It
takes
a
byte
array
and
an
offset
in
account.
There's
like
four
checks
that
happen
up
front
where
it
says,
is
the
array
will
noooo
throw
argument
null
exception
if
offset
less
than
zero,
throw
argument
of
range,
exception,
etc,
and
then
it
says
you
know
new
memory
passing
in
those
same
arguments
and
today,
new
memory
does
those
exact
same
well
very
similar
checks.
I
A
A
O
A
Mean
the
middle
array
was
designed
to
for
perfectly
said
you
having
you
like,
you
get
a
slightly
different
exception.
Only
we
get
it
next
out
of
engine
and
yellow
I
get
actually
I.
Think
it's
an
accelerated
hope.
What
was
the
thing?
I
wonder.
I
think
this
nitrous.
What's
not
the
moment,
we're
happy
with
I
mean
they
said
screw
it
like
it's
it's
better
to
do
it
this
way
towards
the
double-checking
but
honestly
indexing.
You
do
way
more
than
you
do.
You
know
poke
operations
or
restraint,
so
I
mean
hopefully.
I
C
A
G
C
C
G
Mean
my
my
initial
inclination
just
looking
at
these
specific
create
methods
is
we
probably
don't
need
them,
and
we
just
you
know,
and
if
we
find
that
there
actually
is
a
measurable
cost
to
having
the
the
extra
checks,
then
we
can
add
something
later,
but
right
now,
I've,
yet
to
see
evidence
that
there
is
I
mean
you
know.
Part
of
me
doesn't
want
to
burn
any
extra
CPU
for
any
reason.
K
A
K
G
Well,
so
if,
for
that
separate
issue,
we
might
want
to
go
look
at
it,
because
we
already
had
an
issue
that
we
talked
about
about
where
we
put
these
things,
we
talked
about
having
some
sort
of
span
marshal
or
memory
marshal,
or
even
just
adding
them
to
the
existing
marshal
class
and
I
would
be
fine
putting
them
there.
The.
O
G
A
F
C
A
A
C
A
F
A
C
C
To
pin
things
they
probably
will
want
to
have
some
convention,
how
you
know
how
the
method
works
and
I
don't
know
if
they
like,
like
some
other
static
method,
another
in
another
type,
because
it's
difficult
like
how
do
you
tie
them
together?
How
do
you
know,
instance,
method
is
very
convenient.
We
just
have
a
name
and
when
you
call
fixed
this
method,
which
is
in
general,
hidden
only
which
we
would
hide,
or
it's
even
today,
hidden
on
I,
don't
I,
don't
remember:
I
hid
what
or
we
hid
one,
but
not
the
other
correct
I.
Think.
I
A
A
C
Yeah,
what
is
the
status
of
this
one?
Why
is
why
are
we?
Why
is
it
not
showing
on
the
list
or
any
minute?
Oh
okay,
where's
Marshall,
our
first
Marshall
came
up
with
that
yeah,
let's,
let's
rename
it,
let's
improve
memory
Marshall,
because
we
already
said
that,
like
we
gonna
have
like.
If
we
have
those
grab
bags
in
this
assembly,
we
use
the
memory
as
a
previous
just.
C
C
We
we
need
to
make
sure
that
the
checks
at
least
happen
at
some
point
lazily
and
not
just
like.
If
you
call
this
dangerous
method
now,
you
kind
of
can
write
and
read
over
all
over
the
memory.
Why
not
I
mean
literally
called
an
API
called
danger?
I'm
dead
I
mean
dangerous
means,
like
you
know,
but
you
only
had
the
dangerous.
I
A
G
C
And
you
also
have
length
and
the
dangerous
create
that
we
have
today
you
can
pass
arbitrary
like
for
it.
We
don't
do
any
validation
of
like
what
the
object
is,
because
the
thing
is
with
this
API
you
can
pass
an
array
and
it's
empty
and
you
can
pass
length
10,000.
Now
you
can
kind
of
write
over
some
memory.
That
is
not
even
part
of
the
array.
Yeah.
A
F
A
I
A
A
C
C
A
Q
C
C
You're
saying
sure
yeah
at
least
this
one
takes
an
array
so
like
potentially
at
some
point,
you
know
like
we
have
all
the
information.
We
are
not
doing
checks,
the
other
one
is
like
taking.
If
you,
if
you
add
new
analyzer
to
check
so
you
defeat
the
point.
The
whole
feature
of
there's
not
a
chance
because
they
were
have.
They
are
equally
dangerous.
So
by
not
adding
them,
we
are
not
buying.
Much
I
can
actually
say.