►
From YouTube: .NET Core Design Reviews: ManagedBufferPool
Description
We'll look at this proposal: https://github.com/dotnet/corefx/issues/4547
B
B
We
have
scenarios
where
we
have
multiple
different
threads,
trying
to
allocate
yellow
kate,
very
short-lived
buffers
for
use
with
io
or
for
adding
or
thicker
things
like
that,
and
everyone
kind
of
rolls
their
own
way
of
doing
this,
and
a
lot
of
them
are
actually
pretty
similar.
So
it
seemed
like
a
great
place
where
we
can
actually
extend
the
pcl
by
adding
a
new
class
that
could
help
take
care
of
this.
B
So,
on
the
pros-
and
for
this
is
you
know,
I
wrote
this
up
and
and
I
came
up
with
a
very
simple
solution
that
tries
to
tackle
a
majority
of
the
cases
that
we
use
this.
If
I
am
and
reduce
the
memory
overhead
of
allocating
ND
allocating
and
then
having
to
run
called
GC
cycle
on
a
lark
temperature
allegation.
So.
D
C
A
B
That
says,
I
like
a
quick
overview
here
so
going
so
I
go
into
a
lot
of
detail
here
in
the
ratchet
on
usage,
pretty
much
what
I
just
I
just
talked
about
that
make
it
specific.
All
of
that.
This
is
not
specifically
meant
for
object-group.
There's
been
this
one
to
talk
on
this
thread
about
allowing
it
so
what
so
choose,
but
it
is
not
a
explicit
call
out
for
this.
Another
explicit
non-starter
for
this
is
these
buffers
are
not
meant
to
be
pinned
by
the
GC.
B
As
a
new
menu,
if
you're
doing,
if
you're
using
these
buffers
and
paying
them
and
talking
some,
he
invokes,
we
have
future
plans
to
make
that
do
that
in
a
better
way.
That
will
be
more
efficient,
for
instance,
rather
than
doing
that
and
hang
them
and
having
some
cheesy
overhead
associated
with
that
with
that
and
will
create
a
non-native
buffer
pool
where
there's
no
margin
until
pinning
there's
no
talking
GT
at
all,
because
the
buffer
you're
passing
is
going
to
be
used
by
pure
native
rights.
B
D
Better
for
that,
well,
luckily,
there's
still
the
issue
when
you
do
want
to
you
know.
On
the
one
hand,
you
wanted,
as
an
array
of
bytes,
are
aware
of
something.
On
the
other
hand,
I
want
to
interact
with,
with
native
code,
I
wanted
the
native
code
of
fill
that
array
of
bytes
right
so
you're
the
thing
that
you
just
described
it
with
you
know
a
native
buffer
pool.
You
can't
do
that
right.
D
If
you
make
an
point
in
native
code,
it
will
never
be
on
native
memory
will
never
be
a
byte
array
that
we
undergo
a
met,
so
you
have
to
do
the
other
way,
which
is
that
you
have
to
literally
pennant
foo
and
then
give
it
out
right.
So
how
is
that
that
the
interesting
thing
is
that
that
scenario
seems
to
be
fairly
common
link
in
our
scenario,
we're
always
filling
buffers
natively
and
I'm
wanting
to
treat
them
as
always
bites.
C
The
moment
that
pool
itself
pins
you
start
ramming
into
my
significant
issues
is
like
Lifetime,
school
and
things
you
know
like
and
when,
when
I
and
then
I
get
ideology,
so
we
now
kind
of
like
unto
the
issue
and
it's
like
music
correct.
So
we
can
call
it
like.
You
know
panting,
but
I
would
say
the
scenario
that
you
mentioned.
I
think
ultimately,
the
best
solution
is
to
once
we
have
spans
to
just
allocate
math.
You
know
like
allocate
native
memory
and
pass
guns
spans.
Are
you
know
it?
Just?
Okay,.
D
C
D
Ugly
part
about
that
is,
it
probably
requires
a
fairly
massive
sort
of
know.
The
plumbing
of
that
you
know
there's
a
lot
of
plumbing
today,
that's
probably
by
your
rate
based
and
now.
All
of
that
now
lies
are
going
to
expand
them
right,
who
they'll
be
like,
but
all
I'm
saying
is
that
that
also
sort
of
punts
this
issue
to
to
that
new
world,
and
we
have
a
question
whether
we'll
get
to
that
world
and
at
what
time
scale
at.
C
D
Mean
we
have
a
thing
called
pinhole
buffer
cache,
which
is
trying
to
be
a
buffer
pool.
It
doesn't
pin
it's
not
meant
to.
It,
doesn't
do
any
of
that
painting
for
you,
but
but
what
does
do
is
it
tries
to
make
it
so
that
when,
if
you
were
dependent,
it's
not
as
expensive
from
a
GC
point
of
view,
so
basically
what
it
does
is
it?
D
Is
it
ages
the
the
buffers
that
it
gives
out
and
tries
to
get
them
into
gentoos
before
it
gives
them
to
you,
and
so
you
tend
only
pin
things
in
gentoo
and
paintings
in
gentoo
is
not
a
big
deal,
because
we
don't
move
things
around
and
Jen
too
much
anyway,
so
everything
is
fine
anyway.
The
high
level
question
here
was
a:
is
it
really
the
case
that
we
we
don't
pin
like
there's
an
interesting,
valuable
scenario
here?
That
is,
we
want
managed,
presumably
byte,
arrays
or
native.
D
You
know
primitive
type
arrays
and
we
don't
actually
end
up
painting
them
like
you
know
that
we
care
about
the
byte
arrays,
but
we
don't
actually
need
to
pin
them
because
it
seems
like
most
of
the
time.
You
are
paying
them,
or
at
least
you
know,
that's
the
most
common
scenario,
so
I
hope
I
just
asking
the
question
so.
C
Just
to
reiterate,
I
think
they
kind
T
of
our
and
feel
free
to
push.
Yes,
whose
back
is
we
give
you
by
today's?
They
user
code
is
responsible
for
paying
yeah
agree
and
what
and
also
I
would
say
that
in
the
interim
player,
of
course,
you
need
to
pin.
There
are
still
lots
of
scenarios,
welcome
to
lend
buffers
and
they
have
nothing
to
do
with
a
turd
on
this.
C
A
So
the
I
guess
that's.
Why
also
why
you
want
to
go
with
the
management
of
cool
so
assume?
If
you
ever
have
the
span
of
key
version
to
take
slated
memory,
you
would
give
you
you
would
make
it
part
of
the
contract.
I
would
not
just
add
overloads
here.
It
would
give
you
probably
a
native
buffalo,
so
you
don't
know
that
you
don't
know
right.
C
A
C
B
So
far,
service
area
was
right
right
and
just
just
one
piece.
This
still
one
call
out
from
the
feedback
goes
on
here.
The
where
t
is
struct
is
there's
a
dispensing
discussion.
That's
gonna
be
going
away,
so
this
is
this
call
that
out
and
have
a
chance
to
edit
this
before
meeting,
but
there's
been
significant,
significant
amount
of
people
asking
for
it
to
take
any
object
so
once
the
samara
asp
net
has
would
be
they
have
a
wonder.
Scenarios
is
dealing
with
razor
is
that
they
have
complex
types,
that
it's
either
attracts
an
object.
B
B
C
B
C
B
Event
well,
I
mean
steak.
Steven
brought
that
up
down
in
here
as
well,
but
my
thinking
by
thinking
that
excel
with
our
prototype
to
get
one
the
head
on
that
dating.
What's
that,
yes,
it's
very
trivial
to
you
to
copy
the
array
reference,
but
it
was
also
you
know,
I
think,
there's
a
one
there's
an
example
down
there,
where
you
know
if
it's
it
makes
it
more
difficult
for
you
to
after
free
errors,
with
the
same
variable,
yeah.
B
D
C
B
Removed
that
why
it
seemed
like
there
was
a
so
does,
Justin
background
everyone
else
here
there
was
originally
meant
clots.
There
was
a
static
property
for
each
shared
buffer
pool.
We
could
access
that
would
use
the
default
constructor
using
the
default
values
and
you
can
just
rent
and
return
without
having
to
create
a
pool
by
it
right
back
who
doesn't
remove.
That
is
because
it
seems
like
it
would
lead
down
a
very
annoying
path
where
that
all
of
a
sudden
is
now
allocated
statically
and
say
a
component.
B
Some
random
component
XYZ
that
you,
including
your
program,
decided
to
use
this
now
you're.
Now
your
entire
process
has
its
memory
address
space
up
because
of
this,
and
then,
if
you
stop
using
that
component
in
your
process,
there's
no
way
for
that
to
go
away
right,
there's
no
way
to
control
the
the
allocation,
there's
no
way
to
say
I'm
done
with
this
buffer
pool
and
deallocated,
and
if
you
need
a
shared
one,
it
seems
like
the
the
proper
way
to
make
sure
you
control
life
lifetime
without
without
it
being
referenced
by
your
process.
C
B
D
For
example,
like
system
io
compression,
how
would
we
use
this
in
d
played
stream
which
allocates
an
8k
buffer?
Every
time
you
create
a
deflating
stream
we'd
either
need
to
have
a
shared
pool
that
we
access
or
we
need
to
add
some
sort
of
polyp
surface
area.
That'll
force
you
to
pass,
wouldn't
maybe
the
question
is
more
about
component
learners,
as
opposed
to
program.
A
Owners,
okay,
it
cuts
both
ways.
I
mean
you
talk
brutal,
even
a
cockroach
on
about.
Is
that
I
think.
Fundamentally,
we
have
a
shared
one.
We
need
to
find
really.
Basically,
you
know
there's
only
one
set
of
parameters,
a
B
support
by
this
tech,
the
next
buffer
side.
You
have
to
pick
some
majors
and
you
have
to
make
sure
that
whatever
you
pick
is
good
enough
for
whatever
the
eighty
percent
cases,
then
you
come
on
girl
right
the
downside.
A
If
we,
if
we
go
down,
that
path,
is
almost
saying
you
know
it
may
make
things
better
overspending
or
components
you're
using
but
I
do
by
the
other
argument
as
well,
which
is,
if
you
don't
have
one
everybody
creates
their
own
or
even
worse,
of
we
usually
end
up
doing.
Is
they
have
some
private
thing
that
isn't
some
internal
component
in
half
member
can
access?
We
can
use
their
pool
and
I'll
be
created
your
engineering
nightmare
for
ourselves,
which
I
don't
think
is
better
me.
There
I
honestly.
C
A
C
D
Sorry
on
that
front,
like
one
of
the
things
I
had
suggested
to
John,
was
that
we
have
either
an
interface
or
an
abstract
base
class
for
an
arbitrary
bumper
pool
and
I
think
the
shared
buffer
that
we
exposed.
We
want
to
be
of
that
base
class
so
that
we
would
have
the
freedom
to
you
know
make
whatever
changes.
We
want
without
mocking
with
this
public
tight
as
these
very
specific
contracts
around
max
a
precise
number
of
buffers
per
bucket,
and
so
on.
Yeah
I.
D
Going
to
be
a
problem,
while
you
know
there's
a
reason
why
it's
just
nice,
what
the
GC
do
all
this
and
not
think
about
it
right
and
you
know
it's,
it
boils
down
and
the
other
bad
thing
about
a
shared
one.
Just
so
we're
putting
it
out
there
is
that
now
everyone
can
screw
it
up
from
when
you
married
the
leak.
Everyone
can,
you
know
I
so.
C
In
this
one,
what's
nice
about
this
tra
Patrick
boo,
you
cannot
actually
be
right,
because
if
you
do
not
return
it
yeah,
it's
gonna
receive
if
you
lose
any
faster,
but
basically
you
turn
it.
If
you,
if
you
don't
return
it,
you
turned
it
into
a
GC,
regular
GC.
Think
that
you
know
you
may
as
well
just
allocate
it
so.
D
C
A
D
C
D
More
I
think
I
like
to
share
good
idea
with
one
more
downside
to
it.
Is
you
run
the
risk
that
components
across
the
system
will
accidentally
return
a
bumper
still
use
it?
What
else
is
going
to
get
it
a
completely
different
component
and
now
you're
going
to
have
concurrency
issues
that
are
hard
to
detect,
hey.
C
D
B
That
one
of
the
comments
of
like
this
class
I
would
release
I
really
want
when
I
have
wanted
to
add
some
special
debug
could
only
be
tagged
each
the
erase
that,
like
you
know
when
you
say,
allocate
the
raise
a
little
padding
at
the
beginning
or
end
of
them
to
you
know,
do
some
checking
to
say
you
know,
when
you're
running
debug
mode,
make
sure
that
when
you
return
it,
it's
actually
one
in
a
way
that
you
rent
from
here
all
right.
No
no
else
is
using
this
things
like
that.
C
The
prototype
has
actually
a
public
property
that
would
give
you
the
number
of
outstanding
buffers
and
I
use
the
text
sheet
to
do
testing
you
know.
Europe
I
would
write
unit
tests,
doing
something
complicated
it
with
components
that
excuse
the
demography
and
then,
at
the
end
of
the
test,
I
will
check
whether
the
property
is
0,
I'm
going
to
ensure
that
my
component
actually
would
return
on.
The
matter
is
e
yeah.
B
C
B
And
you
want
to
be
one
of
the
questions.
I
was
brought
up
bullets
instead
of
making
this
you
know
just
return.
The
TRA
maybe
have
a
structure
type
that
we
return.
That's
you
know
I
disposable
when
I
suppose
have
a
return
to
the
mountain
to
the
moon.
Things
like
that
there's
ways
you
can
try
and
mitigate
this,
but
the
for
the
p1
one
of
the
goals
was-
or
at
least
the
the
initial
prototype
was
made
this
as
fast
and
simple
as
possible
right
where
no
to
make
asthma
as
efficient.
B
This
is
very
pretty
much
a
lightweight
optima
implementation,
where
my
pero
type
doesn't
use
the
whole
block
thing.
You
see
their
spin
Wade
with
interlocked
operations
to
try
and
be
its
cry,
be
safe
of
the
operations.
So
you
try
to
be
very
very
so
distressing.
It
is
thread-safe
yes,
well
is.
Where
does
one
make
suppose?
It's
always?
It
has
to.
C
Be
granted
by
the
way,
so
what
you
just
said
is
also,
I
notice
interesting
in
the
discussion
whether
we
should
help
its
share
it
or
not.
When
you
have
a
shared
bathroom,
you
actually
don't
need
this
disposable
rubber
for
battles,
because
you
can
always
reach
out.
When
you
have
a
brother,
you
can
always
return
it,
because
this
one
pool
shedule
the
moment
you
don't
have
the
shared
pool.
Very
often
the
components
need
to
have
this
shocked.
So
remember,
a
more
human
trainers
from
which
boom
was
this.
C
B
C
A
A
D
The
very
least,
though
you
should
have
a
mode.
It
says
the
whole
like
you
know,
don't
wait
in
whenever
you
give
something
back
drop
it
on
the
floor
and
we
give
you
new
one
and
that
way
someone
can
very
quickly
determine.
Is
this
a
buffer
pool
problem
or
not,
like
turn,
turn
off
any
reuse
of
the
buffer
pool?
If
the
problem
goes
away
and
there's
a
pretty
good
chance,
it
was
a
buffer
pool
problem,
at
which
point
you
can
now
turn
on
the
other.
Debuggable
to
this
is
that's
a
big
yes,.
A
A
B
D
D
A
controller
I'm
gonna
have
this
one
big
air,
1,
/
type,
there's
a
question
of
whether
you
there's
a
certain
value
in
keeping
track
of
that.
So
I
can
certainly
imagine
in
debugging.
It
would
be
interesting
to
know
whether
I
was
sleep.
You
know
my
component
was
leaking
or
somebody
else,
and
that
was
also
using
the
shared
pool,
was
leaking
its
if
you
could
somehow
tag
them.
That
would
be
useful
and
mezack.
D
I
haven't
thought
about
it
carefully,
but
the
idea
of
allowing
a
tag
for
at
least
debug
ability,
but
maybe
it
maybe
would
have
other
uses
locality
or
order
it.
Yes,
when
I'm
certain
expensive
sports,
this
tiny
tiny
planet
ought
to
call
your
life.
I'm
wondering
wondering
nederlands
for
a
smart
move.
I'm!
Sorry,
you
cut
out
you
asking
Kenya
object,
ids
and
event.
Source
events.
Is
that
what
you're
saying
ya?
What.
D
Very
sorry,
sir,
oh
I
see
what
you're
saying
you
could
certainly
imagine
that
so
then
source
we
actually
have.
You
can
do
one
of
two
things.
People
can
either
log
a
a
get
hash
code
which
basically
returns
you
you
know
for
object.
It
will
return.
You
basically
a
number,
that's,
roughly
speaking,
an
object,
ID
and
it's
usually
good
enough
for
these
kind
of
purposes
for
post
analysis,
but
obviously
it
doesn't
guarantee
uniqueness.
D
We've
also
toyed
with
the
idea
of
just
writing
out
the
object
ID,
and
there
are
events
that
let
you
know
when
gc's
happen
and
where
the
movement
happened.
So
you
can
actually
imagine
a
post
processor
that
can
do
a
perfect
job,
because
every
time
a
GC
happens,
any
movement
of
the
references
it
knows
about
and
it
tracks.
But
you
could
imagine
that's
a
little
bit
more
compliments.
D
You
know
that's
more
complicated,
and
so
if
people
want
to
do
really
lightweight
post-processing
that
that
usually
you
know
is
daunting
for
them,
but
yeah
we
could
definitely
have
some
instrumentation.
That
would
then
you
could
then
imagine
a
thing
that
looks
for
leaks
or
or
or
double
fries
of
things
like
that
double
fries.
It
probably
can't
figure
out
Hannah.
C
B
C
After
twice
he's
now,
gonna
have
the
same
array
twice
in
the
in
the
three
lets.
You,
oh
so
now
he's
gonna
rent
it
twice.
So
that's
like
a
poison.
You
know
like
in
a
in
a
queue
and
once
the
poisonous
in
there
you
screwed
you
now,
like
yeah,
I,
honestly,
think
we
probably
strong
double
return,
except
to
track
whether
we
double
it
and
is
expensive.
B
Guess
one
of
the
questions
would
be
then
know:
where
do
we
envision
envision
this
being
in
stack
right?
So
I
tried
to
make
this
as
low
level
as
possible
kitchen
on
user
within
the
framework,
and
if
we
want
to
use
in
if
we
want
to
raise
it
up
and
and
say
you
know,
this
is
a
dependency
on
things
like
collections,
generic,
then
I
was
suddenly,
can
start
using
more
and
more
of
the
framework
to
try
to
mitigate
some
of
these
issues.
B
D
A
C
When
one
more
question
about
the
ice,
the
clear
buffer
I
understand
the
value
in
the
return
batter.
My
paraffin
I
wanted
to
return.
The
batter
and
I
don't
want
others
to
see
the
data
very,
very
common
scenario
on
read
buffer.
It's
probably
less
useful,
but
I
don't
care
the
end
large
buffer,
which
one
is
cleared.
The
period
free
space,
the
new
space,
the.
C
B
B
C
D
D
C
C
B
B
C
A
C
D
C
C
C
D
D
I'm
also,
having
trouble
understanding
why
we
need
to
function
at
all.
Basically,
it's
one
line
instead
of
three
right:
we
do
it.
Kristef
set
you
you
rent,
a
new
bumper,
you
do
a
radar
copy.
You
return
the
old
bumper
and
it's
very
clear
because
you
can
specify
clear
buffer
on
both
the
rent
and
on
the
return
and
people
will
never
do
a
reality.
You
might
get
a
native
code,
so
there's
we
might
even
be
misleading
people
by
suggesting
that's
possible.
I
guess
I'm,
wondering
with
the
value
of
this
function
is.
B
Sure
in
this
goes
with
the
future,
thinking
of
you
know
sometimes
will
in
the
future
will
be
moving
towards
having
a
native
Russell
Poole
that
can
do
this,
and
if
we
want
to
keep
this
part
of
a
part
of
any
of
you
know,
consistent
API
space
then
make
this
an
abstract
class.
Then
we
probably
due
to
include
distance
of
the
contract.
No.
B
D
C
So
I
was
saying
something
not
something
slightly
differently.
I
would
say:
I
would
change
the
flag
from
clear
free
space
to
just
clear
buffer
and
it
always
refers
to
the
battery
that
I
returned
and
then
I
would
remove
this
flag
from
read
buffer,
because
when
I
rent
a
buffer
I,
almost
never
care
about
it
being
clear,
like
I,
don't
care
what
it
in
there.
What's
the
value
I'm
large,
then
why
don't
you
just
call
run
again
because
English
I
mean
the
su
said
it
sorry
lines
of
code
but
I.
C
D
A
A
No
I'm
saying
I
get
the
question
is
what
do
I
expect
right,
but
I
mean
I
would.
I
would
agree
with
crystal
that.
If
I
mess
it
up,
it
doesn't
matter
whether
it's
all
nails
or
zeros
or
garbage,
because
whatever
I
do
with
the
buffer,
I
probably
have
garbage
anyway,
because
now
I
have
some
other
random
data
in
my
stuff.
So
this
is
also.
B
In
terms
of
strange
right,
so
if
you're
using
this
to
kind
of
you
know,
do
something
around
strings,
if
it's,
if
it's
all
zeros-
and
you
say
you
know,
read
something
from
from
the
user
and
it's
not
necessarily
nawl
terminated
all
of
a
sudden,
you
can
start
reading
garbage
at
the
end
of
it,
whereas
if
you
say
clear,
the
array
make
it
all
make
it
all
moles.
Now
sudden
it
doesn't
matter
if
it's
not
null
terminate
because
you're
going
to
you're
in
it
how
to
terminus.
Anyway,
at
the
end
of
your
ray.
A
Yeah,
what
that
makes
it
necessarily
better,
because
now
you
have
a
string
of
length
15,
but
the
visual
sizes,
five,
so
I
mean
that
has
a
lot
of
issues.
I
mean
I!
Think
that
a
good
person
like
your
garbage
one
way
or
the
other
you
could
make
the
argument
and
say
that
mean
a
native
code
is
really
bad,
because
if
you
interpret
those
as
pointers
on
all
UAV,
suddenly
it's
particularly
bad,
which
is
why
initializing
their
makes
sense.
A
D
A
Every
clear
why
they
don't
have
to
write
a
loop
that
really
likes
you,
assuming
a
very
clear,
is
sufficient.
It's
not
bad
I
mean
I.
Think
the
thing
we
should
avoid,
though,
is
that
we
end
up
at
some
point
making
it
clear
by
default,
and
now
everybody
will
also
call
write
or
clean
all
you
do
it
twice,
so
that
would
be
really
bad
yeah.
So.
C
D
C
D
D
The
value
of
the
clear
buffer
is
is
if,
if
in
fact,
people
want
it
like
you
know,
they've
been
fine,
they
would
do
it
themselves.
Then
the
fact
that
sometimes
you
allocated
from
the
GC,
which
point
you
don't
have
to
do,
the
clerk
is
passed
through.
Sometimes
you
somebody
asks
for
clear
on
return,
so
you
had
to
clear
it,
and
you
know
it's
clear
that
again,
you
can
just
same
pan
into
it.
You
don't
have
to
like
do
the
actual
clear.
D
So
if
you
ask
for
it-
and
it
happens,
because
we
have
an
extra
knowledge,
we
can
like
avoid
that.
That's
where
it's
valuable,
but
it's
all
predicated
on
the
assumption
that
you'll
find
it
valuable
like.
If
you
really
don't
think
that's
a
common
case
then
like
let's
face
it,
the
cases
where
I
the
cases
where
people
say
I
want
to
clear
our
return,
our
kind
of
rare,
its
security
stuff
like
it's
stuff
that
I
really
care
about
security
and
then
the
initial
allocation,
which
again
hopefully,
is
rare.
Like
you
keep
reusing
buffers.
D
D
A
A
That
Internet
can
actually
use
it
because
I
mean
if
you
really
go
down
the
path
where
you
say
you
know
you
just
return
it
or
whatever
and
them.
Then
it's
a
bit
of
a
problem
because
I
don't
know
I.
The
keepalive
part
is
a
bit
of
a
problem,
but
I
mean
if
you
can't
use
it,
for
example,
to
manage
like
context
of
your
days
to
net
is
using
and
then
they
don't
use
the
pool
and
do
their
own
thing
that
that's
necessarily
networks
better.
But
this,
like.
A
D
A
C
D
B
A
D
That's
up
to
us,
we
all
I'm
saying
is
they?
You
don't
have
to
rely
on
the
fact
that
the
c-sharp
didn't
give
us
a
thing.
We
can
throw
an
exception
in
the
constructor
that
does
whatever
the
hell
we
wanted
to
do
so,
but
I
don't
think
we
want
that.
My
point
was
just
that
clearing
would
be
very
important
in
if
you
did
put
and
yeah.
B
D
A
D
B
D
C
B
That
I
mean
one
of
the
one
of
the
goals
that
says
to
reduce
complexity
around
this,
and
in
the
be
surprised
you
know
we
can
prevent.
These
are
those
on
the
foot
all
time
right.
So
there's
always
ways
around
it's
like
when
we're
trying
to
say
you
know,
limited
dis
drugs.
Well,
then,
you
can
wrap
us.
You
can
have
a
start
that
wraps
Hubble
objects
that
have
been
thrown
state
that
we
can't
see,
there's
no
different
ways
that
they
can
never
clean
yourself
in
the
foot,
but.
C
Release
like
there's
lots
of
concerns
about
you
know
we
can
brands
mention
well
in
the
past.
We
just
said
we
should
you
know
this.
You
should
take
care
of
these
things,
and
now
we
are
releasing
a
public,
you
know
buffer
pool
and
we
had
the
property
shared.
I
can
imagine
more
and
more
people
with
using
it,
so
I
would
kind
of
error
on
the
side
of
making
it
hard
for
people
to
shoot
themselves
in
the
foot
with
it.
C
A
It
I
mean
I
would
also
say
that
I
think
we
should
probably
think
about
how
a
native
of
a
pool
would
look
like,
because
I
would
imagine
that
some
of
the
policy
decisions
will
probably
be
slightly
different.
Culminated
pop
up
or
more
conservative
I
agree
with
what
what
Stephen
said
that
you
can't
really
have
an
abstract,
baster
but
I
think
there's
the
probably
should
make
sure
that
the
API
interaction
levels
of
holes
are
somewhat
aligned
and
meaningful.
C
So
one
last
thing
about
great
guys:
the
name
is
kind
of
long
and
the
generic
time,
and
when
it
conditioned
property
or
if
we
have
shared
property,
it's
a
bit
throws
it
used
to
be
so
nice
to
use.
You
know
I
used
to
have
just
buffer
full
of
bites
right
and
it
was
buffer
pool,
dot,
shirt,
dyed
red
and
you
could,
like
you
know
you
would
like
write
it
in
line
to
just
rent
a
muffin
right
right
now.
It's
managed
buffer
pool
off
by
that
shirt
that
rent
buffer
yeah
can.
A
B
C
D
A
C
Know
today
is
somebody
was
asking
about.
You
know,
answers
and
I'm
now
working
on
their
resource
either
maybe
ice,
and
I
discovered
the
API
that
I
wrote
several
times
over.
I
need
it
again,
which
is
like
binary
reader,
except
it's
set
up
like
static
method
still
just
like.
I
should
prefer,
and
I
just
want
to
interpret
you
know
four
bytes
as
a
games.
I
wonder
whether
we
could
come
up
with
a
night
space
name.
That
basically
says
it's
like
big
data,
manipulation.
C
A
A
A
C
B
A
A
D
A
C
D
D
A
D
We're
setting
a
new
precedent
because
that's
what's
gonna
happen
everything
everyone,
you're,
borrowing,
something
you're
gonna,
be
renting
it
everything
you're,
getting
things
that
you
don't,
but
you
might
really
so.
This
idea,
though,
that
we
have
one
big
pool
for
everyone.
I
think
that's
important
thing,
so
we
can
putting
in
a
static
right
here.
D
B
B
D
I
think
I
think
we
should
probably
seriously
figure
out
whether
we
can
do
this
adaptively
like
this
one
too,
because
realistically
I
mean
we
can
have
someone
can
pass,
but
but
mostly
the
ideas
that
will
figure
it
out
is
the
contract.
And
now
we
aren't
this
problem
with
this.
One
shared
one
and
frankly,
I
would
actually
hide
the
constructor
and
call
today.
So
again
you.