►
From YouTube: .NET Design Review: GitHub Quick Reviews
Description
Today, we're focusing on API reviews that are blocking partners: https://github.com/dotnet/corefx/issues?q=is%3Aopen+is%3Aissue+label%3Aapi-ready-for-review+label%3Ablocking-partner
A
All
righty,
so
let's
do
this.
It's
made
very
funny.
We
actually
are
live.
Yes,
we
are
because
I'm
using
a
new
tool
that
I
wrote
myself,
make
my
life
easier,
but
tools
can't
have
bugs
actually
when
I
write
them
all
right.
So
let's
first
go
over
these
two,
because
these
are
the
only
ones
that
are
marked
as
bill
blocking
a
partner.
So
the
first
one
would
be
the
immutable
one.
A
Hopefully
it's
pretty
straightforward,
so
any
proposed
that
we
should
expose
an
s
ban
and
s
memory
and
on
a
mutable
raid,
because
it's
effectively
like
an
array-
and
this
one
does-
you
know-
still
give
you
read-only
semantics.
So
you
can
modify
that
and
if
you
really
need
to
the
other
ones,
you
can
still
go
to
the
about
the
API
is,
but
we
have
some
sort
of
unsaved
API
where
you
can
get
the
underlying
array.
People
can
already
do
that,
but
it's
probably
not
what
we
want.
B
B
G
B
H
H
E
A
Because,
if
you
would
have
done
it,
we
would
have
put
this
in
to
interrupt
services
as
well.
I
think
the
conclusion
there
was,
if
you
really
want
to
do
this,
it's
trivial
to
write
yourself.
A
little
struck
that
does
the
explicit
layout
trick
to
fish
out
the
array,
and
then
you
just
do
an
unsafe
cost
effectively,
but
I
think
I
made
it
bigger,
actually
does
to
avoid
copying
the
array
all
right
so
yeah
anyway.
So
I
think
there
are
no
concerns,
and
it's
just.
E
B
A
A
B
E
E
E
D
D
F
C
A
G
C
A
C
A
A
A
A
C
A
A
It's
I
guess
that's
also
a
good
question,
but
again
step
assembly
in
this
context
would
just
be
the
code
you're
generating
right,
in
which
case
that's
what
I
find
T
of
them.
It's
a
bit
more
complicated
because
it's
like
a
board.
We
have
multiple
frameworks
that
are
all
you
run
in
depth
assembly
in
that
case
today,
I
think.
G
C
C
G
A
A
G
C
G
C
C
C
C
I
I
C
C
A
G
A
The
way
I
think
about
this,
maybe
that's
the
wrong
way
but
like
if
you
look
at
architecture,
I
would
say
it
just
indicates
effectively
what
what
CPU
we
are
running
on
right.
Logically.
Well,
if
you're
running
in
at
the
end,
then
it's
whatever
the
VM
is
using
right
and
then
I
would
say
that
if
we
have
multiple
one
time
so
right
now,
really
we
have
the
mono
or
one
time
for
assembly
that
uses
I
forgot
what
stuff
they
they
figure.
So
many
mothers
take
sea
bass,
one
time
the
day
that
they
ported
I.
A
Think
and
then
that's
what
interpreting
the
L
at
runtime.
If
we
build
a
different
thing,
let's
say
something
based
off
of
you
know,
warranty
or
something.
Then
it
would
just
have
different
TMS
for
that
image.
So
yeah,
just
you
know,
just
if
you
want
to
have
differences
between
implementation
implementation,
be
it's
not
specific
that
into
whatever
that
specific.
Whatever
the
bet
specific
checks,
you
would
have
to
do.
A
So,
in
that
sense,
I
would
not
care
that
there
are
different
runtime
implementations.
I
mean
it's
the
same.
What
we
have
today
with
that's
a
real
jet,
whether
they
had
real
jet
that
did
x86,
and
then
we
had
whatever
they
of
the
old
JIT
was
called
right.
And
if
you
were
woken
by
this,
you
just
do
a
DMM
check.
A
E
B
E
I
A
I
forgot
we
had
there's
a
few
API,
isn't
a
hermit
that
are
super
weird
and
much
of
its,
and
we
have
one
API,
but
maybe
that's
one
of
the
specialized
ones.
That
is
effectively
an
array
and
the
list
I,
don't
think
it's
this
one.
Yeah
I
think
this
one
is
just
the
tilde
sorting
by
key
in
your
index
bike
here.
There's
no
index.
A
A
A
B
G
E
B
A
B
B
C
B
A
I
don't
quite
understand
it's
like
somebody
making
voice
I'm
sure
learned
what
some
bad
on
this.
If
this
is
really
about
enumeration,
why
would
we
return
the
sword?
It
said
to
begin
with,
I
give
the
only
thing
you
do
with
a
numerator,
then
we,
it
would
be
much
much
easier
for
us
to
just
return
an
ienumerable
that
basically
stores
the
begin
at
the
end
key
and
reference
to
whatever
3
structure
we
have
so
we
can
always
emulate
that
without
doing
crazy
domestics.
My.
A
A
B
G
Think
the
idea
was
that
you,
wouldn't,
if
you,
if
you
gotten
a
numerator
you'd,
have
to
call
skip
which
right
and
spend
the
cost
inefficiently
of
iterating
for
things
he
didn't
need
either
a
through
the
ideas.
Since
it's
sorted,
you
could
do
a
login
operation
to
find
the
balance
and
then
given
a
numerator
that
just
thought
it
aerates
over
those
bounds.
C
B
So
I
like
there's
an
operation,
is
the
set
a
subset
of
another
one
and
to
do
that,
it
calls
get
a
view
between
with
min
and
Max,
and
then
it
loops
over
every
item
and
calls
contains
on
the
subset
on
the
gun,
the
view
between.
So
it's
actually
getting
kind
of
the
constrained
thing
and
then
calling
the
contains
on
it.
For
each
item,
I
see.
B
A
A
E
I
A
H
B
G
B
G
B
C
Normally
consider
view
to
be
similar
to
what
span
is,
which
is
you
have
a
reference
to
the
interior
data
and
the
end
of
the
data,
and
you
will
enumerate
through
it.
So
if
you
keep
track
of
one
through
three
and
someone
inserts
another,
two
now
you're
going
to
have
an
additional
value
that
you
numerate
yeah.
But
if
you
insert
a
zero,
then
what
is?
How
do
you
represent
that
without
changing
your
bounds?
Stay
in
well,
I
mean
you're,
still
tracking
the
starting
key
is
one,
and
the
ending
key
is
three
zero,
presumably
sorted
before
one.
C
G
G
And
then,
if
you
throw
away
that
late,
if
you
throw
away
that
idea-
and
you
say
okay,
can
it
take
your
cake?
Take
some
sort
of
copy
of
it
creates
an
oh,
like
an
N
sized
election
to
make
a
copy
and
have
its
own
independent
references.
Then
you
kind
of
throw
away
whatever
efficiently
meant
before,
because
now
you
haven't
like
ain't
unless
it's
slightly
in
general,
I
think
getting
a
view
between
is
probably
not
like
the
efficiency
you
get.
There
is
maybe
you're
sort
of
saving
I,
don't
I
mean
again,
maybe
yeah.
C
You
could
have
it
so
that
you
could
do
it
basically,
the
same
we
do
we
do
with
struct
enumerators,
which
is
keep
track
of
the
underlying
data,
keep
track
of
the
current
index.
In
this
case
it
would
be
start
as
well
and
then
keep
track
of
the
version,
and
if
the
versions
get
out
of
sync,
then
you
know
you
have
to
restart
from
zero
to
find
where
that
index
starts.
Otherwise
you
can
start
from
the
previous
start
in
that.
Yes,
so.
A
E
C
E
E
E
A
C
A
A
A
B
A
I
C
A
C
E
A
A
A
A
History
is
not
just
the
gap
right,
it
says,
like
he
mixes
strings
and
spans
right
and
so
like
he
just
doesn't.
He
just
want
to
use
him
in
his
third
argument.
He
just
slices
off
a
few
characters,
which
no
means
this
whole
thing
basically
chooses
to
expand,
overloads
and
now,
when
he
had
so
forth,
it
stopped
working.
A
No,
he
has
to
go
down
this
twice
Pam
but,
like
he's
not
really
a
additional
span
user
in
the
sense
that
he
is
managing
buffers
himself
right,
but
I
guess
like
yeah,
he
scooted
away
might
I
mean
unless
he
had
like
12
arguments.
So
there's
like
somebody
will
find
example
will
fly
right
and
I.
Think
at
this
point
it's
more
about
like
okay,
we
should
lose
to
be
consistent,
I
guess
of
ourselves.
A
E
A
C
B
A
Yeah,
the
I
would
argue
the
to
me.
I
would
separate
these
because
we
don't
know
what
the
timeline
is
for
the
other
one
and
the
other
problem
is
that
in
practice
we
already
have
a
ton
of
parents
in
the
framework
right.
So
like
that's
what
I
mean?
If
we
talk
about
legacy
api's,
we
have
a
ton
of
legacy
API,
so
one
more
would
not
make
a
difference,
but
at
least
until
you
get
the
feature
and
let's
say
you're,
maybe
user
I
mean?
Can
you
use
the
param
to
take
the
span?