►
From YouTube: .NET Design Reviews Brotli
Description
-02:-12:-07 - Approved: Add Brotli Compression to CoreFX https://github.com/dotnet/corefx/issues/25785#issuecomment-352921246
B
C
B
Same
184
that
you
don't
like
this
is
getting
better.
We
all
just
want
to
go
to
sleep
to
go
so
I
can
think
that's
something
we
talked
about
this.
We
basically
said
like,
ideally
for
the
stream.
You
just
take
my
seat
deflates
to
anymore.
That's.
E
B
E
F
C
F
C
C
C
No
data
in
there,
no
because
you
don't
have
to
create
the
buffer.
Somebody
starts
using
the
stream.
So
when,
when
the
nice
test
is
created,
it's
empty,
it's
just
like
you
know
it
has
the
settings,
so
you
could
then
they
could
freely
change
the
property
and
when
they
started
to
use
the
stream
it
would
all
work.
Yeah.
E
C
G
C
There's
only
easier
because
you
see
like
that
would
kind
of
solve
the
problem.
So
now
we
have
like
six
constructors,
we
would
have.
We
would
go
back
to
four
and
also
if
it's
a
property
like,
if
you
don't
care,
you
don't
see
it
versus
constructor
parameter,
is
kind
of
interface.
Once
you
like
start
looking
at
the
constructor,
it
shows
you
intelligence
shows
you.
The
signature
is.
C
B
G
Yeah
I
also
asked
earlier,
but
you
weren't
here
to
answer
on
what
are
the
semantics
of
flush
on
this
ADR
and
on
for.
F
For
this
stream,
it's
pretty
much
the
same
as
deflate
streams,
it'll
act,
the
same
way.
The
only
thing
about
Bradley,
which
is
different
from
deflate,
is
that
a
brightly
stream
isn't
really
completely
inflatable.
Unless
you
have
the
finished
fight
so
like
for
the
flight
stream,
for
example,
you
could
do
you,
could
encode
half
of
it
and
give
it
to
an
inflator
and
then
call
it
a
day,
but
for
Bradley
stream
you
need
to
do
the
finalization
first.
If
you
don't
do
the
finalization,
then
it's
not
going
to
have
that
final
bite
and
the
inflator.
F
G
Just
removes
all
your
lines
and
some
Adrian's,
so
here's
the
particular
scenario
that
I'm
thinking
of
say
that
I'm
writing
a
large
document
to
the
output
stream
and
halfway
through
I,
say
flush.
Then
I
send
that
off
to
a
receiver
somewhere.
Can
that
as
that
receiver
runs
it
through
the
decoder?
Is
he
actually
going
to
be
able
to
see
all
of
the
document
that
I've
compressed
thus
far,
or
is
there
going
to
be
some
type
of
buffering
that
you
won't
be
able
to
work
around?
G
G
E
B
B
Later,
oh
yeah,
mr.
Park,
oh
that's
inconvenient,
to
set
it
up,
it
was
yeah.
I
see
the
usage
is
okay,
so
then
the
decoder
so.
C
A
C
C
C
The
name
renaming
it,
but
it's
a
separate
review
and
I
forgot
about
that.
It's
already
there
so
oh
and
this
IP
I
would
depend
on
system
memory.
Yes,
okay,
yeah,
cuz,
I
was
kind
of
thinking.
F
A
A
C
A
C
C
F
B
C
F
B
B
A
C
F
F
A
C
Yes,
so
if
system
memory
is
oh,
this
thing
has
to
be
Oh
Biff,
it
depends
on
it.
In
other
words,
in
box
cannot
depend
on,
things
are
not
involved
in
the
neck.
Is
physics
involved?
What
API
you
can
call,
but
an
operation
started
so
system
memory
is
like
a
hybrid
component
like
part
of
it
is
in
the
platform.
Part
of
it
is
just
oh
yeah,
I
think
operation
status
is
just
like.
Basically,
we
don't
have
IP
is
in
the
framework
that
returning
we
only
moved
into
the
platform
span,
read-only
span
and
kind
of
its
dependencies.
F
B
B
What
they
all
get
disposed,
yeah
a
point
well,
but
the
problem
that
you
have
today
is
when
you
have.
Let's
say
you
have
like
two
classes,
so
you
have
one
class
right
if
I
call
this
Folsom
that
that
guy
can
basically
register
that
you
call
dispose
another
out
any
pointers
and
then
effectively
when
you
call
another
method
just
so
it's
not
supported
because
it
is
posted.
If
you
have
two
structs
and
it's
a
whole
day
out,
they
hold
on
to
native
memory.
B
C
F
B
F
C
C
Well,
mainly,
I
was
just
asking
like
how
you
do
it
I'm,
not
sure
whether
it's
so
in
a
lot
of
other
AP
is
a
Levi.
You
kind
of
worked
on
similar
where
you
know
you
call
like
decompress,
first
chance,
second
chance
third
chunk,
and
then
you
call
decompress
final
or,
like
you
know,
an
API
that
is
called
final
and
then
it
makes
it
very
explicit.
Like
you
look
at
the
API-
and
you
know
here,
it's
kind
of
like
you
have
to
know
that
you,
you
should
call
this
pose.
So
now,
maybe.
F
F
G
Sort
of
flush
or
flush,
parle,
okay,
okay,
like
in
I,
think
in
what
you've
done
here
is
you
never
actually
have
to
call
dispose,
except
as
a
perp
optimization,
because,
as
you
mentioned,
the
decoder
always
knows
when
it's
done
anyway,
and
the
encoder
requires
a
caller
to
call
compress
final
at
some
point.
So
I
see
I.
F
G
G
B
B
E
B
C
F
D
C
C
B
B
C
Had
so,
we
have
actually
I
think
in
the
encoder
space
already
in
framework
IP
is
we
have
existing
IP?
Is
that
basically
do
things
in
chunks?
And
then
you
call
find
out
this
one
is
slightly
different
because
you
don't
have
to
call
find
out
on
the
at
least
decoder
side,
but
what
do
we
have
on
it
and
on
the
other
corvex
laughing
for
oh
okay,.
C
D
D
C
C
F
G
C
C
F
F
E
C
F
C
C
F
B
G
C
And
intermediate
flashing,
so
it
may
be
what
I'm
getting
confused
is.
It
seems
like
there
are
two
different
reasons
to
do:
intermediate.
Flushing
one
is
for
some
reason:
I
want
the
data
to
start
flowing
and
then
the
second
one
is
I
have
data
in
the
input
buffer,
but
there
was
no
room
in
the
output
buffer.
Now
it's
really
just
the
first
I
think
there
will
be
a.
G
Somewhere
because,
as
you
mentioned
earlier,
when
the
applications
in
the
steady
state,
it's
just
going
to
be
calling
this
method
in
a
loop
right,
it's
not
really
going
to
care
how
much
data
is
in
the
interview
output.
It's
it's
just
going
to
do
some,
you
know
offset
picks
up
and
then
just
wild
trigger
Walter,
all
true,
but
yeah
as
soon
as
as
soon
as
you
run
into
a
situation
where
I'm
working
on
a
real-time
chat,
application
I
need
this
data
to
get
to
the
caller
or
to
the
recipient.
B
F
D
G
F
F
F
A
F
F
C
D
C
B
C
F
G
G
More
output
like
for
regular
compressing
areas,
I
can
kind
of
get
that,
but
for
a
stateful
API,
especially
like
a
spongy
API
like
this
I
would
expect
certain
values
of
operation
status
and
never
to
appear
ever
anywhere
before
input
needs
more
input
with
Neverland
never
appear
on
flush.
I
would
expect
that
number
to
your.
C
G
B
There's
somebody
reading
they
can
read
the
entire
window
or
not
like
it
like
have
to
wait
until
the
middle
to
get
more
data
yeah,
in
which
case
I
would
argue.
When
you
talk
about
the
flashing
of
the
window,
not
enough
data
makes
complete
sense
because
you
have
to
be
have
enough
data
to
finish
the
window
versus
in
the
normal
flush.
B
State
like
there
is
no
doesn't
make
any
sense,
because
all
you're
saying
is
that
whatever
you're
holding
on
to
yourself
just
but
it's
an
underlying
thing
and
that
that
makes
no
statement
about
whether
that's
enough
or
not.
It
just
means
you
know,
stop
holding
on
to
data
which
kind
of
means
to
like
I
think
flash
may
not
be
the.
C
G
So
you're
writing.
You're.
Writing
a
chat
application
of
web-based
chat
application
right,
like
maybe
you're,
working
with,
like
customer
support
on
a
website
somewhere.
Now
you
you,
as
a
chat
representative
like
ask
a
question
to
the
user
on
the
other
side.
That
question
like
the
ASCII
text,
ends
up
through
the
broadly
encoder,
like
the
ASCII
text
is
only
going
to
be
this
big
right.
The
buffer
is
huge,
so
you
hit
Enter.
When
does
the
question?
Let
you
type
actually
make
its
way
over
to
the
customers
when.
G
G
B
G
F
B
F
C
B
Maybe
the
better
model,
so
what
you
have
here
is
basically
the
the
situation
where
you
have
a
you
know
you,
basically
you
compress
data
right
now.
The
thing
is,
let's
talk
about
how
the
phone
of
the
data
looks
like
you
have
a
header
and
then
like
chunks
of
encode,
the
data
you
got
blocks.
Yes,
yes
and
there's
a
header
at
the
at
the
at
the
very
beginning,
always
like
every
chunk
the
same.
There's.
B
F
B
B
C
F
F
F
F
B
F
To
just
finish
this
one
versus
also
writing
this
one
personally
I'm
in
the
camp
that
I
think
we
should
do
the
finished
block
at
the
end
of
every
set
of
data.
So
we
don't
have
a
flush.
We
just
have
a
finish
because
I
was
looking
around.
Some
of
the
decoders
are
always
going
to
expect
the
EOF
equivalent.
They
don't
like
it
when
you
don't
give
it
at
the
ELA.
They.
B
F
All
over
again
with
header,
it's
sort
of
data,
it's
sort
of
the
corollary
to
the
encoding
flushing
right,
so
the
D
compressor
will
have
this
internal
buffer
that
takes
Chung's.
The
text
owns
the
fixed
chunks
and
it's
not
going
to
actually
flush
that
data
to
the
underlying
destination
until
it
sees
that
AOS.
So
the.
B
F
B
F
Care
about
this
another
media,
API
Provenza,
but
then
the
question
is
on
the
other
side
of
things,
the
decoder.
Does
it
see
that
chunk
and
do
the
whole
thing
or
what
it
has
a
bigger
bubble?
If
it
buffer
is
allows
two
chunks,
does
it
wait
for
to
fill
the
buffer
or
do
they
just
get
one
chunk,
you're
halfway,
finished
chunk
and
then
what
I'm
out
of
the
jungle
but
I
assume
they
have
like.
B
Some
sort
of
micro
header
that
says
you
know
I
have
they're
like
I
know
you
kept
a
basin
area,
I
guess
from
the
decoder
standpoint.
They
should
be
able
to
decode
the
data
that
is
entirely
in
this
chunk
and
then
well.
If
it's
like
a
checked
client,
then
the
expectation
is
that
this
is
just
text.
So
let
me
draw
that
this
is
a
unit
of
work.
It
was
like
a
JSON
document
and
then
you're
like
a
bit
of
a
JSON
document.
Then
whoever
you
know.
G
C
Know
all
over
again,
so
what's
the
cost
of
creating
this
structure
like
all
the
native
machinery
like?
Does
it
make
sense
to
reuse?
Let's
say
you
have
the
scenario
that
anybody
was
talking
about
my
Kamchatka
enterprise
and
you
know.
Basically
we
don't
provide
flash.
So
you
have
to
like
say:
I'm
done,
I'm
done,
I'm
done
yeah
today.
C
G
C
What
I
was
saying,
maybe
I'm,
not
by
the
way
what
I
was
saying.
It
has
nothing
to
do
with
a
browser.
This
API
has
no
title
browsers
to
streams.
It
doesn't
do
actual
flashing
for
you.
It
just
moves
data
from
one
span
to
another.
It's
up
to
the
consumer
of
the
API.
To
do
the
right
thing
for
the
browser
from
the
browser's
protects.
F
G
F
C
B
C
May
not
what
you
want
so
another
thing
we
could
do
is
kind
of
reverse
it
I'm
now
brainstorming,
because
there
are
some
issues,
I
just
noticed,
but
we
could
have.
You
know
a
final
means
just
rush
all
the
data,
and
then
we
could
have
right
EOF
method
to
basically
everybody
has
to
call
my
UF
is
EOF
always
the
same.
Is
it
like
a
constant
payload
or
it
varies
well.
F
It's
not
it's
not
exactly
an
EO
f,
so
much
as
it
is
you're
telling
the
underlying
native
implementation
to
finish
the
block
with
those
EOF
bytes,
so
I
mean
you
wouldn't
want
to
do
like
a
flush
and
then
another
AOF.
You
don't
want
to
finish
this
block
and
then
put
another
block
there
with
just
an
EF
in
it.
Why
do.
C
B
C
G
B
B
B
See
the
problem
that
I
have
these
kind
of
things
I
mean
that's
I've
not
really
made
up
my
mind
whether
I
think
it's
a
leaky.
Abstraction
was
just
part
of
the
ceremony
that
you
cannot
really
abstract
away
from
the
caller,
but
it
seems
a
little
bit
like
similar
to
base64
with
same
discussion
right
I,
guess
this
final
boxing
of
the
memory
maybe
leaked
the
way,
the
form
it
looks
like
well
I.
B
B
B
C
D
G
C
G
Interface
right,
that
is
really
because
stream
is
always
guaranteed
to
consume
all
of
its
data,
whereas
these
encoders
are
not,
and
that
actually
makes
flush
very
hard
to
use
because
say
that
you
call
compress
in
a
loop
and
compress
returns
needs
for
it,
but
because
it
didn't
actually
consume
all
the
input.
Yeah
do
you,
and,
and
now
you
want
to
do
a
flush.
G
G
Can
you
is
this
under
the
under
the
person
that
you
don't
have
a
flush,
then
I'm,
saying?
If,
if
the
scenario
is
that
I've
put
one
bite
into
the
and
I
want
to
flush,
that
out
of
the
network
again,
if
I
call
compress
and
pass
one
byte
is
that
for
the
source?
Is
that
guaranteed
not
to
return
needs
more
data?
C
F
C
F
G
C
B
So
I
guess
what
you're
saying
is
that
you're
returning
for
later
when
the
window
is
full
yet
right?
Is
it
fair
yeah,
that's
the
idea,
and
then
you
basically
so
what
happens
when
I,
when
I
basically
pass
in
just
enough
data
that
finishes
the
window,
but
not
more
than
you
return
to
success,
I
suppose
what.
C
You
know,
maybe
we
need
to
add
one
more
values
to
Dana
a
value
called
something
like
buffered,
so
people
are
not
surprised
that
they
call
the
API.
It
returns
success,
but
nothing
was
written.
That
is
kind
of
surprising,
so
new
case.
Isn't
it
isn't
it
fair
to
say
that
each
monitor
is
almost
like
the.
B
Argument
exception,
like
the
method
cannot
work,
no,
no,
no,
in
which
case
in
case
going
okay,
like
it
like
it
again.
Okay,
like
in
this
case
you
could.
It
could
argue
that
there's
nothing
the
caller
would
have
to
do.
We
got
just
just
throws
in
data
and
at
some
point
you
just
write
it
out
and
thanks
buffering
you
don't
care
whether
they
buffered
or
not.
You
just
want.
G
B
C
Is
so
imagine
that
you
like
basic
C,
for
encoding
right
and
a
you
encoded,
this
chunk
and
this
one
byte
here
yes,
say:
32,
it's
space
right!
Well,
you
don't
want
to
throw
because
there
is
additional
buffer
here
in
the
pipeline.
So
if
you
pass
just
this
chunk,
it
cannot
do
its
work.
It
says,
need
more
data.
What
you
do
is
you
take
the
next
segment
from
the
pipeline.
You
stitch
them,
and
now
you
pass
the
you
know
the
four
bytes
yeah.
A
C
Base64
encoding,
I
PR,
it
will
not
like
say,
needs
more
data.
I
didn't
do
anything.
It
would
actually
start
encoding
as
much
as
it
can.
Oh
I
sense
is
for
for
the
encoder,
not
for
a
decoder.
I
couldn't
I
couldn't
encode
everything
that
you
passed
me
I
encoded
as
much
as
I
could,
but
I
need
more
data
to
encode
a
few
more
and
detail
people.
G
C
F
C
A
C
C
C
G
B
F
C
C
A
B
C
G
B
B
G
B
C
B
F
F
C
B
B
B
You
can
sample
bytes
from
one
to
the
other,
and
then
all
this
guy
returns
bool
to
indicate
that
it
half
of
the
other
guy,
which
runs.
You
know
false,
to
indicate
that
all
the
destination
was
too
small
and
then
it
gets
really
more
complicated
because
then
either
then,
basically
you
have
to
deduce
the
arrow
states
based
on
you
know
the
relationship
of
the
out
variables,
which
is
what
we
had
originally
like
that.
F
I
think
I
think
doing
the
compressed
with
this
final
than
having
a
separate
flushes,
probably
the
way
they
go
and
before
we
decide
on
flush.
I
want
to
do
some
more
research,
but
the
browser's
do
when
they
video
F,
because
it's
possible
that
they
treat
this
as
equivalent
to
collect
this
or
the
possible
they
decide
that
the
stream
is
done.
Everything's
done,
Ella
takes
it,
so
I
want
to
find
that
out.
First
before
we
decide
if
flushes
necessary
I
think
having
compressed
with
is
final,
is
good
either
way.
Okay,
yes,.
C
F
A
C
A
A
E
A
C
A
That
perspective
I
agree.
However,
it's
gonna
come
I
live
for
it
myself,
so
many
times
that
you
look
hey
did
return
something
out.
What
the
like.
You
know,
how
many
values
do
I
have
to
kind
of
watch
over
right.
You
know
how
do
I
have
to
protect
myself.
What
do
I
do
if
it's
not
okay
from
some
exception,
that's
basically
that
code
yeah,
it's
I,
think
we
should
have
the
algorithms
be
super
puzzles,
nor
corollary,
just
want
to
make
sure
that
for.
B
B
I'm
gonna
be
a
little
confused
by
Isaac.
What
are
we
designing
right
now?
So,
basically
we
just
said
it's
like
now.
We
take
our
compressed
API
and
the
Eddie's
final
block
here
right,
yep
I.
Think
that's
good!
You
should
be
voted
to
true
because
there's
a
basic
C
for
that
I
think
it's
weird
but
like
I,
don't
know.
C
G
C
C
B
C
F
F
E
F
F
The
try
compress
is
a
static
thing
where
you
don't
have
to
make
a
broadly
encoder,
you
can
give
it
source
to
give
a
destination
and
you're
done
and
it
works
or
not.
Okay,
I
see
return,
a
bool
succeeds
like
Forge
it.
So
then,
if
we
have
try
compressed,
then
I
think
is
final.
Block
needs
to
default
to
false,
because
you're
going
to
use
compress
with
is
final
block.
Whenever
you
have
like
you,
don't
know
that
you'll
be
able
to
finish
in
one
iteration
like
you're
gonna
loop.
C
B
C
B
F
B
C
C
F
F
So
that's
why?
Why
does
this
have
to
take
any
data?
Why
would
it
not
be
just
what
does
it
take
data?
It
just
has
its
destination,
because
otherwise,
if
you
flush
data,
where
does
it
go?
Oh,
okay,
okay,
never
mind
yeah!
That
makes
it
technically.
You
could
take
source,
but
I,
don't
think
we
should
do
that
better.
So.
F
F
Cannot
so
that's
the
argument
for
why
there
should
be
compression
for
constructor
variables,
which
is
what
Christoph
wants
to
do
yeah?
That's
what
I
would
do
a
good
I
mean
the
reason
I
have
them
like
that,
instead
of
being
constructive
variables
is
because
it's
a
struct,
so
I
kind
of
wanted
to
have
the
like
the
default.
Struct
declaration
and
dot
set
quality
dot
window,
but
you
you
can
still
have
default.
C
F
C
C
B
G
Would
be
narrated
yeah
like
there's
no
code,
basically,
the
very
first
time
you
call
compress
this
thing's
going
to
have
to
allocate
a
save
handle
in
commerce,
which
is
what
you
were
doing.
That's
what
we're
doing
now
so,
but
all
of
when
you
create
an
array
of
these
guys,
like
they're
all
going
to
have
defaulted
to
tea,
but
they're
all
usable.
It's
exactly
look
where
the
quality.
B
C
I
am
getting.
F
G
B
E
C
F
B
F
B
B
B
F
G
So
the
way
that
this
API
works
under
the
covers
is
it's.
It
has
some
mystically
assumes
that
the
data
that
you're
feeding
it
is
not
compressible
at
all
right
and
it
will
assume
that
it's
writing
out
uncompressed
data
plus
X
number
of
bytes
for
headers.
So
the
answer
that
you
get
back
from
get
maximum
press
size
is
always
going
to
be
strictly
greater
than
the
value
that
you
pass
them
always
now,
which.
F
E
C
Did
you
get
byte?
Why
would
you
need
to
estimate
what
would
you
do
with
it?
So
it
let's
say
it
returns,
13
gigabytes.
What
would
you
do
now
with
this
information,
for
example,
check
that
the
output
right
at
that
size?
So
I,
don't
like
one
of
this
place
helper
to
the
operation?
I,
don't
think
that's
super
reliable
operation!
C
Do
is
I
would
basically
say
whatever
is
the
long
times.
1.2
is
good
enough
estimate
like
we
don't
need
API
for
it.
I
honestly,
this
API
is
for
that
for
the
first
one.
For
the
instance
method
I
mean
sorry
now
for
the
for
the
Tri
compressor
and
for
the
static.
That's
the
primary
is
what
I
like
I
just
want
a
a
if
I
don't
pass
enough
destination
for
the
for
the
try
method.
It
fails
yeah.
It
doesn't
actually
like
right.
It's
not
like
the
first
one
to
try
it's
partially.
It
just
doesn't
right.
D
F
F
F
G
C
C
B
C
F
B
B
C
C
C
G
G
D
A
A
G
C
C
We
could
just
make
this
thing.
A
class
implement
our
own
lifetime
safety,
which
is
seventy
right
to
take
a
funnels
object,
yeah,
something
like
this
or
we
implement
manually
like.
There
are
many
ways,
and
then
you
know
you
don't
every
box
it!
Oh
yeah,
you
have
just
one
object
on
the
heap
always
and
always.
C
C
B
E
B
C
B
C
B
C
B
What
we
could
do,
what
Jared
are
called
crazy,
which
is
less
style,
borrowing
or
linear,
tied
to
something
you
can
enforce
it?
That
structure
some
coffee
to
run
so.
F
D
C
Am
talking
about
the
kinetic
limitation,
so
it's
not
a
Navy,
there's
no
use
after
free
or
anything
like
this.
If
the
handle
is
closed,
we
can
detect
it
because
the
moment
you
pass
it
to
some
underlying
API,
it
will
basically
return
an
error
code.
The
problem
is
that
the
handle
can
be
recycled.
Correct
is
that
the
safe
handle
is
secure
against
recycling.
Oh,
if.
C
G
Basically
e,
so
in
the
one
one
thing
that
we've
seen
before
in
asp.net
when
we've
had
stuff
like
this,
is
you
end
up
writing
someone
else's
response
to
a
different
network
constraint
so
say
that
you
and
you
are
both
coming
into
my
web
server
I've
accidentally
I
might
have
an
int
pointer.
That
I
think
is
pointing
to
you
that
is
actually
pointing
to
you.
I'm
writing
data
to
it
and
now
all
of
a
sudden
you're
getting
the
information
that
was
intended
for
you
like.
That's
why
we
moved
away
from
them
insisted.
G
Spam
I'm
actually
writing
his
data,
because
that's
what
the
end
pointer
actually
points
to,
even
though
the
spam
that
I'm
passing
to
the
API
is
destined
for
you
like,
because
what
I'll
do
is
I'll
I'll
get
an
array
pull
or
stack
alloc
or
something
I'll
have
coffee,
but
data
into
there
and
then
I'll
pass
that
span
over
to
your
networks.
Train,
okay,.
C
D
B
G
G
G
Against
a
safe
handle
is,
is
fine,
for
this
cassette
handle
has
its
own
record.
So
if,
for
whatever
reason
somebody
tries
using
one
of
these
after
it's
indisposed,
save
Han
will
will
kick
in
and
throw
a
proper
exception
and
directed,
and
it's
all
threads
apeshit
now
I
think
that,
if
account,
it
has
its
own
separate,
ref
count
posit
and
last
until.
C
G
C
You
when
you
pass
memory
of
T
around
you,
don't
end
up
with
the
same
issue
and
memory
of
TSS
trap.
We
used
to
have
a
feature
in
memory
and
on
memory
that
lets
you
reuse
the
internal
type
on
memory,
so
you
don't
pay
the
cost
of
allocations.
Okay,
so
here's
how
it
worked
when
memory
of
T
is
created
for
owned
memory.
C
Basically,
this
is
how
it
detects
the
canary
almost
so
we
decided
not
to
do.
Basically,
we
remove
this
feature
from
member
of
the
and
I
now
regret
and
we
removed
it
because
we
were
optimizing
performance
of
Kestrel
and
we
were
just
removing
everything
that
we
could,
because
we
had
problems
meeting
there.
Ultimately
speaking.
G
C
Yeah
sure,
but
it
so
for
at
least
for
memory
and
on
memory,
it's
more
like
a
I
guess,
maybe
there's
some
security
aspect
of
it,
but
it
was
more
about,
like
developers
not
shooting
themselves
in
the.
But
what
are
you
gonna
do
what
fail
fast?
If
you
see
oh,
we
say:
object
the
spot
just
like
we
say
today
like
if
you
own
memory
of
T.
G
C
C
G
G
G
Of
a
web
server
and
items
I
wasn't
making
a
security
argument.
I
was
just
making
a
reliability
argument
like
this.
We
don't
want
to
be
in
a
situation
where
a
bug
could
manifest
itself,
just
by
an
exception,
being
thrown
and
swallowed
that
the
developer
wouldn't
have
really
seen
while
he
was
debugging
or
better.
Yet
we
would
probably
want
this
to
bring
down
the
application
if
it
occurred,
because
it
means
something's
gone
horribly
wrong,
but.
G
Like
me
to
say
it
again,
what
would
you
would
not
want
to
happen?
So
what
I
would
not
want
to
happen
is
that
the
behavior
right
now,
because
we
actually
have
like
it,
sounds
like
we
have
an
actual
object
which
is
disposed
under
the
covers.
If
we
try
using
that,
we
know
that
the
objects
disposed,
because
we
probably
have
an
associate
and
we
can
jump,
we
can
throw
an
exception
and
we
we
take
that
request,
but
we
haven't
negatively
affected
anything
else.
G
Aside
from
that
one
request,
but
we
start
reusing
these
instances
instead
of
having
a
disposed
field.
If
we
just
use
like
a
canary
or
something
like
that,
then
what
happens
is
we
will
eventually
get
a
collision
which
means
that
where
we
expected
an
object
disposed
exception
to
be
thrown
instead,
the
code
will
succeed
and
have
undefined
behavior
sure.
C
D
G
G
B
G
G
C
C
G
Which
is
fine,
but
the
application
developer
has
made
an
intentional
decision
to
do
that,
whereas
if
the
class
design
just
assumes
you
create
the
encoder,
you
encodes
and
stuff,
and
then
you
dispose
of
it
and
if
the
application
developer
really
wants
to
go
crazy
and
woman,
he
can
but
he's
responsible
for
lifetime.
Editor.
E
C
C
G
F
Not
really
doable,
okay,
everyone!
Well,
it
carries
a
lot
of
state.
Once
you
write
the
final
block,
you
can
give
it
more
data
so
for.
C
C
F
B
A
F
C
C
C
G
C
Mean,
and
also
like
so
measuring
performance
differences
seem
like
allocating
nada,
okay,
P
Isis
hard,
because
if
you,
if
you
don't
have
lots
of
threads
and
a
lot
of
pressure
and
memory,
yeah
yeah
they're,
not
gonna,
be
very
different
yeah
the
pressure
all
right,
it's
only
starts
showing
up.
If
you
have
like
a
taking
power,
you
know
benchmark
that,
basically,
like
does
things
like
crazy.