►
From YouTube: .NET Design Review: System.IO.Pipelines
Description
We'll do an API review for the upcoming System.IO.Pipelines.
B
B
E
Put
an
idea
of
what
the
whole
set
of
api's
looks
like
otherwise,
there's
always
dislike
okay.
So
today
we
reviewed
five
types:
when
does
it
end?
So
this
is
basically
the
whole
surface
area.
We've
worked
on
other
the
most
of
the
work,
but
we've
worked
on
kind
of
simplifying
the
API
is
preparing
it
for
the
API
review.
There
was
more
types
in
the
past
more
api's,
now
I
kind
of
feel
that
it's
relatively
simple.
But
you
know
this
is
the
full
list
of
types
yeah.
D
So
we
kind
of
have
three
categories
of
that.
First
category
is
just
the
basic
multi
segmented
buffer,
committed
both
for
reading
and
for
writing.
The
second
part
is
pipelines,
implementation
itself,
and
the
third
part
is
the
utility
and
additional
types
we've
had
to
invent
well
in
Connecticut.
Most
of
them
are.
D
D
H
D
E
And
they
represent
a
single
buffer
of
contiguous
memory,
but
when
you,
in
that
situation
like
in
a
web
server
or
in
any
kind
of
you
know,
pipeline
scenario,
you
sometimes
end
up
in
a
situation
where
you
have
data
that
cannot
be
stored
in
a
single
batter
for
various
reasons.
So
read-only
buffer
is
a
moral
correspondent
to
memory
of
fight
where
the
data
is
not
in
two
contiguous
memory
battle,
it
can
be
basically
a
chain
of
buffers,
but
it's
kind
of
the
same
thing.
E
D
You
know
concentrate
of
the
attachments
too
much
chicken
squawks
life-
that's
the
that's
our
multi
segmented
buffer
reading
thing.
So
if
there
are
three
types,
two
main
types
that
roughly
correspond
to
three
type
of
sweet
cash
from
the
our
memory
architecture,
so
we
have
a
buffer
least
that
represents
roughly
a
linked
list
of
linked
lists
of
I.
Think
is
the
best
that
you
can
implement
on
wherever
that
is
actually
attempt
just
to
feed
it
into
the
redundant
buffer.
That
is
an
exchange
that
we
are
hoping
to
be
used
between
a
high
level
person
primitives.
D
You
pass
it
into
XML
parser
to
parse
a
second
with
multi,
segmented
memory,
and
when
we
try
it
using
it,
we
found
out
that
for
some
things
for
situations
where
you
need
efficient,
that
reads:
you
need
something
that
works
not
on
read-only
memory,
but
up
spent.
So
we
have
the
third
level
of
Poppa
reader
that
keeps
a
single
segment
of
freedom
a
buffer
in
a
span
and
provides
you
very
performant,
but
the.
E
E
Every
time
you
read
an
INT
and
next
in
the
next
int
we
would
be
accessing
the
span,
which
is
relatively
expensive
to
get
the
span
out
of
memory.
So
buffer
reader
is
a
stark,
only
type
it's
a
by
redline.
It
store.
It
basically
takes
the
span
out
of
the
next
segment
stores
it
in
a
field
and
then,
when
you
read
an
int
and
next
in
the
next
int,
it's
super
fast,
because
this
palace
or
already
day.
D
Yeah-
and
there
is
another
position
so
read-only
buffer
is
basically
two
pointers
into
I
bufferless.
Each
of
them
is
a
segment,
and
it's
a
pointer
to
segment
itself
and
position
in
the
second,
so
slicing
is
almost
grape
slicing
is
creating
another
instance
of
freedom
with
Mark
instructor
is
just
different
than
before.
That's
why
we
didn't
do
just
in
offset
from
the
very
start,
because
it
wasn't
very
mutual.
D
E
Sounds
like
again
going
again
back
to
the
analogy
in
memory
of
tea.
We
use
the
an
India
as
a
way
to
say:
I
want.
You
know
this
byte
inside
my
memory
for
this
contiguous
buffers.
You
don't
want
to
lose
ins,
because
then
you
would
have
to
basically
search
so
position
is
kind
of
a
small
stripe
that
has
both
a
pointer
to
the
actual
segment
and
then
index
within
the
segment.
D
It's
like
it's
very
what
I
said,
but
pearl
is
yeah,
so
reading
is
good.
We
also
needed
something
on
the
writing
side
and
it's
much
simpler
than
that.
Then
the
Rings
I'll
put
it
basically
an
attractant
that
allows
you
to
say.
Give
me
a
bumper
and
to
say:
I
wrote
that
much
into
a
buffer
and
to
say
I
want
more
space
and
again
he
is
intended
to
be
used
by
more
high
level.
D
Writing
primitives,
not
like
in
the
format
that
the
span
is
enough,
but
it's
MLC
realized
the
realize
something
that
is
expected
to
write
enough
data
to
justify
having
all
this
abstraction
for
multiple
purpose
and
alpha.
Prattler
is
again
writing
into
memory
and
getting
spent
per
memory.
Every
time
isn't
very
efficient.
D
D
L
A
E
D
And
now
by
wines
or
white,
wherever
you
where
we
decide
to
go
in
this
region,
yeah,
so
the
problem
with
threads.
So
one
of
the
problems
we
try
to
show
is
in
fact
for
working,
but
first
of
them
was
that
our
stack
seems
to
capella
and
buffer.
A
lot
into
every
class
has
its
own
byte
array
buffer,
that
it
manages
and
has
some
size
that
everybody
says
for
itself.
D
So
if
you
go
from
reading
file
to
write
into
console-
and
if
you
want
to
transport
and
use
stream
reader
in
the
middle
you'll
end
up
with
firefighter-
is
that
every
one
of
them,
especially
if
you
then
use
JSON
or
some
other
like
serialization,
a
pass
you
get
tons
of
by
the
right
and
each
of
them
tries
to
park
enough
data
to
to
fit
their
needs?
And
this
scoping
first
spends
time
on
memory,
and
you
cannot
control
it
and
most
of
them
don't
a
proper
size.
D
So
five
is
the
primitive
that
allows
single
producer
and
single
assume
consumer
to
exchange
multi
segmented
by
basically
written
with
buffers
without
need
to
copy
ever
so
they're
the
same
memory.
The
producer
got
when
it
wrote
the
data
the
same
memory
would
consumer
get
when
it
hit
with
it.
We
also
manage
the
pooling
of
all
the
data
structures
and
satified
and
the
pipe
itself
it'll
either
settle.
So
you
give
this
really
cheap
API
to
exchange.
L
D
Will
manage
the
pool,
and
now
you
have
to
do
that
to
be
my
animator.
Oh
yeah,
then
compensate
yeah,
so
these
animation
will
show
you
the
typical
lifetime
of
the
spent.
Oh,
the
pipe
so
on
the
writer
side.
First
have
to
call
ballot
that
will
give
you
some
segments.
It
will
ask
for
a
segment
from
memory
book
and
give
it
to
us.
I
opted
that
mixes.
D
Then
you
read
some
data
into
the
segment
and
then
you
decide
to
write
more
than
a
second
and
when
you
write
more
data,
when
you
tell
I
output
ensure
that
I
have
three
bytes,
the
right
people
say:
oh
you
don't
have
to
buy,
only
have
one
byte.
Let
me
rent
another
segment
for
you
from
the
group
and
when
you
flush
this
data,
you
see
that
it
became
yellow.
D
D
D
D
So
it
can
say
advance
but
doesn't
advance
to
the
variant
advance,
just
where
I
know
that
I
consume
the
data.
So
when
you
advance
and
it's
the
next
foot,
start
pointer
of
the
pipe
moves
forward
and
that
the
queue
is
easy
to
cross
the
second
boundary,
we
would
have
returned
the
buffer,
but
for
now,
until
it
didn't
keep
the
segment
plate.
D
So
the
next
time
you
have
a
can
write
will
append
the
data
you
flash
it
and
when
you
call
read
again,
you'll
get
all
the
data,
starting
from
the
point
to
where
you
have
less
advance
the
last
time.
So
now,
when
you
read
the
rest
of
the
HTTP
request
and
at
last,
then
we
bring
all
the
partners
in
the
fight.
Ok.
So
this
is
one.
E
Interesting
feature
of
kind
of
this,
you
know
pipelines
that
when
you
use
our
existing
api's
or
your
kind
of
open
code-
and
you
deal
with
consumer
producer,
you
kind
of
have
to
know
when
you
can,
for
example,
return
buffers
to
the
buffer
pool
and
it
it's
really
tricky
to
know.
When
you
are
done
pipelines
kind
of
the
philosophy.
Is
you
don't
allocate
buffers?
You
don't
dispose
buffers,
we
will
do
it
for
you.
You
just
tell
us,
you
know
the
writer
says:
here's
where
I'm
writing
and
the
reader
says.
Here's
where
I'm
already
done
with
right.
L
D
You
when
you're
alert
you
get
high
output
and
you
can
write
into
I
output
as
so
we
have
this.
Each
side
has
two
operations
to
start
and
to
complete
on
the
writer
side,
it's
valid.
That
gives
you
an
eye
out,
put
and
flash
that,
and
that
can
means
data
into
the
five
and
it
makes
it
available
to
the
reader
so
get
between
Alec
and
flash.
D
So
there
is
that's
why
it's
a
single
producer,
single
consumer.
We
well
as
a
it's
reverse
era.
With
that
you
keep
this
though
there
isn't
like,
but
you
will
be.
We
keep
this
force
you
to
keep
two
methods:
girls,
and,
if
you
don't,
you
will
just
throw
it.
You
verify,
because
it
helps
to
avoid
a
lot
of
a
lot
of
by
just
forcing
you
to
pull
up
the
pattern
and
so.
D
N
D
What's
another
than
anymore,
so
if
reader
says,
if
writer
says,
I
won't
write
anything
I,
would
we
have
some
specific
buffer
management?
There
are
scenarios
if
we
posted
without
gear,
even
if
there
was
there
and
part
four
in
path,
we
can
just
throw
everything
away,
so
you
can
even
complete
if
you
are
in
the
middle
of
read
or
write.
So
we
force
you
to
correct
it.
Put
a
leak,
go
belly.
O
E
D
D
D
You
don't
delegate
anything
industry,
you
just
Oh
who
pulls
reset
the
producer,
the
consumer
or
so
so
you
need
both
of
them
to
agree
to
complete.
First,
yes
and
then
the
third
entity
that
owns
the
pipe
completely
cause
I
said
the
country
Tecna
me
said
not
yet
here,
and
so
we
have
five.
We
have
two
sides,
reader
and
writer,
that.
L
O
L
Anything,
it
is
much
more,
it's
just
it's
very
it's
very
weird
to
have
a
dotnet
type
that
has
that
behavior.
This
is
not
okay,
yes,
but
fast,
and
you
don't
you
don't
want
to
make
it
easy
to
get
wrong
easy
to
continue
right.
Oh
that's!
Why
I
throw
at
you
in
every
way
possible
when
you
try
to
reel
it
like
that
and
you're
incurring
performance
overhead
from
doing
the
Sharks
now.
C
E
It,
let
me
just
like
say
so:
a
I
feel
like
read-only
buffer,
so
yeah
I
started
to
work
in
convex
lamp
on
a
representation
for
this
contiguous
segments
of
memory.
It
was
called
read-only
bytes,
and
then
we
converged
on
the
read-only
bath.
I
kind
of
feel
that
you
know,
regardless
what
happens
with
pipelines,
I
think
it
would
be
good
for
BCL
to
have
a
representation
whenever
you
kind
of.
E
Have
you
know
several
byte,
arrays
and
or
maybe
not
several,
and
you
won't
want
to
put
them
in
a
Singh
turn
it.
Let's
say
from
some
method.
What
is
the
type
that
you
would
use?
So
I
kind
of
you
know
we
converged
on
this
type
and
I
feel
it
a
pretty
lightweight
representation.
It
was
more
specific
to
how
pipelines
work
and
we
changed
it
such
that,
for
example,
you
can
wrap
a
single
byte
array.
You
remember
like
in
memory
of
T.
It
was
a
bit
heavy
weight.
E
E
N
E
L
E
Just
it
so
this
type
is
used
quite
often
in
api's,
and
you
know,
like
kind
of
API
is,
in
my
opinion
too
busy.
If
you
have
these
small
things
that
are
meant
to
be
but
I
buy,
that
mirror
I
buy
your
you're
concerned,
but
I
would
like
to.
If
we
feel
that
position
is,
we
want
to
reserve
for
something
else,
I
completely,
don't
my
like.
We
should
just
rename
it
but
I
general
and
make
it
two
words,
because
it
kind
of
shows
in
the
same
places
where
you
would.
E
L
S
E
U
E
A
A
L
Is
it
so
I
have
a
random
question
then
say
that
you
have
a
read-only
buffer
that
consists
of
mold
together,
okay,
so
you've
you've
called
the
fourth
instructor
over
lived
there,
you
have,
you
have
an
ibuffer
list,
you
call
with
your
read-only
buffer
shrunk,
you
now
called
dot
start
and
end,
and
you
have
two
different
positions
that
come
back.
What
happens
if
you
take
those
start
and
positions
and
now
pass
them
into
the
fifth,
the.
D
D
V
E
E
D
E
D
E
E
Fast
and
help
that
you
know
Josh
was
suggesting
validate
metal,
but
I
think
that
validate
would
like
code
call
it,
and
would
we
still
have
this
constructor
so
like
most
people
would
not
call
it
so
we
didn't
yet
self
and
crowded
so
I.
What
I
was
thinking
about
this?
Could
we
make
it
such
that
public
API
hundreds
validate
and
we
use
something
else
when
we,
you
know,
create
the
buffer
list
and
create
the
thing?
You
know
the
whole
chain
and
we
know
that
we,
but,
on
the
other
hand,
imagine.
D
D
Method,
wouldn't
ya
have
to
do
this
yeah?
We
could
do
something
like
this
is
well.
We
tried
to
get
as
much
of
validation
as
possible.
For
example,
we
have
fresh
shaking
instead
out,
but
only
when
it
doesn't
hurt
the
performance
so
much.
We
don't
want
validation
to,
for
example,
reverse
entire
populace,
because
that
would
cause
things
to
slow
down
dramatically.
For
example,
if
you
have
a
long
buffer
list-
and
if
you
have
a
writer
and
the
reader
and
readers
are
sound,
does
something
slowly
reverse.
D
Or
spiral
so
either
worth
anything,
that's
or
and
we're
in
this
kind
of
segments.
If
you
didn't
tell
us
if
you
say
slice,
ten
thousand,
but
we
have
to
work,
we
have
to
work
the
buffer
list
for
you.
But
if
you
don't
tell
us
to
do
anything
expensive,
we'll
try
not
deliver
any
cases.
We
would
AP
because
we
got
you
know
something
if
you
you
can
break
this
type
by
passing
in
order,
it's
not
bulletproof
from
people
trying
to
break
it.
J
D
X
N
E
D
Y
E
The
only
thing
continuously
so
that
something
the
reason
for
it
for
the
constructor
with
byte
array
is
you
kind
of
in
a
lot
of
situations?
You
have
a
child,
but
then
let's
say
you
slice
and
slice
it
and
you
end
up
with
a
sink
who
fight
the
red.
You
would
then
cut
it
and
return
it.
So,
let's
say
a
trace
on
you
know.
Jsonparser
parse
is
lots
of
buffers
trained,
and
then
you
asked
for
an
a
return
one
of
these
tags.
Why
would
it.
E
H
S
E
Has
two
fields:
they
are
both
positions
and
when
you
have
an
array
position,
you
remember
has
two
fields:
one
is
an
object
and
one
is
an
index
and
when
you
pass
an
array,
you're
gonna
have
a
position
start
pointing
the
object
points
to
the
array
and
the
index
is
zero.
No
I
didn't
know
position
an
object.
E
L
E
D
Want
range,
checking
you,
don't
you
just
don't
want
to
move
positions
as
far
as
you
want,
this
type
would
allow
you
to
not
let
user
go
after
then.
We
are
checking
that
offset
that
you
moved
to
please
inside
the
read-only
buffer
uring.
So
you
cannot
go
and
drink
some
random
memory
outside
of
what
you
so.
O
O
A
pipe
the
pipe
diagram
is
showed
like
the
rewriter
having
a
single
these
buffer,
a
buffer
is
kind
of
window
to
give
the
reader,
and
the
reader
actually
has
worked
that
point
to
the
entire
chamber,
like
they
can't
see
past
what
they're
given.
So
this
kind
of
a
thing
that
says
moving
that
bounds,
we
don't
go
patent
about
what
the
dead
space
is
environment,.
E
O
Just
put
a
point
on
it:
position
is
shared
like
it's,
it's
called
abstract
right,
but
it's
still
just
a
struct.
It's
not
interface
and
a
position
can
be
created
for
types
other
than
read-only
buffer,
which
would
be
incompatible
with
read-only
buffers.
So
basically,
this
read-only
buffer
is
the
only
thing
that
knows
what
to
do
with
position.
If
position
had
a
back
reference
to
the
read-only
buffer,
then
you
could
click
convenience
method,
son.
You
just
described
the
C++
specific
yes,
so
we
have
technical
iterators
in
sequel,.
G
D
And
it
says
so:
we
have
read
there
that
most
where
it's
at
inside
the
redundant
buffer
but
read
only
Barbara
it
just
if
you
on
the
segment
of
Ruth.
Do
you
want
me
only,
but
for
that
it's
not
a
register.
It's
a
secret
turns
position.
So
if
you
just
changes
the
position
moves
the
position
you
gave
it
and
returns
during
your
one
surplus
count.
A
The
way
I
understand
it
is
that,
because
we
only
buffer
as
well
as
singles
balance,
it
sits
in
list
behind
the
covers
I
think
the
positions
themselves
don't
have
access
to
the
list,
so
they
don't
know
how
they
would
be
able
to
represent
their
next
location
of
memory.
Essentially
right.
So
they
have
to
ask
the
other
guy,
but
I
think
it's
hard
to
say
that
only
buffered
stuff
doesn't
have
a
notion
of
a
current
right.
Yeah
resume
last
in
there
again
and.
D
D
S
AB
S
D
V
L
That
point
you
don't
have
the
numerator,
the
numerator,
the
position
become
the
same
type
in
the
numerator
is
implemented
as
position
hotspots,
because
it's
really
nice
to
express
if
you
get
something
selection,
do
some
other
bother.
What
is
it
so?
You
make
two
read-only
buffers
they're
completely
unrelated,
and
you
pass
the
wrong
position
into
the
wrong
one
and
call
it
it
ask
it
to
see.
What
does
that
do?
What
does
it
do
with
you
if
you
pass
one
into
another
rings
and
kills
it
little
bit
like
I?
E
E
W
O
L
D
D
E
P
O
Really
quick
really
buffering.
Is
this
inertia
that
we're
not
going
over
today?
But
if
you
right
extension
lessons
on
that
interface,
that's
why
you
want
position
to
be
like
his
first
class
thing,
so
we
don't
leave
operator,
length,
I,
suppose
I,
just
yeah,
so
I'm!
Sorry,
like
that's,
not
what
this
video
about,
but
I
mean
it
influence
decisions.
Clearly.
L
D
O
E
AC
X
L
X
AD
E
E
L
X
D
D
E
We
talked
about
this.
This
is
one
of
the
considerations
we
we
could
change
a
buffer
list
to
a
linked
list.
The
first
property
would
be
called
item
next
and
we
need
virtual
index.
Then
you
is
with
me
at
least
like
type,
but
the
question
was:
do
we
need
this
general
I
linked
list
interface
in
the
VCL?
If
we
feel
that
we
needed?
E
Maybe
it's
the
right
thing
to
do
if
we
are
not
sure
whether
we
need
this
general
new
collection,
interface
or
link
list,
then
this
interface
is
a
bit
more
like
busy,
because
let's
say
we
have
a
genetic
link
list
interface.
Suddenly,
all
pipelines,
simply
you
know
api's,
say
I
linked
list
of
memory
of
mine.
It's
like
generic
inelastic
generic
names.
It's
not
a
big
deal,
I
think
because
their
list
only
shows
up
in
the
constructor.
It
wouldn't
be
a
big
deal.
I
think
you
guys
would
okay
with
verify
it's.
E
E
L
L
L
AD
E
We
kind
of
started
on
this
path
of
having
the
read
and
read
on
the
end.
Readwrite
types
will
span
and
memory,
there's
a
trade-off
here,
correct
like
it
all
now
is
it's
very
viral.
You
can
kind
of
keep
going
and
suddenly
you
have
like
two
frameworks
as
a
read-only
framework
and
the
reader
framework,
because
we
don't
have
you
know
readability
in
in
in
the
language.
It's
not,
so
we
could
do
what
you
they.
R
E
S
S
E
D
With
the
length
of
the
last
segment
of
a
buffer,
this
can
change.
So
if
you
wanted
one
segment
to
the
next
segment,
it
should
be
fixed
in
place,
but
they
still
a
motivation
index
and
you
have
to
keep
a
virtual
running
index
of
and
what
it
is.
Is
previous
note,
virtual
index,
plus
your
current
things,
and
you
said
it
when
you
push
it
currently
inside
indexing.
D
E
E
A
These
for
general
purposes,
making
employers
and
yeah
I
think
I'm,
like
I,
think
list
in
general,
I
think
a
lot
you
so
bender
generic,
but
I
think
that
this
one
is
like
like.
If
you
really
want
understand
that,
like
I,
think
it
helps
to
have
naming
it's
very
specific
to
what
the
scenario
is,
especially
when
virtually
it
next
I
mean
yeah
the
name
of
the
idea.
D
E
L
L
N
E
About
it,
because
today
to
create-
let's
say
you
you
know
like:
if
you
have
a
single
byte
array
or
you
have
innumerable
of
byte
arrays,
you
can
call
the
constructor
some
read-only
buffer
and
just
pass
them.
But
let's
say
you
want
to
kind
of
a
very
common
scenario.
If
you
not
I,
I
use
these
types
in
some
code
that
doesn't
use
five
five.
Z
E
L
D
Should
be
other,
we
should
into
one
it
segment
that
inside
the
part
and
the
other
one
is
internal,
put
it
on
the
paper
that
gets
made
it
when
you
put
ienumerable
of
memory.
So
any
part
sign
number
of
memory
redundant
part
has
its
own
segment
single
it
chains
together.
Then
we
have
two
or
three
others.
A
Y
L
If
it
is
public,
it's
an
exchange
type,
that's
or
whatever
anyone
wants
to
use
it
for
yeah.
We
cannot
constrain
what
our
users
do
with
types
unless
the
constructors
permit
them
from
doing
it,
especially
since
we
told
people
feel
free
to
stomp
on
this
type
as
much
as
you
want
you
to
build
your
own
version
of
the
interface
like
that's
that's
what
I've
heard
from
this
table
tonight,
yeah.
R
O
D
R
D
L
A
R
Q
AA
AA
N
X
X
X
AF
L
AA
D
X
O
X
X
E
E
Are
saying
that
because
otherwise
you
wouldn't
be
able
to
access
with?
Oh
one,
a
data,
as
you
were
saying
when
assignment
is
to
access
data.
So
if
there
was
no
segment,
you
coded
you.
Basically,
you
will
just
give
an
offset
fergie
and
you
would
have
to
work
a
chain
of
linked
lists.
You
show
how
to
that
index
now.
Q
V
D
D
E
One
issue
and
I
think
a
good
suggestion,
the
a
because
there
are
two
different
indices.
Maybe
it
would
be
good
to
both
of
them
to
have
a
name
that
makes
it
super.
You
know
which
one
is
virtual
on
this
segment
so
like.
If
we
named
this
one
segment
thanks,
it
would
be
very
clear
that
it's
an
index
of
this
segment,
not
you
don't
grow
back
and.
D
J
A
C
AB
P
S
D
AB
E
E
A
A
E
L
AB
E
E
Q
A
Understand
like
what
do
you
argue
might
have
to
do
above
the
off
team,
because
I'm
like
it's
today,
it's
called
only
but
all
right,
they're
already,
like
whatever
you
just
say
about
abuse,
where's
this
critique,
because
that
already
exist
the
proposal.
Is
it
there
nothing
to
do
about
key
or
not
the
idealistic
so.
A
E
E
AG
L
Here
you
call
it,
you
don't
need
buffers
or
read-only
memory
lists
so
separate
remaining.
Can
we
make
the
slice?
Can
we
make
any
method
whose
first
argument
is
position
static
right?
The
reason
being
that,
if
you
take
position,
is
the
first
argument,
your
you
can
really
work
with
any
read-only
buffer.
It
doesn't
have
to
be
this.
So
why
have
the
this
implicit
work?
You.
D
L
O
L
E
L
A
To
me,
because
it's
static
methods,
it
kind
of
implies
mutation.
It
always
confuses
me.
Basically,
you
just
ask
for
a
pointer
to
be
advanced.
They
get
me
on
stream,
for
example,
make
sense
acquisition
innocence
because
it's
a
state
of
the
screen
itself,
I
guess
in
this
case,
one
of
this
is
state.
The
only
reason
you,
but
this
pointer
is
so
that
you
get
access
to
additional
data
that
you
need
for
validation
purposes,
but,
like
it's
not
mutating.
The
state
of
this
thing,
unfortunately,
but
I
would
say.
A
L
E
E
D
E
A
You
but
I'm
saying
instead
because
I
mean,
if
you
look
at
string
right
stream
as
a
position
and
like
seek
methods
and
their
instance
method,
because
they
mutate
the
current
state
of
the
stream
a
because
they
literally
advance
the
position
that
the
stream
points
at
white
versus.
In
this
case,
you
call
API,
is
that
a
position
related
they're
all
instance
members.
But
it's
a
bit
confusing
I
look
at
the
API
for
the
first
time.
You
assume
that
all
that
call
sly,
that
you
know
move
for
example
like
I.
A
E
L
Here:
here's
a
concrete
a
shot
now
so
I
have
I,
have
a
byte
array,
which
is
one
megabyte
in
length.
I
pass
it
into
the
memory
shrink,
constructor
and
I,
say
I
say
only
expose
zero
to
nine
hundred
K
to
the
consumer
and
don't
allow
access
to
anything
else
like
memory
stream
will
not
provide
you
that
last
100
K
about
this
one
same
league
is
run
if
I.
If
I
knew
a
position
and
assitive
know
it.
L
Q
D
O
E
E
D
D
Z
G
X
U
X
X
E
N
X
D
E
E
You
still
have
just
no
you'd
have
to
win
his
relative.
We
don't
have
a
new
interface,
no,
no,
no
he's
so
quick
there.
Okay,
it's
kind
of
okay,
fine,
I,
understand
what
you
are
saying.
If
we
ever
run
into
the
situation
that
Jeremy
was
talking
about,
which
is
super
hypothetical,
which
is
somebody
gives
you
read
on
memories,
I'm
playing.
X
X
A
S
A
E
Survived
this
is
an
excellent
representation
correct
and
it's
neither
I,
and
then
you
can
imagine
there
are
two
rappers,
one
is
City
Tandy
and
one
is
readwrite.
If
we
end
up
with
three
types
the
moment
we
start
like
splitting
this
interface
with
an
I
end
up
with
four
types
and
a
that
like
just
like
it,
I
don't
like.
A
Sort
of
what
is
it
versus
that
I
mean
it's:
a
simulant
I
only
took
every
notice
it.
You
basically
have
to
make
them
convertible,
and
you
basically
have
to
say
we
white
one
has
to
hear
it
from
we
don't
use
and
like,
in
fact,
is
I'm,
not
sure,
that's
worth
it,
because
you
have
all
this
complexity,
opening
a
Bible
and
Eric
are
we.
E
To
hear
I
see
points
show
me
that
this
is
this
should
be
read.
Right
is
because
it
bothers
me
like
a
it.
The
fact
that
we
have
written,
expand
and
span,
and
returning
memory
and
memory
it's
already
too
much
and
I
really
don't
want
to
keep
going
like.
We
should
by
row
like
it's
sort
of
IRA
regarded
or
to.
A
Meet
the
same
thing
with
like,
if
you
look
at
list
of
tea
right,
it's
read
right:
there's
no
weed
only
list
of
tea,
there's
high
level
things
that
wrap
those
guys
and
that's
the
same
thing
here
like
they
fell
and
promoted,
was
I
buffer
list,
and
then
there
is
we
only
buffer.
The
maybe
you
know,
read,
write
buffer
at
some
point
if
you
ever
cared
and
then
which
is
rare,
but
we
have.
L
X
D
Z
G
Z
B
L
L
K
L
Q
D
E
O
R
L
E
E
R
A
No,
like
that's
exactly
what
we
do
provide
we
don't.
This
is
horrible
because
it
means
then,
if
we
add
I
only
later
yeah,
it
means
you
can
only
have
I
per
Phyllis
inherit
from
I,
we
don't
in
Geneva.
Well,
then,
you
have
basically
all
the
public
that
we
have
evolved
to
fit
in
the
frame
work
where
you
have
no
same
representation.
L
E
E
O
C
Q
Q
N
L
A
The
notion
of
emmerich
always
said
you
are
good,
that's
good
or
bad,
but
emotions
always
been
that
mean
only
is
effectively.
You
always
say
that
that
makes
no
guarantees.
It
just
means
you
can't
program.
It
doesn't
mean
that
the
saying
underneath
you
can
change
that
for
the
immutability
does,
and
so
that's
why
we
always
said
like
every
collection
time
that
is
mutable
it
kinda
has
to
be
C
influenced
or
we
don't
leave
you,
but
that
gets
its
and
that's
the
bottom.
Ideally
I
list
up
to
you
would
inherit
from
Irene
only
this
stuff.
A
AA
E
That
I
really
want
to,
like
my
main
objective,
is
I,
don't
want
like
ever
in
the
future
and
that
we
free
the
region
is
right.
I
linked
this
sort
of
effortless,
so
everything
what
I'm
worried
about
right
thing.
We
change
it
today
to
read
only
what
one
and
then
in
the
future
you
want
to
do
some
reader.
You
know,
write
a
book
buffer
that
has
a
list
of
three
di
things
and
then
we
have
to
add
another
interface,
and
then
we
basically
like
keep
adding
read-only
and
read/write
interfaces
for
everything.
This.
E
E
You
know
somebody
gave
me
already
read
only
this
and
then
we
make
the
design
such
that
it
results
in
more
types
and
the
scenario
sound
effect
of
ethical
I
wasn't
talking
about
that
because
I
was
talking
about
the
extra
caching
or
doing
every
time,
I
forget
the
casting.
So
let's
talk
about
the
performance
so
interesting.
This
happens
read
it
from
object
to
first.
D
Q
E
E
At
first
the
West,
but
performance,
this
is
what
those
readers
and
writers
are
because
forget
about
discussed,
just
getting
a
span
out
of
memories
too
expensive
for
a
majority
of
the
scenarios
that
that's
why
he
was
talking
about.
On
top
of
this
whole
thing,
you
have
readers
and
writers.
That's
how
you
do
a
lot
of
this.
They
basically
call
this
API
whatever
well,
they
cast
into
expanding
toward
the
span
and
then
they're,
either
just
ran
straight
into
the
security
said,
visited
views
if
these
cost
only
or
harassment.
Basically.
B
D
X
X
Q
D
AE
AD
Q
D
AA
E
With
segments,
then
you,
oh
by
the
way
this
is
my
petty.
This
property
is
a
single
span.
It
should
be
called
a
single
segment
because
how
many
spans
this
all
universe,
some
of
them,
are
the
segment
some
of
their
sub
segments,
some
of
them
span
segments.
If
you
copy
that
span,
is
the
name
of
it
ties
here,
no
you're
a
yes!
It's
in.
L
Said
there
were
extension
but
thats
hanging
off
of
this
too.
Are
there?
Are
there
api's
that
allow
things
like
I
just
want
to
start
reading
arbitrary
and
squibs,
whatever
from
a
read-only
buffer?
So
what
do
mean
by
arbitrary
so
like
that
I
want
to
read
the
next
four
bytes
and
treat
them
as
a
32-bit,
integer
or
I
have
to
revamp.
V
D
V
V
E
Has
nothing
more
profile
up
for
the
thing,
so
like
I
kind
of
I
I,
don't
think
we
have
Chris
guidance
when
to
use
extension
methods.
There
is
negative
of
using
a
session
methods,
it
kind
of
like
you
know,
random
types
in
the
namespace
and
they
random
methods
that
you
don't
know
what
they
apply
to
and
like
I,
don't
know
if
it's
worth
it
I
think
well,
what
was
definitive.
P
Q
E
A
Downside
of
this
approach
is
that,
like
hearing
this
sounds
great,
but
in
practice
it
leads
to
way
more
types
being
created.
It
makes
documenting
times
harder
than
I
have
like
grievant
times.
You
have
to
merge
them
and
the
other
day
like
it
to
me,
like
honestly,
that
we
might
see
a
bit
of
the
layering
discard
where's
the
fire,
because
I
would
be
nice
and
thick
layer
insanely.
But
in
the
end,
because,
like
like,
is
this
I
don't
know
like
on
the
actual
type
should
be
cordoned
requiring
house
it?
A
A
The
super
lightweight
super
targeted
like
I,
think
we're
is
nothing
not
known
out
like
I
would
say
anything
that
is
utilitarian
and
tied
to
you
know
other
ties
that
are
in
higher
levels
or,
like
you
know,
super
like
weird
behavior,
like
yeah,
making
extension
like
this.
What
you
have
interface
we
just,
can
you
don't
want
to
have
them?
Why
didn't
we
put
everything
on
spend
them?
We
have
index
of
this
non-spell
yeah.
The
reason
for
that
was
a
nasty
on
the
question.
A
I
mean
like
because
I
made
the
same
segment
there
and
like
yeah
my
she
said
he
doesn't
want
to
do
that
because
the
problem
is,
you
want
to
specialize
over
the
tea
right.
So
basically,
when
you
have
like,
let's
say
you
have
100
methods
on
spam
right
spans
of
tea,
the
normally
didn't
think
she
had
span
of
let's
say
bite.
The
jet
has
to
create
bite
versions
of
all
the
methods.
This
is
an
extension
method.
They
can
sell
you
only
ever
called
you
know,
certainly
messes
with
flies
certain
message.
L
L
D
M
D
T
T
E
Api
to
system
memory
that
DLL,
we
can
really
remember
if
I
can
whip
it
out.
Yes,
because
we
cannot
fish
out
well,
we
are
not
sure
whether
we
can
fish
out
everything
from
memory.
Oh,
the
tea
that
we
so
basically,
if
memory
of
tea
is
backed
by
an
array,
we
could
get
it
out
yeah,
but
if
it's
and
by
own
memory
we
can
get
or
so.
E
V
M
D
We
do
if
we
change
it
to
memory,
don't
know
but
like
I
was
trying
to
keep
things
on
rhythm
with
offer
efficient.
So
nothing
out
of
this
are
currently
except
like
to
registering
allocates
as
a,
but
if
we
put
it
into
system
memory
and
we
would
have
access
to
internal
of
my
Marathi,
it
gets
reference
out
of
the
service.
But
you.
M
M
M
W
E
E
D
E
L
D
E
Why
you
are
well
because
I
was
implementing
some
code
and
I
basically
implemented
it?
It's
for,
like
pipelines
and
I,
clearly
knew
that
I
cannot
move
backwards
and
then
I
implemented
it
on
some
other
types
that
can
work
backwards.
I'm,
like
should
the
behavior
of
this
methods,
since
it's
on
an
interface
be
the
same
always
err
but
I
think
it
only
makes.
P
O
E
E
AB
D
AF
E
E
L
Say
that
you
call
the
slicing,
so
you
say
that
you
have
so
say
that
you
have
a
read-only
buffer
that
consists
of
ten
segments
in
there.
I've
ever
was
okay.
Now
the
I
buffer
list
maintains
things
like
virtual
impacts,
correct.
When
you
call
slice,
do
you
have
to
fix
up
all
of
those
virtual
indexes?
No.