►
From YouTube: GitHub Quick Reviews
Description
Powered by Restream https://restream.io/
A
A
Yeah,
hello,
everyone.
So
today
we
are
looking
at
a
few
issues
in
our
backlog.
We'll
start
with
the
binary
data
proposal
that
I
wrote
a
spec
for
so
my
goal
would
be
to
just
go
with
the
document
or
parts
of
the
document.
I
should
say.
A
So
we
talked
about
most
of
the
stuff
last
time
already,
so
the
key
changes
from
last
time
is:
we
need
a
stable
api,
a
stable
api.
We
can't
ship
preview
right
now.
A
The
other
thing
I
added
was
effectively
just
the
assembly
name
and
the
package
name.
So
I
have
a
very
boring
approach.
I
just
took
the
core
type
name
and
made
that
the
assembly
and
package
name
because
that's
the
pattern
we
used
elsewhere
and
so,
unless
there's
more
questions
around
that,
I
would
just
try
to
use
this
meaning
to
just
close
on
the
api
so
effectively.
A
Last
time
we
had
a
slightly
different
proposal
where
I
try
to
make
everything
instance
methods,
so
we
can
use
extension
method
signatures
to
basically
factor
some
of
the
functionality
to
you
know
higher
levels.
A
I
think
we
convinced
ourselves
that
that's
over
engineering
or
not
really
necessary,
because
we
think
of
binomial
data
as
a
high
level
exchange
type,
not
a
low
level
thing.
We
would
use
an
ms
callip,
so
in
that
sense
it's
acceptable
that
this
thing
directly
depends
on
basically
adjacent
serializer
or
whatever
else.
We
need
the
primary
reason
why
we
do.
A
The
the
downside
to
using
constructors
is
that
they
are
named
right,
so
the
basic
problem
is
now.
If
we
have
something
like
this
signature
here,
where
we
have
basically
a
type
that
gets
serialized,
it's
somewhat
challenging
to
add
another
serializer
later,
because
now
we
would
have
to
somehow
manage
to
overload
this
thing.
So
one
way
we
could
do
this
is
we
can
overload
this
method.
You
know
have
another
argument
that
is
like
you
know:
serializer,
which
is
an
enum
or
an
abstraction.
A
A
The
linker
is
not
able
to
remove
one
of
them
if
you
only
use
one
of
them
because
it
can't
tell
which
one
you're
ending
up
using
because
you're
effectively
passing
in
the
thing
through
you
know
as
an
enum,
for
example
right.
If
you
go
to
with
an
actual
abstraction,
then
maybe
we
can
because
then
the
idea
would
be
that
you
construct
the
abstraction
and
then
the
abstraction
itself
depends
on
the
serializer,
not
the
actual
implementation
of
binary
data,
but
that
still
is
somewhat
challenging
when
you
think
about
defaults
right.
A
So
because
people
don't
know
this,
that
it
does
json
right.
It
says
it
here
but
like
if
you
actually
new
up
the
thing
you
don't
know
what's
happening
versus.
If
you
look
at
a
factory
like
it,
clearly
tells
you
what
it
does
right,
it
would
say
from
object
as
json,
so
it
tells
you
that
it
does
json
serialization
right,
so
there
shouldn't
be
any
surprises.
A
The
downside
of
the
factories,
of
course,
is
that
they
are
somewhat
less
discoverable,
because
you
know
you
can't
you
up
the
thing.
Last
time
we
said
binary,
there
was
a
struct
because
it
only
holds
on
to
effectively
a
single
pointer,
which
the
struct
can
do
just
fine,
but
that
also
no
means
that
structs
always
have
a
constructor
right,
the
implicit
one
that
doesn't
take
any
arguments.
If
you
make
this
a
class,
then
we
can
get
rid
of
the
default
constructor,
which
means
you
can't
get
cons.
A
A
My
personal
opinion
is
that,
given
that
this
type
is
designed
for
usability,
I
mean
that's
literally
its
only
goal.
Really,
it
doesn't
do
anything
that
you
can't
already
do.
It's
really
meant,
as
a
one-stop
shop,
for
people
to
effectively
convert
data
from
into
binary
representations
that
are
common
in
the
framework
without
thinking
too
much
right.
So
if
the
type
is
not
usable
enough,
then
it
no
longer
it
no
longer
realizes
its
values
right
and
so
that's
kind
of.
B
C
So
I
just
wanted
to
confirm
you
mentioned
earlier
that
you,
this
type
would
never
be
used
in
core
lib.
This
type
would
never
be
used
anywhere
in
any
of
the
shared
framework
right
pretty
much
the
only
place
it
would
exist.
And.Net
runtime
is
the
type
definition
itself.
A
Yeah,
so
that's
something
we
can
decide.
I
mean,
like
I
wouldn't
say
it
can't
be
used
anywhere
in
the
shared
framework.
It's
just
basically
because
of
depends
on
systems
of
system
text.json.
It
could
only
ever
be.
You
know
at
whatever
the
layer
is
that
system
text.json
is
right,
so
it
would
be
fairly
high
up
right.
C
Yeah,
I'm
asking
for
that
reason,
but
also
just
to
clarify
the
performance
goals.
If
it
really
is,
you
know
never
going
to
show
up
in
any
api,
anywhere.net
runtime,
that's
one
thing:
if
it
might
kind
of
you
know
sneak
its
way
in
somewhere.
I
fear
we're
going
to
find
ourselves
starting
to
talk
about
performance
on
the
type
that
was
never
designed
for
it.
D
C
Well
that,
for
the
most
part,
this
is
gonna
any
many
of
these
conversions,
or
some
of
these
conversions
are
not
cheap,
which
is
fine.
They're
not
supposed
to
be.
You've
got
your
data
in
one
representation,
and
you
need
to
marshal
into
another
go
from
a
span
to
an
array
like
that's
an
allocation
and
a
copy
of
the
whole
data
right
right.
D
C
A
Yeah,
so
the
so
the
way
I
think
about
this
is
and
christophe
can
chime
in
here,
but
the
way
I
understand
this
api
is
that
it's
really
meant
for
for
receivers
that
basically
dump
data
somewhere
else.
So,
for
example,
if
you
think
of
the
example
I
have
in
this
document,
is
you
talk
to
the
azure
queueing
apis
right?
That
just
add
a
cue
item
somewhere.
A
Fundamentally,
the
data
in
the
queue
is
a
binary
blob,
so
you
basically
get
to
pass
in
the
binary
blob.
But
realistically
your
data
is
not
in
binary
form
already
right.
It's
either
an
object
graph,
it's
you
know,
text
or
basically,
something
that
you
already
have
in
some
other
form
right
and
so
by
basically
just
giving
this
type
here.
Yes,
you're
right
that
some
of
these
overloads
here
end
up
copying.
A
A
So
then,
when
you,
when
you
pass
it
around,
given
that
the
data
is
effectively
stored
as
a
read-only
memory,
that's
why
we
have
this
two
bytes
method
here,
which
basically
gives
you
back
the
underlying
data
right,
and
so
it's
no
longer
copying
after
that.
But
yes,
you're
right,
the
initial
thing
might
not
be
super
cheap
to
produce,
but
that's
probably
for
the
purpose
of
the
api,
what
the
user
already
has
to
do
anyways.
So
it's
not
like
this
is
super
inefficient.
A
C
C
C
D
So
I
I
think
that
I
can,
I
think
I
can
clarify
or
add
something
here.
This
type
is
not
to
represent
a
kind
of
unified,
different
representations
of
binary
data.
So,
as
you
said,
you
know
it's
not
it's
not
a
type
that
would
represent
either
a
span
or
memory
or
byte
array
or
some
other
things.
It
is
a
type
that
makes
it
easy
for
people
to
convert
from
strings
and
objects
to
binary
data
and
the
other
way.
C
D
D
And
then,
therefore,
I
would
say
I
would
not
see
it
in
low-level
apis
that
you
know,
as
you
said
today,
take
read-only
memory
and
span
and
and
so
on
in
general.
I
don't
know
if
it's.
If,
if
you
know
we
would
never
get
pressure
from
people
to
add
it
to
some
other
apis,
but
I
would
say
I
I
see
it
more
in
apis
kind
of
in
asp.net.
You
know.
Recently
there
was
a
kind
of
set
of
extension
methods
that
use
http
client.
I
mean
extend
http
client
to
kind
of
send
and
receive
json.
C
Well,
that's
that's.
That
makes
whole
sense,
but
that
also
makes
me
think
like
what
we're.
What
we're
really
talking
about
here,
isn't
the
type
so
much
we're
talking
about
a
bunch
of
conversions
from
a
to
b
and
the
only
reason
we're
talking
about
adding
a
type
that's
instantiable
is
because
there's
you
know,
10
things
that
we're
converting
from
and
10
things
we're
converting
to,
and
we
might
want
to
add
more
in
the
future.
We
don't
want
the
full
product
of
all
of
those
yielding.
You
know,
100
methods.
F
G
D
No,
no,
no,
so,
actually
like
sorry
for
kind
of
interrupting
you
a
bit,
but
I
think
at
the
core
of
what
this
type
offers
is
that
it
would
show
up
in
signatures
of
high
level
apis.
So
the
the
reason
so
we
actually
explored
just
having
a
bunch
of
you
know,
helpers
for
let's
say
read-only
memory
of
bite
and
but
what
we
observed
in
usability
studies
you
you
probably
know
that
you
you've
seen
it
too.
People
basically
want
to
use
intellisense
to
discover
what
to
do
with
apis.
D
So
they
see
a
method
and
let's
say
the
method
takes
read-only
memory
of
byte
and
they
want
to
send
either
a
string
or
an
object
serialized,
and
that
and
now
they
are
like.
Oh,
how
do
I
get
read-only
memory
of
byte
from
a
string?
Let's
say-
and
you
know
some
people
know
how
to
do
it,
but
it's
you
read.
Only
memory
of
byte
is
a
new
api,
and
even
even
if
it
was
a
byte
array,
people
are
still
not
as
familiar
with
all
the
encoders
that
we
have
and
encoding
apis.
D
Now
we
developed
this
type
and
we
put
read-only.
I
mean
binary
data
in
signatures
of
these
methods
and
literally
all
problems
went
away
and
they
went.
They
went
away
because
you
know
the
user
sees
binary
data
in
the
signature
and
says
okay.
Well
then,
I
need
to
instantiate
binary
data,
they
call
the
binary
data
constructor
and
they
see
several
overloads
and
one
takes
a
string
and
one
takes
an
object
and
says
this
is
going
to
be.
You
know,
json
serialized
and
they
literally
just
you
know,
fly
through
the
api.
D
D
You
know
wants
to
get
to
deserialize
this
binary,
payload
and
get
you
know,
json
or
deserialize
json
object,
and
you
know
they
would
have
to
deal
with
all
these
apis
to
do
deserialization
or
encoders
decoders,
and
you
know
now.
C
D
We
basically
just
transcode
it
to
utf-8.
C
D
A
Yeah,
so
one
way
to
think
about
this:
is
that
really
what
this
type
does?
It
basically
allows
you
to
take
your
data
and
put
it
into
a
binary
blob
representation
right,
and
you
are
usually
the
only
party
that
retrieves
it,
so
it
at
the
end
of
the
day,
whether
you
a
code,
utf-8
or
utf-16,
is
kind
of
an
implementation
detail
anyway,
because
you
just
say
I
want
to
put
stacks
into
this
binary
blob
and
then
on.
I
want
to
retrieve
this
text
from
this
binary
blob
you're,
not
really
according
to.
A
C
A
Well,
but
the
thing
is,
you
see,
you
say
somebody
else
right
so,
for
example,
take
the
azure,
blob,
storage,
sorry,
the
azure
cueing
example
that
I
have
from
the
dock
right.
It's
a
public
api
for
the
queueing
layer
right,
but
you
are
the
party
who
put
stuff
in
the
queue
so
you're
also
the
part
that
retrieves
that
from
the
queue
so
long,
you're
consistent
with
what
what
you
use
to
retrieve
the
data.
It's
fine
right,
because
you
just
treat
this
thing
as
a
as
a
binary
blob.
C
Yeah,
I
think
steve
you're
actually
missing
a
little
bit
of
context
here,
so
I
think
you
missed
the
very
first
time
this
came
through
a
review
where
there
was
a
constructor
on
this
type
that
actually
did
take
object
and
the
opinionated
behavior
of
this
api
was
that
it
would
call
through
system
text
json,
because
the
api
would
be
locked
to
the
json
stack
and
one
of
the
pieces
of
feedback
that
we
gave
at
the
time
was
like,
while
this
might
be
fine
for
something
like
string
to
go
through
utf-8,
because,
like
that
encoding
has
won
the
encoding
wars.
C
Jason
has
not
demonstrated
yet
that
it
has
won
the
serialization
wars
like
it's.
There
are
competing
standards
and,
if
you're
serializing,
something
as
a
binary
blob
who's
to
say
that
in
two
or
three
years
time
the
world
would
not
have
moved
on
to
a
more
compact
binary
representation,
something
other
than
json.
C
C
The
json
example
I
was
citing
was
the
one
that
kristoff
brought
up
of
extension
methods
on
http
client,
that
post
data
as
json,
and
if
that
takes
a
binary
blob,
you
as
the
consumer
of
that
api,
are
creating
the
binary
data
to
hand
in,
and
the
consumer
of,
the
the
api
itself
needs
to
pull
out
those
bytes
and
know
what
they
are,
and
so
this
isn't
the
case
where
you're
both
the
producer
and
the
consumer.
In
that
case,
I'm
just
pushing
I'm
just
pushing
back
on
what
email
said.
C
A
Well
then,
I
would
say
those
scenarios
to
me
would
be
easy
to
justify
what
they're
out
of
scope
right.
I
mean
like
if
you
actually
just
use
hp,
client
to
publish
data
to
the
server
and
there's
no
interpretation
on
the
http
layer
on
the
http
layer.
It's
just
you
send
a
blob
to
the
server
and
then
on
the
servers.
You
do
the
exact
same
thing.
You
say
binary
data
from
that
payload.
A
B
C
Say
that
that's
out
of
scope,
I'm
concerned
about
this
type
showing
up
in
public
apis
anywhere,
not
everyone
type,
just
kind
of
bring
this
full
circle.
In
these
scenarios
we
have
the
content
type
header,
which
is
a
piece
of
metadata
that
exists
separately
from
this
type.
That
tells
you
how
to
interpret
the
type
without
that
secondary
piece
of
metadata.
You're
right,
you
wouldn't
know
how
to
interpret
this
unless
you
had
a
private
agreement
with
a
receiver.
D
A
Yeah,
I
mean
it
kind
of
like
I
mean
just
to
echo
steven's
point
though,
like
to
me
basically
there's
two
things
you
already
know
right.
One
of
them
is
because
of
our
civilization
dependency.
This
is
a
high
level
type
right,
so
we're
never
going
to
plumb
it
to
the
you
know,
all
the
way
to
the
bottom,
which
everybody
seems
to
be.
You
know,
okay
with,
because
it's
a
usability
type
after
all,
right
and
realistically
the
given
that
this
type
gives
you
the
ability
to
convert
to
any
other
exchange
type
you're,
never
really
cornered
right.
A
If
somebody
asks
for
memory
well,
you
have
a
way
to
produce
one.
Somebody
asked
for
a
span.
You
have
the
ability
to
produce
one,
so
the
question
really
becomes
like
what
what
are
good
use
of
the
api-
and
I
think
to
me
like
if
you
formalize
what
what
I
tried
to
express
you
earlier,
which
is
the
idea
that
you
use
it
in
cases
where
you
really
give
the
customer
the
ability
to
store
arbitrary
data
and
retrieve
arbitrary
data.
A
The
the
queueing
example
would
be
good
right,
http
client,
to
talk
to
an
arbitrary
rest
service,
probably
not
so
much
because
yeah,
you
have
to
know
what
the
server
wants
to
get,
and
this
type
doesn't
allow
you
to
do
that,
and
I
also
would
argue
that
we
probably
shouldn't
make
this
tribe
do
that,
because
then
the
type
gets
more
complicated
and
then
it
kind
of
loses
its
primary
value.
Prop.
D
Yeah,
I
I
think
another
way
to
say
it
is
it's
mainly
for
user
data,
it's
not
for
the
protocols
data,
but
even
users.
Data
is
basically
utf-8,
because
users
just
operate
like
well.
Let's,
for
starters,
they
use
the
utf-8
json
parser.
I
mean
writer
to
write
the
data.
So
it's
going
to
be
utf-8
and
then
they
just
store
it
as
utf-8.
D
Yeah,
but
I
mean
I
you
know
in
general
steve,
I
think
your
main
point
is
about
not
complicating
low
level
apis.
That
already
have
many
representations
of
bytes,
and
I
I
completely
agree
with
that.
I
don't
see
this
type
as
a
universal
representation
of
bytes.
I
see
this
type
as
a
helper
for
converting
from
using
json,
serialization
or.
C
A
A
C
Yes,
I
think
that
matches
what
we've
seen
too
from
usability
studies.
I
wonder
if
I
wonder,
if
there's
a
way
for
us
to
like,
if
someone
tries
saying
new,
some
type,
to
have
some
kind
of
intellisense
mechanism
that
says,
oh
by
the
way
like
here's,
how
you
actually
create
an
instance
of
this
like
something
that
just
kind
of
guides
people
toward
the
right
thing.
A
I
mean
we,
I
mean
you
can
basically
by
just
providing
an
analyzer
or
a
code
fixer
right.
So,
for
example,
a
code
fixer
can
work
on
any
code.
The
code
doesn't
even
have
to
compile
right.
So
you
could
say
if
somebody
says
new
binary
data,
you
know
of
data,
you
can
say:
oh,
you
can
suggest
to
replace
that
to
bina
data
dot
from
bytes
right.
A
The
problem
with
that
is
that
I'm
not
sure
that
fixes
usability
issues
because,
as
christoph
said,
right
people
don't
don't
code
like
that
right,
they're,
basically
open
intelligence
and
they
make
decisions
based
on
what
they
see
right.
They
don't
type
in
arbitrary
code
and
then
try
to
make
it
work
right.
So
I.
A
Is
a
I
mean
we
have
seen
this
so
many
times
I
mean
the
the
system.
Text.Json
example
was
was
perfect,
but
when
we,
when
we
tried
the
serializer
type
and
all
the
static
methods
we
had,
none
of
them
were
main
class
and
dcl,
as
they
all
were
called
like.
A
You
know,
to
string
or
parse
or
load
or
whatever,
and
we
could
observe
people
not
calling
any
apis,
because
they
were
just
trying
to
figure
out
which
one
to
call
right,
and
so
I
think
like
if
you,
if
you
create
these
pauses
people
just
are
stuck,
they
don't
know
what
to
do.
It's
pretty
bad.
C
Yeah,
the
the
best
workaround
I
can
think
of
is
provide
a
constructor
immediately
mark
it
obsolete
as
error
and
then
have
it
inside
the
error
message
like
say
hey:
this
is
how
you
do
it.
Instead.
A
A
I
mean
there
is
an
experience
you
could
do,
which
is
kind
of
like
I've
seen
this
in
reshapper,
for
example,
they
have
this
smart,
complete
mode
where
you
can
basically
say.
Oh,
I
need
the
binary
data.
Let's
say
you
call
the
method,
it
takes
a
binary
data
and
when
you,
when
you
basically
writing
the
argument
for
the
method
and
you
control
shift,
space,
resharper
will
suggest
things
that
are
in
scope
that
can
produce
the
binary
data.
That
includes
also
factories
on
the
same
type
and
so
the
intellisense
immediately.
A
You
would
see
binary
dot
from
bytes
and
from
object
and
all
of
that,
but
we
don't
have
that.
So
I
think,
but
that
would
be.
I
think,
the
right
ui
metaphor
to
deal
with
that,
but
I
am
generally
hesitant
to
design
apis
with
the
assumption
that
we
will
have
tooling
at
some
point
when
the
stooling
doesn't
exist
and
it's
very
hypothetical
if
the
tooling
exists.
I
think
I'm
fine
with
saying
that's
not
how
people
write
code
anymore,
but
I
think
that's
not
the
case
here.
C
If,
if
I
remember
correctly,
the
the
big
pushback
toward
having
constructors
to
to
create
these
things
rather
than
factory
methods,
was
that
we
were
considering
a
constructor
that
just
took
object
and
it
wouldn't
be
apparent
that
that
was
json
serialization.
Would
it
make
sense
just
to
leave
that
off.
A
I
D
I
D
D
For
example,
we
discovered
some
scenarios
where
a
subtype
would
be
better
when
it's
returned.
E
D
So
so
you
know
it
could
be
class,
but
having
said
that,
going
back
to
the
constructors,
I
think
basically,
the
three
main
scenarios
for
this
type
is:
I
have
an
object.
I
want
to
serialize,
I
have
a
string,
I
want
to
encode
and
I
have
a
biter
and
I
just
want
to
pass
it
through,
and
I
think
we
should
have
these
three
constructors.
D
C
D
D
D
You
know
an
instance
of
system
text,
json
serializer
change
the
settings
and
then
pass
it
to
this
type
and
say:
hey,
don't
use
your
own
13
default.
Serializer
use
this
one
and
very
often
it's
done
to
basically
do
some
transformations
and
conversions.
D
A
I
mean
in
principle,
I
think,
that's
a
good
idea,
I
think
in
practice,
given
that
we
have
only
effectively
like
11
days
left
before
we
have
to
ship
a
stable
api.
I
don't
think
that's
the
best
time
to
basically
design
and
sealed
as
an
abstraction,
because
we
have
no
way
of
previewing
it
and
my
conference
of.
B
D
D
J
A
D
H
H
But
if
the
signature
ties
the
jason
serializer
options
into
it,
then
at
least
now
you
have
a
target
that
is
obviously
this
is
jason,
it's
not
as
clear
as
a
named
method,
but
at
least
now
it's
not
taking
the
best
overload
and
and
hand
waving
for
what
later
made.
You
know
yeah
like
anything.
We
have
right
now
that
uses
xml
when
somebody's
like.
Why
is
it
using
xml
in
10
years
I'll
be
like?
Why
was
this
using
json?
It's
like
well
go
back
in
time.
D
A
So
I'm
not
following
this
one
crystal:
are
you
basically
saying
because
it
had
it
takes
an
additional
parameter?
That
is,
but
you
would
make
it
optional
right,
which
means
the
call
side
still
wouldn't
tell
you
right.
D
A
J
A
H
J
H
Again,
we
want,
like
the
generic
inference,
is
very
helpful
in
this
case
the
the
understanding,
what
you're
doing
when
you're
calling
this
constructor
the
notion
that
if
you
had
a
byte
array,
typed
as
object
that
when
you
give
it
to
the
constructor,
it's
not
going
to
you
know
de-alias
the
type
it's
going
to
jason
serialize
your
byte
array,
as
opposed
to
transport.
Your
byte
array,
like.
D
Unfortunately,
the
implications
of
removing
this
constructor
are
the
following:
people
see
the
other
constructors,
they
have
an
object,
they
want
to
serialize
it.
They
see
in
signature
of
some,
let's
say,
service
bus
method,
binary
data.
D
A
Yeah,
I
think
that's
kind
of
like
I
think
the
question
is:
where
do
you
draw
the
line
right?
I
think
so
clearly
with
async
people,
you
have
to
make
the
leap
of
faith
that
people
will
discover
the
the
aesthetics
right
because
there's
no
way
to
make
them
asynchronously
work
right.
So
the
question
is:
if
you
are
an
async
context,
do
we
believe
people
get
that?
Oh
yeah
new
is
just
one
way
of
doing
it?
Another
one
is
aesthetic
right,
that's
question
one!
A
I
mean
you're
basically
saying
well
it's
advanced
scenario,
so
people
should
be
able
to
do
that,
but
I'm
not
sure.
I
completely
agree
with
that,
because
we
make
async
kind
of
very
popular
for
most
people
already
right.
The
the
other
question
is
like
yeah.
If,
if
we
remove
the
civilization
constructor,
I
I
completely
agree
that
it's
it
looks
weird
if
part
of
the
data
can
be
constructed
via
the
constructor.
The
other
part
can
be
constructed
only
via
factories
right
now.
The
split
is
basically
only
for
things
that
are
async
in
nature.
A
So
the
only
thing
that's
missing
from
the
constructor
is
the
stream
one
right.
Everything
else
is
also
on
the
constructor
so
like
at
least
you
get
a
when
you
do
new
binary
data,
you
get
a
sense,
for
you
know
99
of
the
data
that
you
can
actually
construct
it
from
right
and
then
it's
just
oh
you
don't
want
to
do
it
synchronously
you
want
to
do
it
asynchronously
sure
factories
might
be
then
the
next
step
but
yeah.
I
think
if
we,
if
we
really
want
to
move
the
construct,
the
the
civilization
constructor.
A
C
You
know
to
take
a
look
at
what
I
posted
in
chat,
where
you,
if
you
introduce
an
intermediate
type,
even
something
like
a
struct,
you
could
actually
have
the
word
jason
appear
somewhere
in
the
constructor.
The
idea
is
that
you
would
have
new
binary
data
new
json
data,
and
then
you
would
pass
in
your
object
there.
A
I
mean
I
think
that
satisfies
what
crystal
said
earlier
about
using
intellisense,
to
discover
things.
I
will
say,
though,
like
if
we
ship
this
api.
The
immediate,
like
reaction,
will
be
that's
very
tedious
right
because
you
have
to
type
a
lot
of
stuff
here.
A
A
C
So
let
me
let
me
explain
the
problems
that
I'm
trying
to
solve
here,
and
maybe
this
is
the
wrong
way
to
solve
them,
but
the
the
problems
I'm
trying
to
solve
are
a
like
when
you,
when
you
create
the
thing
you're
led
by
intellisense
to
just
start
typing
and
as
long
as
you
follow
intellisense
you're,
going
to
be
led
into
the
right
world
right
and
b,
we
don't
have
the
type
implicitly
tied
to
a
particular
serializer
without
the
word
jason
being
somewhere
in
the
method.
Name.
C
B
A
I
mean
I
would
say,
like
the
question
really
comes
down
to
you
know,
I
think
we
believe
that
jason
was
not
going
to
be
the
last
civilization
format
right
because
well,
we
already
have
others
right,
but
the
question
is:
if
you
assert
that
it's
literally
just
for
give
me
some
bytes,
I
don't
actually
care
what
they
are.
I
just
want
my
object
to
be
in
there
and
I
won't
be
able
to
retrieve
it
later.
A
I
would
like
to
have
it
like
you
know:
20
bytes
right.
So
if
we
assert
that,
then
do
we
think
that,
still
in
the
same
ball
game
as
oh,
my
god
there's
another
sailors
are
coming,
we
have
to
support
them
everywhere,
because
I
feel
like
for
things
that
are
protocols.
It
makes
sense,
because
people
choose
different
things
at
different
things,
but
here
it
seems
more
like
well,
it's
a
black
box.
So
as
long
as
you
can
get
the
bytes,
what
you
put
in
you
should
not
care
whether
it's
json
or
not.
A
D
D
You
know
it
was
a
good
suggestion
because
we
will
have
to
make
the
the
the
options
parameter
be
not
defaulted,
so
it
cannot
be
lost
and
then
you
know
future
serialization
technologies.
You
just
we
add
them
without
the
defaults.
It's
not
ideal,
but
I
think
it
works,
and
I
still
I
think
I
was
talking
about
this
in
the
last
review
of
this
type.
D
I
do
believe
that
usability
of
the
type
has
to
be
the
highest
when
it
ships
for
the
first
time
once
there's
enough
critical
mass
of
customers
who
learn
how
to
use
this
type.
What
it's
for
what
it's
about,
then
additions
are
kind
of
easier.
They
don't
have
to
be
frankly
as
easy.
So
yes,
the
additional
serialization
options.
Somebody
would
have
to
pass.
H
D
D
H
A
H
H
I
want
the
messages
to
be
smaller,
so
they
fit
into
an
azure
queue
message,
because
it's
terrible
when
you
have
to
split
it
or
indirect
it
that
now
what
you
have
is
the
majority
of
cases
are
passing
protobuf
serializeroptions.default
as
the
second
argument,
just
so
they
can
get
the
which
constructor
overload
was
I
trying
to
call,
and
that
means
that
we
burned
the
default
on
the
thing
that
people
don't
want,
and
we
expect
they're
going
it's
going
to
be
the
thing
they
don't
want
within
a
relatively
short
amount
of
time.
Having
said
that,.
D
We
would
still
add
the
factory
methods
for
protobuf,
which
means
people
kind
of
already
understand
the
type
understand
this.
You
know
what
what
what
it's
about,
and
now
we
just
have
a
blog
post
and
say
we
now
support
protobuf2
and
by
the
way,
there's
a
factory
method,
and
you
don't
have
to
pass
the
options
if
you're
happy
with
that
with
the
default
right.
D
Can
we
discuss
one
more
thing
that
I
think
is
a
leftover
from
from
having
the
serializer
abstraction,
so
we
used
to
have
serializer
abstraction.
As
I
explained,
we
removed
it
because
it
doesn't
exist
in
the
pcl
and
we
kind
of
like,
I
think,
manually,
just
converted
the
apis,
which
means
we
have
async
apis.
D
Do
we
need
async
apis,
given
that
now
it's
basically
a
built-in
system
text,
json
serializer,
because
it's
just
serializing
objects
in
memory
to
a
buffer
in
memory?
There's?
No!
I
o
going
on
there's
no
reason
to
call
async
apis
when
we
had
the
serializer
abstraction
we
needed
to
have
async
apis,
because
some
implementations
of
the
abstraction
actually
do
io
as
they
as
they
serialize
for.
D
A
D
Something
so
yeah
so
because
one
of
the
one
of
the
implementations
of
the
abstraction
was
a
serializer
that
communicates
with
the
schema
registry.
So
schema
registry
is
a
service
that
stores
schemas.
A
D
And
during
serialization
the
serializer
would
actually
go
hit.
The
service
retract
retrieve
the
schema
and
validate
that
everything.
You
know
that
the
object
matches
the
schema
or
the
payload
matches
the
speed
gotcha
right
now,
since
we
don't
have
the
abstraction,
the
people
serializer.
Basically
just
you
know,
serializes
data
in
memory.
Therefore,
no
io
is.
H
When
you-
and
I
talked
yesterday
at
least,
we
talked
about
from
object
as
json
and
two
object
from
jason.
Instead
of
just
to
object
and
from
object.
B
A
D
C
A
A
Yes
yeah,
so
it
seems
like
if
you
can
go
implicitly
to
read-only
memory.
You
should
be
able
to
get.
You
know,
implicitly
to
read
only
memory
and
so
to
read
only
span
as
well.
I
understand
that
going
from
a
memory
to
a
span
is
not
super
cheap,
but
it's
still
an
one
operation
right.
It
doesn't
do
any
copies.
C
Correct,
it's
still
all
one.
I
don't
think
we
actually
have
many
types
in
the
framework
that
are
implicitly
convertible
to
read-only
memory.
I
think
I
think
we
say
that
they're
implicitly
convertible
to
spam,
just
because
it's
used
in
more
places
and
we
have
like
dot
as
memory
methods.
If
you
really
wanted
the
memory
out
of
it.
H
Yeah
I
mean
our
our
general
stance,
I
mean
it's.
A
written
guideline
is:
don't
have
an
overload
that
allows
a
read-only
memory
or
a
read-only
span
as
alternative
options.
I
mean
this
violates
that,
but
because
yeah
basically
right
now,
if
you
said
so,
if
you
said
new
binary
data
of
binary
data,
I
think
it'll
actually
yeah
it'll
json
serialize
it
because
object
is
better
than
the
implicit
conversions
and
if
we
got
rid
of
the
object
constructor,
then
it
would
fail
to
compile
so
yeah.
H
Really
it's
a
question
of
how
many
types
are
going
to
be
like
this
and
ignore
the
guideline
to
not
overload
a
cross,
read-only
memory
and
read
only
spam,
I'm
not
sure
jeremy.
Can
you
repeat
what
the
guideline
exactly
says,
because
I
don't
see,
I
think
it
was,
do
not
overload
across
read-only
memory
and
read
only
spam,
but
let
me
look
up
the
exact
wording,
but
where
is
it
overloaded.
H
A
D
D
D
D
Yeah,
so
we
may,
we
may
debate
this
one.
This
one
doesn't
bother
me
as
much,
but
I
think
a
constructor.
I
I
wonder
whether
josh
again
josh
ted.
What
do
you
think
about
removing
the
constructor
that
takes
a
span
I
mean
span?
Is
such
a
you
know,
low
level
and
still
exotic
type,
and
I
wonder
whether
we
want
it
in
a
type
that
is
optimized
for
kind
of
high-level
usability
scenarios.
A
D
C
A
D
Yeah
and
that's
another
reason
why
I
think
maybe
we
should
remove
the
one
that
takes
a
span
and
now
the
semantics
are
actually,
you
know
more
uniform
for
the
constructors
and
then
faction
methods
are
a
bit
more
advanced
and
they
can
have
in
intellisense,
basically
describe
what's
happening.
C
D
C
C
Stream
as
a
constructor-
oh
I
I
sorry,
I
thought
I
must
have
been
looking
at
something
else.
Sorry,
it's
a
factory
method.
H
Yeah
yeah,
so
the
the
one
that
takes
object
and
the
one
that
takes
string
are
both
making
copies
because
they
have
to
turn
the
data
into
bytes.
But
so
I
guess
they're
actually,
both
making
you
know
translations,
but
the
yeah
and
the
guideline
for
not
overloading
across
read
only
memory
read
only
span
is
avoid
not
do
not.
D
C
B
C
Yeah,
so
what
what
I
wrote
in
chat
is:
that's
actually
the
what
I
did
with
utf-8
span
as
well.
Like
I
I
say
it
always
copies
unless
you
call
the
explicit
factory
that
says
don't,
but
I
I
mentioned
this
earlier,
but
it
got
lost
like
if,
if
you're
really
looking
for
something,
that's
really
really
high
performance
zero
copy.
I
think
the
appropriate
way
to
do
that,
as
has
already
been
established
by
the
framework,
is
in
your
apis
that
communicate
directly
with
azure.
D
Yeah,
but
this
one
the
problem
is:
suddenly
you
have
so
many
copies
you
basically
to
read
from
a
network
stream.
You
have
to
create
a
byte
array
and
read
from
it
and
then
you
pass
it
to
this
type,
and
now
it's
gonna
make
yet
another
copy
of,
and
then.
C
D
All
you
know,
or
else
it's
we
don't
want
to
be.
H
H
H
Right,
well
so
the
I
mean
so
the
weirdness
here
really
is.
If
you
have
an
object,
which
is,
I
don't
know,
some
simple
type
that
has
two
arrays
as
properties,
disregarding
the
fact
that
we
suggest
not
having
erasers
properties.
If
you
say
you
know,
dot
array,
a
sub,
zero
and
change
the
value
after
calling
new
binary
data
of
the
object,
that
is
not
visible
in
the
payload,
but
if
you
pass
a
byte
array
now
that
is
visible
in
the
payload,
so
we
have
two
of
the
constructors.
H
H
D
People,
but
I
think
there's
you
know
so,
of
course
you
know
the
constructor
detects
object
and
a
string.
The
payload
is
not
stored,
the
same
there's
a
transformation
going
on
the
other
ones.
Well,
that's
how
array
behaves
I
mean.
Hopefully
we
are
not
saying
now
that
arrays
are
unsafe
in
clr
or
in
c
sharp
erase
a
self.
And
yes,
you
need
to
be
aware
that
you,
when
you
pass
a
race
around
whoever
passed
the
array
in,
can
mutate
it
I
mean
that's,
that's
c
sharp.
A
I
mean
it
seems
to
me
like
bo.
I
mean
if,
if
both
the
the
the
the
byte
array
one
and
the
only
memory
just
wrap,
then
in
both
cases
you
would
observe
the
modification
to
the
underlying
data
right
and
then
in
string
and
objects
cases
like
well,
you
have
the
data
in
a
different
shape,
so
you
would
be
hard-pressed
to
observe
any
differences
there.
Anyways.
B
B
H
A
If
we
have
one
that
just
wraps,
I
think
it's
fine
and
I
think
like.
If,
if,
if
those
are
rapping
and
those
are
rapping,
then
it
means
in
the
default
case.
People
wouldn't
accidentally
make
copies,
because
the
object
one
and
the
string
one
like
I
think
it's
fine
to
say
it
kind
of
implies
that
there
are
copies
right,
because
they
have
no
way
of
actually
wrapping
the
thing.
K
What
if
I
have
some
what
what
if
I
am,
I,
I
guess
we're
intending
more
advanced
scenarios
like
I'm
operating
on
chunks
of
data,
to
use
something
like
binary
reader
instead.
D
D
H
Right
now
we're
back
to
what's
the
purpose
of
the
type.
If
it's
something
like
the
azure
sdk
is
I'm
I'm
going
to
store
something
for
you.
It
stores
it
in
bytes.
Give
me
a
thing.
I
will
shove
it
in
storage.
When
I
give
you
a
thing
back,
I
give
you
this
and
then
you
you
do
the
inverse
of
whatever
operation
you
did
to
make
one.
J
K
A
A
E
D
No,
I
don't
think
so,
memory
stream
when
you
wrap
an
array
in
memory
stream,
we
don't
copy
the
array.
K
I
think
memory
steam
is
a
very
specific
scenario.
That's
at
the
far
edge
of
what
most
types
like.
If
you
use
any
of
the
collection
types
you
give
an
array,
it
gets
copied.
A
A
A
But
I
think
the
scenario
is
very
similar
right,
so
memory
stream
is
not
a
type
that
lives
long
right.
It's
a
type
that
you
that
you
have
temporarily
because
you
want
to
you
know
either
read
data
in
a
stream
fashion
that
you
already
have,
or
you
want
to
basically
expose
like
sync
something
into
it.
Right
and
binary
data
is
very
similar.
It's
not
a
thing
that
will
live
long
in
the
app
right.
A
It's
basically
an
interim
type
that
you
use
to
basically
transcode
data
into
it
in
a
convenient
fashion
and
then
have
it
stored
somewhere,
like
collections,
are
different
right
collections
are,
are
permanent
things
in
that
live
for
very
long
time,
potentially
in
your
process
and
they're
very
often
part
of
an
object
model
where
modifications
do
need
to
be
observed
and
stuff
like
that,
so
that
I
think
that's
why
they're
very
different
behaviors,
like
things
that
hang
around
you,
you
don't
want
side
effects
right.
D
H
H
B
I'm
sorry
there
is
a
conversation
in
chat,
a
class
versus
type
where
levi
says
most
people
believe
it's
a
struct
and
then
jeremy
says
I
think,
we're
solely
on
a
class.
Yes,
so
let's.
E
H
Yeah,
I
guess
now.
C
D
D
H
If
it's
unsealed
with
no
virtuals,
the
only
thing
you
can
do
is
yeah
change.
What
the
constructors
do
on
the
way
in
you
can't
change
what
to
object
from
json
or,
as
it's
currently
called
to
object,
as
jason
can't
like
you
can't
change
that,
because
there
was
nothing
virtual,
but
sealed
class
does
mean
we
have
the
option
of
doing
unsealed
with
virtuals.
H
Later
unsealed
class
means
that
if
azure
sdk
thinks
it's
easiest
to
make
a
you
know,
cubased
data
type
that
extends
binary
data
as
the
return,
so
that
you
don't
have
to
always
pass
the
json
serializer
options
that
it
you
did
it
with
the
type
name.
Instead
of
with
the
second
parameter,
then
it
gives
you
that
ability,
but
again
you're,
probably
just
calling
the
static,
and
you
would
just
call
a
different
utility
static
that
passed
in
the
options
and
called
the
one
that
you
wanted.
So.
A
H
A
H
The
compiler
passes
it
with
call
instead
of
culvert,
if
it's
question
mark
dot,
and
it
already
knows
that
the
that
it
couldn't
have
already
been
null
for
reasons
and
therefore,
if
you
change
it
to
virtual
later,
it
won't
virtual
dispatch
until
they
recompile.
So
are
there
any.
C
A
C
H
H
All
the
crypto
methods
that
have
virtual
you
get
a
you,
get
different
argument:
validation
on
every
subclass
and
yeah.
As
we
all
know,
crypto
was
done.
B
H
B
H
That
works.
I
wish.
D
B
C
C
A
I
mean
you
can
basically
make
that
like
it's
like
subclassing
is
not
just.
You
know,
for
basically
it's
storing
it
in
in
a
union
fashion
right,
it's
really
more
for
shortcutting
the
constructor
right.
So,
for
example,
let's
say
I
have
protobuf
binary
data
right
and
that
my
constructor
just
does
portable
civilization
and
then
calls
the
base
constructor
with
read-only
memory
right
and
then,
instead
of
going
factory-wise,
I
can
just
still
new
things
up.
I
can
say
new
protobuf
binary
data,
foo
and
then
the
right
things
are
happening,
and
that
seems
useful
right.
A
A
H
F
A
D
H
A
D
D
H
C
H
H
C
L
H
Just
telling
you
what
the
guidelines
have
said
for
since
kristoff
wrote
the
first
book,
it's
it
says,
do
not
depend
on
to
string
when
you're
when
you're
calling
it
jeremy.
That's
that's.
C
L
So
one
quick
question
about
the
name:
what
was
it
two
object
as
json
that
should
have
been
a
from
okay
yeah,
I
feel
like,
as
is
kind
of
confusing,
and
from
might
be
a
little
bit
safer,
yeah.
I
I
I
just
had
a
question.
I
guess
this
is
mostly
for
ted
and
kristoff,
but
so
like
for
for
the
azure
libraries
we
we
still
want
to
support
from
objects
and
from
object
async
that
work
with
object,
serializer,
how?
How
would
we
actually
implement
it
with
this
new
model?.
L
D
L
The
only
thing
is,
basically:
if
we
do
subclassing
would
we
want
to
subclass
it
ourselves?
I
personally
don't
think
so,
and
I
don't
think
we
have
a
scenario
for
subclassing
this
on
the
azure
side,
so
I
would
actually
push
back
against
leaving
it
open
to
subclass
from
our
perspective,
but
I
yeah
we
can
solve
our
our
specific
stuff.
C
What
about
hubble's
earlier
suggestion
of
having
a
specific
constructor
that
is
a
zero
copy
constructor
for
the
incoming
payload.
H
D
They
do
different
things,
I
mean,
there's
a
you
know
two
of
these
constructors,
that
do
they
do
transformations
right
like
we
all
understand,
this
is
not
copy,
but
no,
but
this
is
not
copy.
Correct,
like
as
josh
was
kind
of
saying.
Clearly,
none
of
them.
None
of
them
do
really
a
copy,
because
copy
implies
that
the
data
doesn't
change.
It's
just
getting
copied
from
one
place
to
another.
H
Well,
but
but
this
is
actually
an
implementation
detail
that
leaks
into
the
surface
of
if
the
object
constructor
held
the
object.
Until
you
called
one
of
the
two
methods,
then
it
would
be
if
it
was
holding
the
reference,
then
mutations
would
be
visible
right
up
until
you
actually
executed
the
transformation,
but
the
transformation
happens
in
the
constructor.
So
now
two
of
the
constructors
are
immune
to
mutations
on
the
next
line
of
code
and
two
of
the
constructors
are
not
okay,
like
that's.
That's
the
level
of
you
flip.
H
These
two
lines
of
code
does
does
something
change.
It
depends
on
what
the
type
was
that
you
passed
into
the
constructor,
and
I
can
understand
this
model.
I
can
wrap
my
head
around
it.
Probably
most
people
can
very
few
people
actually
attempt
to
mutate
things
after
they
pass
it
to
something
like
this,
but
it's
like.
If
you
do
new
binary
data
of
something
in
the
array
pool
and
as
long
as
this
object's
alive,
you
still
have
a
reference
to
the
array
pool
like
or
the
array.
That's
in
the
array
pool.
A
H
H
You
call
new
binary
data
of
the
read-only
memory
of
the
slice
of
your
stuff
in
the
array
pool
right,
you've
returned
your
finally
returns,
the
thing
to
the
array
pool,
but
the
thing
that
you
returned
this
to
put
it
into
a
queue
to
get
around
to
uploading
it
later
now.
Something
else
takes
that
array
out
of
the
array
pool
starts
mutating
it
right.
F
H
F
H
F
H
If
you
feel,
if
you
thought
it
did
a
copy,
if
you
thought
it
did
a
copy
or
every
time
you
tested
it,
it
always
got.
You
know
synchronous
completion,
so
the
data
was
immediately
uploaded
and
you
never
saw
that
it
went
into
a
queue
and
had
a
delay.
You
never
see
the
corruption
and
then
you
hit
production,
and
now
you
now
there's
actually
load
in
the
queue
you
get
enqueued.
Instead
of
immediately
sending,
and
now
you
get
data
corruption.
A
H
H
Just
that's
the
weakness
that
I
see
of
the
current
model
like
or
sorry,
the
biggest
room
for
bugs
that
I
see
is
using
array
pool
or
any
other.
A
C
H
C
A
D
A
But
even
in
that
case,
right
most
customer
code
is
probably
safe
too
because,
as
I
said,
like
the
most
likely
thing
you're
going
to
do,
is
you
call
an
azure
api
or
something
like
that
right
and
then
pass
the
data
into
that
and
they
basically
send
it
over
the
wire.
So
when
they
return
to
you
well,
then
you
are
done
and
then
you
know
that's
the
end
of
it
right.
You
don't
need
like
as
long
as
there
is
a
party
or
there's
there's
no
party
that
holds
on
to
these
things
for
a
long
time.
I
H
A
H
D
D
C
A
C
C
E
A
A
So
in
terms
of
next
step,
then
so,
given
that
we
kind
of
run
out
of
time
for
this
type,
so
we
will
assign
the
dev,
we
will
basically
implement
this
as
fast
as
we
can.
I
didn't
hear
any
pushback
on
the
assembly
name
or
the
package
name.
So
that's
what's
going
to
to
happen,
the
thing
will
obviously
target
net
standard.
I
didn't
say
that,
but,
like
that's
kind
of
implied
so
or
net
center
2,
I
should
say
anything
else
or
does
that
remove
all
uncertainty
in
doubt.
A
So
yes,
if
you
already
so,
I
wasn't
sure
whether
you
have
an
implementation,
if
you
have
one
by
all
means
shared
with
us,
that
makes
it
faster
for
us
to
implement,
but
yeah
I
mean
the
idea
is
that
we
own
the
package
moving
forward
right.
So
we
would
own
the
bug
fixes
and
whatever
comes
with
that.
D
H
D
D
H
A
J
Yeah,
this
is
gonna,
be
easy.
It's
basically
just
exploding
two
instructions
in
arm64
base,
isa
that
allows
to
get
up
or
64
bit
of
of
264
bit
numbers
multiplied,
it's
similar
to
what
bmi
2
does
on
intel,
but
it
only
produces
upper
64
bit,
not
not
upper
and
lower
lower
64-bit
bars
of
the
multiplication
results,
and
it
also
supports
a
signed
version
which
I
believe
is
not
supported
by
intel
and
while
seeing
that
is
basically
like
allows
to
implement
big
mal
methods
using
the
snippet.
I
also
wanted.
J
A
Well,
I
mean
one
of
them
was
hotter
than
the
other,
so
there
is
that
environment
process
path
is
jan
still
on
the
call.
H
Yes,
you
have
camera
with
no
audio
yawn.
F
A
F
A
B
A
Then,
what's
the
next
one,
I
think
similar
one
right,
the
manage
threat
id
same
idea.
I
suppose
right
yeah.
H
H
Maybe
I
mean
I
guess
one
thing
I
don't
know
that
it
was
in
the
issue.
Do
we
know?
Are
those
yeah
two
separate
diagnostic
codes,
or
do
we
want
to
put
them
together
into
one
diagnostic
that
you
either
want
on
or
off
with
performance
rules
or.
F
I
think
we
had
some
discussion
about
it.
I
I
think
the
you
know
whether
have
like
one
id
for
all
of
them.
I
think
the
the
discussion
was
leaning
towards
a
kind
of
grouping
them,
let's
say,
have
all
the
ones.
Maybe
all
all
these
three
together
make
sense,
but
you
know
if
there
is
another
pattern
say
for
I
don't
know
file
stream,
then
maybe
it
should
be
a
different,
different
analyzer,
because
if
it's
a
different
kind
of
class
of
apis.
H
Yeah
my
recommendation
for
the
ones
that
we
just
introduced,
the
new
environment
accessories
for
at
least
the
two
that
we
just
saw,
is
if
you
would
want
them
to
be
turned
on
or
off
at
the
same
time
like
that,
you
say,
show
me
all
my
performance
improvements.
I
could
make
that
we
should
just
bury
them
in
the
same
diagnostic
id
so
probably
means
the
same
analyzer
and
and
the
same
fixer,
but
at
least
the
same
diagnostic
id.
F
By
the
way
we
have
just
introduced
a
similar
analyzer
while
I
go
for
environment
processor
id,
so
I
would
assume
that
it
should
just
use
the
id
for
that.
One.
H
A
I
think
in
general,
like
I
think
we
should
be
able
to
add
to
the
diagnostic
id
it's
just
that
it
needs
to
be
the
similar
case
right
so,
for
example,
for
obsolete.
We
said
if
the
api
is
part
of
the
same
op
solution.
Logically,
then
we
just
reuse
the
existing
obsoletion
id
right.
It's
like
it's.
You
know
it's
not
a
runtime
breaking
change,
it's
more
like
what
do
you
expect
the
developer
to
want
when
they
already
suppressed
one
of
them
right?
Would
they
would
they
expect
the
new
one
to
also
be
suppressed?
A
If
so,
we
use
the
existing
one
like
if
you,
if
you
don't
want
the
existing
one
to
suppress
this
one
then
make
a
new
one,
but
I
guess
for
all
these,
you
know
shortcut
helpers.
If
you
don't
care
about
one
of
them,
it's
probably
fair
to
say
you
don't
care
about
any
of
them
right
like
it's
really
about
what
what
expectations
do
you
have
when
somebody
suppress
that,
but
it's
not
a
breaking
change.
A
All
right,
so
I
think,
is
carol
on
the
call
like
jeff
is
out.
I
think
I'm
here
emo,
oh
you're
there,
okay
cool,
then,
should
we
look
at
the
one
from
jeff,
the
yeah.
F
A
M
It
looks
like
this
is
not
networking
specific
but
more
just
streams.
Yeah.
We
can
skip
this
one.
I
mean
like.
H
It
would
probably
get
the
parameter
name
wrong
for
buffer
being
null
but
yeah.
Otherwise,
yes,
so
you'd
still
have
to
do
a
argument
null
check
on
buffer.
But
then
you
could
yeah
just
use
the
span,
memory
or
array
segment,
constructors
and
they'll
validate
offset,
and
I
think
they
may
call
it
offset
and
length
though
so
again
the
name
may
be
a
problem.
A
M
Yeah
we're
just
adding
an
api
that
kind
of
went
missing,
just
adding
an
ip
endpoint
overload,
so
people
don't
have
to
pull
out
the
address
support
manually.
G
A
K
H
M
I
M
The
usage
we
see-
typically,
people
will
not
need
a
task
like
a
value
task
performance
is,
is
worth
it.
H
H
M
We
we
had
a
similar
question
when
adding
some
socket
apis
and
came
to
the
conclusion
of
having
two
separate
overloads.
So
I
think
it's
consistent
to
do
that
here.
A
A
All
right,
then:
okay,
we
skipped
the
one
from
jeff.
So
then
levi,
I
think
you're
on
disabled
private
reflection.
C
Yeah
so
there's
an
attribute,
the
disabled,
private
reflection
attribute,
it
doesn't
do
anything
in
core.
We
should
obsolete
it.
The
you
you
apply
the
attribute
when
you
want
it.
When
you
want
the
runtime
to
have
a
side
effect
of
preventing
things
like
activator.create
instance
calls
to
a
particular
type
inside
of
an
assembly
but
in.net
core.
We
don't
consistently
respect
it.
So
if
the
only
reason
to
apply
the
attribute
is
for
the
side
effect-
and
we
don't
do
the
side
effect,
nuket.
H
Me
either
is
it
we
don't
respect
it
or
we
don't
consistently
respect
it
and
if
we
don't
consistently
respect
it,
what
does
it
do.
C
So
it's
I
believe,
it's
tied
to
the
kodak's
security
infrastructure
as
an
implementation
and
because
we
don't
really
call
the
cas
infrastructure
anywhere
anymore
yeah.
So
the
like,
I
said,
the
original
goal
of
it
was
to
prevent
things
like
activator.create
instance
of
a
particular
type
that
was
listed
as
non-public,
but
again
like
in
core
those
code.
Paths
aren't
activated
so
yeah.
H
Okay,
yeah
like
if
it
does
nothing
aside
from
anything
where
anybody
themselves
is
inspecting
it,
then
I
would
say.
C
C
Yeah
so
I
had
listed
here
that
we
could
just
straight
up
obsolete
it
without
a
diagnostic
id
if
we
wanted
to,
but
I
don't
feel
that
strongly
about
it.
H
I
mean,
if
somebody's
cross
compiling,
I
guess
they
could
pound
if
the
their
call
away
but
like
while
the
obsolete
will
only
show
up
if
they
target
net
six
specifically
like
if
they
are
cross
compiling
for
netsix
and
netfx.
It's
if
just
more.
C
The
recommendation
here
by
the
way
is
going
to
be
deleted
in
all
cases,
even
if
you're
targeting
that
framework
it
it's
so
inconsistently,
honored
in
net
framework
that
there's
really
no
point
to
use.
It
also
like,
if
someone's
hell-bent
on
using
private
reflection,
they're
going
to
do
it
even
without
this
attribute
being
present
or
even
if
the
attributes
present
there
are
ways
around
it.
K
Is
is
this
possibly
a
scenario
where
we
want
to
say
this?
Obsoletion
is
only
valid
if
you're
targeting
net
core
only
because
I
imagine
there's
a
few
places
where,
if
you're
multi-targeting,
we
don't
necessarily.
C
Want
the
obsoletion
well,
the
obsolete
attributes
only
going
to
be
on
the
newer
reference
assemblies
it
like
we're
not
going
to
place
we're
not
going
to
obsolete
the
apis
in
already
shipped
reference
assemblies,
but
when
we
write
up
the
documentation
for
this,
the
recommendation
will
be
don't
if
def
literally
just
delete
it
everywhere.
You
see
it
in
your.
A
Code
I
mean,
like
I,
don't
quite
understand
the
concern
with
multi-targeting.
I
mean
this
is
true
for
any
discrepancy
and
api
service
right,
which
is
the
reason
why
you
do
multi-target
in
the
first
place.
So
I
think,
like
it's
fine
to
say
you
multi-target,
between
three
platforms
and
only
on
one
of
them,
something
is
obsolete
and
then
you
have
to
make
a
decision.
What
you
want
to
do
right.
C
Yeah
for
those,
what
we
say
is
you
can
be
because
the
because
the
api
that
you're
calling
which
is
now
obsolete,
might
have
had
a
side
effect
or
might
have
had
an
implementation
on
an
earlier
framework.
Then
in
this
case
either,
if
it
or
just
suppress
the
obsoletion.
But
in
this
case,
like
our
recommendation,
would
literally
be
like
if
you're
using
this
on
full
framework,
stop
delete
it.
If
you're
using
this
on
net
core,
stop
delete
it
if
you're
using
it
on
mono,
stop
delete
it
and
so
on.
H
A
A
C
F
C
A
C
A
A
C
Yeah
there
there
are
cases
where
people
do
a
somewhat
expensive
operation
of
like
newing
up
a
a
cryptographic,
hash,
routine
hashing
data
and
then
just
disposing
of
the
thing.
We
have
static,
one
shots
that
were
introduced
in
the
previous
framework
or
I'm
sorry
that
were
introduced
in
5.0.
H
C
C
This
pattern
occurs
frequently
enough,
where
the
fixer,
I
think,
has
value.
H
A
H
Yeah
did
we
also
do
one
to
your
recollection
levi
for
rng
fill
versus
rng
get
bytes,
don't
recall,
because
we
might
just
want
to
do
both
of
them
at
the
same
time.
It's
there.
A
H
A
When
you
say
like
polymorphism,
what
part
do
you
mean
like
when
you
go
through
the
factories.
H
So
like
so
the
one,
the
other
one
that
I'm
talking
about
is
on
random
number
generator
it
it's
the
the
crypto
one,
not
the
system,
it
has
a
virtual
method
called
get
bytes
so
that
your
rng
can
fill
the
array.
But
we
said
that
no
one
should
really
subclass
the
type
you
should
just
use
the
system
rng
and
then
we
added
the
static
rng.fill,
and
so,
if
you're
like
so
the
get
bytes
is
polymorphic,
but
we
tell
people,
don't
use
any
classes
other
than
the
one
we
give
you.
So
why
was
it
virtual?
H
It's
the
same
analyzer
as
this
as
you
don't
want
a
virtual
behavior
of
hash
data
on
shot
256.
You
just
want
the
right
answer
to
come
back
yeah
in
this.
In
the
case
of
sha-256,
there
is
the
parent
which
is
hash
algorithm,
which
is
you
can
accept
any
hash
algorithm
and
produce
some
bytes.
So
there
is
a
polymorphic
semantic
behavior
there,
but
for
the
rng
there
really
really
wasn't.
C
H
A
Alrighty
so
then
I
guess
we
had
now
a
time
sorry
tanner
next
week
we
can
review
more
of
the
backlog.
I
mean
we're
doing
pretty.
Well,
I
mean
like
we
keep
it
at
low
numbers
and
we
mostly
review
everything.
So
I'm
quite
happy
with
where
we
are
right
now
alrighty,
then
I
see
some
of
you
guys
this
week.
Some
of
you
guys
next.