►
From YouTube: GitHub Quick Reviews
Description
Powered by Restream https://restream.io/
A
Hello
friends,
good
morning
or
good
evening,
depending
on
your
time
zone
today,
we're
looking
at
three
issues
and
then
the
remaining
backlog.
We
start
with
one
that
was
yesterday
discussed
on
Twitter
I
made
it
I
made
a
bad
joke
in
case
you
didn't
know,
Twitter
was
hacked
yesterday
and
I
made
a
joke
that
we
will
give
out
api's
for
free
and
then
somebody
of
course
mentioned
one
API
that
we
haven't
looked
at
in
a
long
time
and
then
discussion
ended
and
so
I
love
barking.
This
s.
A
Let's
look
at
this
today,
so
it's
a
little
easier
API
already
have
some
of
the
acing
API
as
we
added
to
the
file
class.
Originally,
we
didn't
do
anything
that
you
know
either
by
the
granularity
was
not
big
enough
or
you
know
where
it
didn't
make
much
sense
like
the
I
new
mobile
one,
for
example,
and
so
now
that
we
have
is
an
innumerable
bond
proposal
is
to
actually
add
read
lines
async,
where
you
effectively
stream.
A
A
I'll
guess
you
can't
see
the
screen
right.
Can
you
let
me
share
the
screen.
I
was
also
kind
of
confused
because
my
CPU
time
wasn't
bad
today
that
should
have
given
it
away
that
I'm
not
sharing
my
screen.
People
on
Twitter
can
YouTube
can
see
it,
but
yeah
so
now,
I
have
to
open
up
teams
again.
There.
B
C
A
A
B
D
A
A
D
D
Then
that
that
tells
the
the
compiler,
when
it's
building
the
state
machine
that
it
can,
if
it
knows
that
default
was
passed
in,
it
doesn't
need
to
do
a
cancellation
token
combined
and
if
it
otherwise,
it
need
to
merge
the
call
to
move
next
day.
Syncs
cancellation
token,
with
the
one
that
was
passed
in
here.
Okay.
A
D
A
D
D
D
A
A
D
So
the
guidelines,
just
since
we
haven't
added
many
of
these
just
walking
through
them,
it
has
the
suffix
async.
Add
the
enumerator
cancellation
attribute
to
the
cancellation
token,
don't
return,
I,
a
sync
enumerate
or-
and
this
is
not
it's
a
numerable
and
don't
be
both
an
enumerator
and
numerable
on
a
public
type,
and
this
isn't
adding
a
public
type,
so
I
think
we're
good.
A
A
D
B
A
F
So
the
gist
of
this
is:
is
that
like
what?
What
instigated
it?
Is
that,
like
there's
a
there's,
a
you
know,
working
on
optimizing,
the
painting
and
in
wind
forms-
and
you
know
we
start
in
wind
forms.
You
know
it's
typically
through
a
Windows
message,
and
that
means
we'd
have
an
htc
that
we're
getting
back
from
from
windows,
and
you
know,
there's
a
fair
amount
of
optimization
or
attempt
at
optimization
internally,
where
we
try
to
stick
with
the
HDC.
F
But
you
know
once
a
graphics
has
been
obtained
from
it.
I
mean
kind
of
have
to
use
that,
and
you
know,
there's
as
the
model
for
the
wind
forms
is
built
on
system
drawing
or
GDI
plus
a
great
deal
of
the
infrastructure
and
public
API
I
mean
most
of
the
public
API,
except
for
the
most
recent
stuff
uses.
Graphics
is
its
main
interface.
F
F
This
graphics
itself
implements
iDevice
context
which
actually
gets
you
the
HDC
back
out
of
it
and
all
of
the
painting
args
that
we
have
are
actually
a
one-to-one
thing
with
a
graphics
object,
and
if
the
painting
arts
themselves
drive
from
my
device
context,
that
would
allow
a
couple
of
things
it
would
allow.
As
far
as
wind
forms
itself,
we
can
smuggle
the
the
pain
of
pain
event
args
through
without
having
to
box
them
into
an
iDevice
context
instance,
and
for
users
that
can
pass
them
back
into
our
into
our
iDevice
context.
F
Api's
that
we
have
there
a
little
bit
more
recent
and
you
know
when
we
get
them
back
in
and
the
other
side
we'd
be
able
to
tell
whether
or
not
we
can
apply
the
speed
optimizations
to
it.
I
like
not
not
create
the
graphics
object
we
don't
have
to
and
we're
also
tracking
now
whether
the
graphics
object
has
ever
been
obtained
through
the
event
args
through
the
public
interface.
D
F
Because
the
idea
here
is
that
we
don't
it's,
it's
distracting
that
they're
there
and
just
don't
want
hanging
off
publicly.
You
know
if
you
really
want
to
go
and
get
it
that
way
it
doesn't
buy
you
anything
it's,
but
you
know
I,
you
know
the.
When
you
get
an
HTC
off
of
a
graphics
object
itself
or
or
through
this,
you
know
it
locks
the
graphics
object,
and
you
know,
as
such,
you
know
just
don't
want
it
hanging
out
in
front
of
things.
A
F
F
F
A
D
I
mean
I'm
just
scrolling
through
the
stuff.
We
have
for
guidance
on
explicit
implementations
or,
if
is
there
an
expectation
of
needing
to
call
these
members
from
a
derived
type,
I
assume
they're
unsealed,
just
because
the
guidelines
say
be
unsealed
and
that
there's
no
real
expectation
of
inheritance
on
these
types.
F
D
D
D
D
A
F
D
D
F
A
All
right,
so
that
means
copy
paste
pasta,
but
I
can
get
my
machine
to
operating
in.
A
Alright,
so
when
a
specific
API,
so
you've
reviewed
this
last
time,
there
were
a
lot
of
changes
afterwards
and
also
feedback
on
particular,
so
I
want
to
just
quickly
go
over
the
changes
at
the
high
level
thing
and
then
I
would
hope.
We
can
just
mark
this
as
improved.
So
the
two
things
we
talked
about
high
level
lives
was
when
I
made
that
list
I
assumed
that
all
this
API
is
ship
in
box.
A
There's
some
assemblies
that
we
have
shipped
as
part
of
the
windows,
compact
pack,
which
means
they're
effectively
auto
event,
you'll
get
packages
available
on
that
Center
to
oh
and
we
concluded
that
we
should
also
mark
them
and
the
way
we
would
do
this
is
we
just
have
an
internal
attribute
definition
that
ships
inside
of
these
assemblies,
because
the
analyzer
doesn't
care.
It
just
cares
about
the
name,
and
it
cares
about.
It
doesn't
care
whether
it's
public.
It
just
cares
about
the
name
that
is
supplied,
and
so
it
will
just
work
without
polluting
the
namespace.
A
The
other
thing
we
talked
about
was
partially
supported,
API,
so
some
of
the
API,
as
we
had
in
this
list,
work
generally
speaking,
but
it
depends
on
the
attribute
on
the
actual
combination
of
parameters.
So,
for
example,
named
pipes,
don't
actually
work
when
you
specify
a
name
for
the
pipe,
and
so
they
were
cross-platform
so
long.
He
said
name
to
know,
and
so
we
said
well.
A
The
other
thing
we
talked
about
was
we
don't
have
a
way
to
support
annotations
along
the
lines
of
this
API
doesn't
work
in
a
particular
platform.
The
whole
design
is
predicated
on
we
mark
where
things
work,
and
so
basically
as
soon
as
we
do
that,
then
everything
we
haven't
marked
is
assumed
to
not
be
supported
and
so
like.
We
need
to
change
the
analyzer
or
change
the
design
to
allow
for
this
attribute,
but
that's
outside
the
scope
of
the
spec,
because
this
is
only
really
for
Windows
specific
API.
A
So
the
only
thing
we
have
to
say
is
this
works
only
on
Windows.
This
doesn't
handle
the
cases
like
open
SSL,
where
it's
like.
Oh
this
doesn't
work
on
Windows,
but
it's
a
separate
feature,
and
that
was
pretty
much
most
of
it.
So
the
only
open
issue
that
I
have
is
sweating
overlapped
for
the
assemblies
themselves.
A
A
Then
specific
API
I
mean
this
I.
Think
most
of
the
thing
was
just
individual
feedback
for
area
owners.
So
here's
an
example
where
we
basically
went
with.
We
didn't
mark
the
API
Martyna
members
that
have
passed
through
the
API,
so
that
addresses
most
of
those
concerns,
and
then
there
was
some
crypto
feedback
and
then
some
additional
stuff
that
was
I
think
Adam
looked
over
that
and
found
some
additional
cases.
A
The
only
thing
pending
really
is
WCF,
so
I
ping,
the
WCF
folks,
take
a
look
at
this,
so
we
probably
add
a
few
more
api's
for
that,
but
my
goal
isn't
necessarily
to
bring
every
single
API
to
this
review
board
because
you
know
it's
probably
not
super
useful
I
just
want
to
establish
kind
of
the
case
law
that
we
have
and
I
think
we
have
done
that
at
this
point.
Is
there
any
more
feedback
or
concerns
with
this
approach
or
questions
for
that
matter?
I.
D
A
A
A
When
you
say
net
5
windows,
7.0
I
mean
most
of
the
time
we
will
never
say
a
version
number
with
Windows
when
you
specified
in
the
TFM,
but
we
have
rules
on
what
that
means,
and
so,
when
an
assembly
is
being
generated,
it
will
put
in
the
version
number
that
whatever
the
SDK
is
version
number
of
that
build
of
that
version
of
the
TMM
is
right.
So
in
our
case
for
dotnet
5
net
5
windows
really
means
net
5
windows,
7.0.
A
D
A
Something
like
that,
whatever
their
thing
is
all
right,
and
given
that
it's
a
string,
it's
not
even
constrained
to
be
the.
What
is
it
I
think
in
16,
I
guess,
but
we'll
probably
not
see
this,
because
usually
if
these
version
numbers
end
up
in
something
like
a
system,
dot
version
where
the
constraint
exists.
A
G
G
By
the
way
regarding
the
wind
versus
windows
moniker
from
earlier,
does
it
make
sense
to
have
an
analyzer
or
I
mean
this?
Is
this?
Is
an
analyzer
that's
looking
at
all
in
this,
but
does
it
make
sense
for
the
analyzer
to
give
a
warning
saying
like
I,
really
don't
understand
what
you're
passing
in
here
like
this
is
a
moniker
that
is
unknown
to
me.
G
A
Some
one
thing
that
we
talked
about
as
you
move,
validate
that
the
syntax
is
correct,
all
right
so
that
you
don't
say
Windows
seven,
oh,
but
you
say
Windows,
seven
Oh
and
that
you
have
a
dot
in
there
right.
So
you
can
say
Windows,
seven
zero.
You
have
to
say
Windows
period
zero,
but
like
the
the
one
thing
we
haven't
talked
about
was
constraining
the
actual
OS
names
to
announce
said.
We
have
talked
about
this
in
the
context
of
the
TF
MS,
where
we
said
we
should
enforce
this
during
the
build
that
you
know.
A
That
is
certainly
something
we
could
consider
because
you're
right,
we
would
expect
people
to
put
them
as
literals
in
source
right
they'll
be
most
likely
not
using
the
tool
in
the
attribute
application.
They
will
probably
define
a
literal
somewhere
and
their
assembly
and
then
refer
to
that
constant,
but
it
would
still
be
nice
if
you
could
validate
that
the
string
makes
sense.
Yeah.
D
A
G
G
A
A
C
C
We
should
just
expose
these
these
new
types
as
part
of
system
runtime
and
drop
services
for
people
to
use.
Additionally,
one
of
the
other
issues
that
comes
up,
and
one
of
the
reasons
why
it
needs
to
be
in
core
lib
in
particular,
is
that
a
simple
wrapper,
struct
and
a
primitive
type
are
not
treated
the
same
for
all
calling
conventions
or
ABI
scenarios.
C
For
example,
with
instance
members
on
Windows
struct
returns.
Our
paths
are
returned
by
pointer
in
a
return
buffer
rather
than
passed
in
register,
and
so
the
runtime
would
be
able
to
especially
handle
these
trucks
to
ensure
they
get
passed
correctly,
as
if
they
were
a
primitive
type
rather
than
a
struct
wrapper.
D
G
C
The
these
types
aren't
meant
to
be
more
generally
usable,
so
you
won't
get
operators
or
things
like
that.
They're
meant
to
basically
be
the
bare
minimum
wrapper
type
to
ensure
marshaling
happens
correctly
and
to
avoid
scenarios
where,
for
example,
you
have
a
struct
that
contains
an
array
of
structs
that
contain
these
fields,
and
so
you
have
to
marshal
each
individual
struct
to
get
things
to
work
correctly.
C
G
A
One
thing
that
I
believe
we
talked
about
in
the
past,
but
I'm
not
sure
why
we
rejected
this
is
like
at
some
point,
I
think
somebody
said
why
do
we
need
type
to
this
at
all?
Wouldn't
this
be
just
attributes
you
put
on
the
field
and
says
marshal,
as
you
know,
whatever
it
is,
he'll
only
see
you
long,
but
you
would
still
define
them
as
effectively
the
larger
type.
C
You
could
do
that.
There
was
a
fairly
lengthy
discussion
on
this
and
a
related
issue.
Eons
also
the
only
call
so
maybe
he
can
come
in
a
bit
more
but
the
general.
The
general
thing
is.
We
don't
want
to
continue
adding
specialized
attributes
in
the
in
the
runtime
because
they
can
be
very
error-prone.
And
another
scenario
is,
it
does
add,
marshalling
overhead,
which
can
be
quite
expensive
in
some
cases,
because
you
actually
have
to
allocate
a
separate
buffer
convert.
Everything
in
size
perform
actual
marshaling,
rather
than
just
letting
it
bleed
across
the
across
the
boundary.
C
A
A
D
Mean
for
something
like
C
long,
we
could
only
implicit
in
int.
We
can't
implicit
in
long,
because
that
would
be
an
overflow
on
windows
right,
and
so
it
just
feels
like.
Maybe
it's
not
worth
it
as
long
as
int
implicitly
goes
to
in,
and
then
you
don't
have
to
double
cast
in
the
or
you
don't
have
to
explicitly
write
a
double
convert
in
the
constructor
yeah.
C
A
Safe
I
guess
my
question
is
like:
how
do
you
see
a
public
API
around
those?
Do
you
think
people
would
basically
just
use
int
because
they
have
to
assume
that
they
run
in
on
internal
tube
based
platforms,
or
is
the
expectation
that
they
literally
exploit
the
fact
that
there
could
be
32-bit
or
64-bit
and
then
effectively
used
in
PTR?
And
then
just
some
windows
say
sorry.
C
My
expect
so
my
general
expectation
is
that
people
don't
use
these
in
public
API.
They
use
these
behind
the
scenes
for
interrupt
scenarios
and
then
for
for
C
long.
They
would
likely
expose
it
as
in
int
publicly,
and
if
they
had
a
setter,
they
would
do
the
validation
internally
or
they
just
decide.
I
only
accept
int
and
they
would
also
truncate
on
UNIX.
Yes,.
A
I
mean
I
understand
that
you
don't
use
these
types
of
public
API.
That's
why
I'm
asking
like
I
guess:
maybe
business
depends
on
the
feature
right.
In
many
cases
you
don't
have
a
correspond,
int
value
in
your
public
API,
because
you
know
it's
only
part
of
the
plumbing.
You
have
to
do
to
call
the
underlying
API
right,
but
I
I
would
assume
that
you
know
there
will
be
cases
where
you
would
do
that
and
then
I
guess.
My
question
is:
what
tie
do
we
expect
them
to
use
in
that
space
and
I?
D
D
C
I
C
D
D
C
B
C
A
C
A
I
D
D
D
C
C
D
A
C
Think
the
only
other
note
is
xamarin
called
out
that
they
wouldn't
be
able
to
use
these
types
because
one
they
defined
their
own
types
that
are
in
the
system,
namespace
that
are
all
lowercase
named
and
we
wouldn't
be
exposing
those
there
and
also
it
would
third
likely
be
some
minor
incompatibilities
because
they
expose,
for
example,
full
operator
support
on
their
types
etc.
But
you
would
be
able
to
unsafe,
as
between
these
types,
for
in
drop
scenarios.
I.
C
Know
that
that
also
applies
to
in
int,
for
example,
and
I'm,
not
sure
what
the
story
is
there.
They
defined
system
in
int
which
conflicts
with
the
inin
t
word,
and
they
do
behave
differently
and
they
are
different
types
in
the
type
system.
So
that's
probably
a
longer
discussion
to
have
with
them.
American,
marcus
and
others.
D
D
A
Yeah
my
only
concern
with
that
is,
like
you
know.
Let's
say
this:
is
you
know
just
like
six
more
types
like
that
and
we
we
started
when
we
only
had
one
type
of
Pi
art
and
now
everybody
copies
the
bed
priority
but
like
it
seems.
If
we
only
have
one
type,
then
that's
fine,
probably
but
I.
Maybe
it's
worthwhile.
Breaking
with
that
and
just
says.
Could
we
actually
put
them,
as
instance,
methods
to
make
our
lives
easier?
A
D
I
mean
we
can
certainly
make
these
be
proper
instance
methods.
The
question
is:
would
we
then
also
take
the
existing
extension
methods,
copy
them,
as
instance,
methods
and
then
effectively
be
deprecating
the
extensions
or
leave
the
three
types
that
are
already
there?
The
way
they
are
and
only
new
things
going
forward
when
we
get
around
to
supporting
pqc
algorithms
I.
D
I,
would
it's
really
yeah,
so
the
the
instance
versus
extension
is
just
about
the
the
three
that
we
have
right
now
we're
all
extension
because
of
dotnet
framework
limitations.
This
one
would
be.
Do
we
start
a
new
pattern?
Do
we
start
a
new
pattern
that
we
want
to
unify,
or
do
we
just
maintain
the
existing
pattern?
I.
A
Mean
in
general,
like
I,
like
the
guideline
to
say,
make
things
extension
methods
only
when
you
have
to
don't
make
them
just
because
right
and
these
ones
don't
strike
me
as
they
make
sense
of
extension
methods.
I
mean
just
because
we
did
this
in
full
framework,
as
you
said,
for
that
was
for
layering
reasons
or
because
you
wanted
to
OOP
them
or
some
other
constraints
right.
That
may
not
apply
yeah.
D
D
A
I
A
D
And
then
yeah
so
do
we?
Do
we
want
to
at
the
same
time
that
we're
adding
these,
as
instance,
members
back
form
and
add
instance,
members
for
the
existing
algorithms?
So
there's
technically
a
duplicate,
but
the
instance
will
beat
the
extension,
the
extension
types
we
can't
remove
because
they're
required
by
that
standards,
yeah.
A
I
mean
we
have
not
done
this
either
I
think
for
the
networking
stack
whatever
added
the
the
async
wants.
These
extensions
I
mean
I.
Guess
you
I,
don't
know
whether
the
status
I
guess
the
other
ones.
They
actually
are
extension
methods
right
for
real
they're,
not
actually
instance,
members
but
like
in
the
WebSocket
Kate,
was
at
WebSocket
or
socket
or
I
forgot,
which
API?
A
That
is
where
we
added
the
async
methods
as
extensions
they
always
shipped
with
actually
being
instance,
members
and
the
extension
was
just
forwarded
to
them
and,
like
that
point
of
what,
if
we
could
have
just
made
them
public
but
I,
think
we
didn't
end
up
doing
it,
because
it
would
have
been
weird
to
just
have
two
api's
in
two
places
now
I
mean
unless
there
is
a
reason,
I
would
probably
not
change
the
existing
ones.
I
would
just
leave
them,
as
is
okay,.
D
And
then
the
other
thing
buried
in
it
that
I
forgot
was
attached
to
this
one,
but
hey
it's
good.
It
means
I,
don't
have
to
bring
it
up.
When
we
talk
about
the
possibly
the
next
issue,
is
we
have
this
class
called
public
key
so
from
a
certificate?
You
can
get
a
thing
talking
about
its
public
key.
It
doesn't
actually
the
public
key,
it's
just
information
about
it
and
in
a
previous
version,
of.net
core.
D
We
started
adding
these
import
and
export
methods
for
the
the
file
formats
that
are
common
to
those
types
and
a
public
key.
Its
export
type
is
called
subject
public
key
info,
and
so
this
is
adding
the
ability
to
create
it
from
or
the
ability
to
just
export
that
that
same
pattern
that
we
have
on
like
RSA
and
DSA
and
such.
A
B
D
Yeah
so
right
now
you
can
only
create
it
from
pieces
and
yeah,
so
the
passing
it
the
constructor
that
takes
a
symmetric,
algorithm
and
the
import
subject.
Public
key
info
static
because
this
is
a
read-only
type.
It
has
no
mutable
numbers,
the
those
are
created
from
the
data
or
take
the
asymmetric
algorithm,
which
already
defines
export,
subject
public
key
info,
and
then
it
would
take
the
thing,
export
it
and
then
call
the
import
logically.
A
D
A
D
D
E
B
A
A
C
D
D
D
Don't
expect
it
to
be
very
common,
no,
the
the
public
key
class
isn't
used
as
an
exchange
type
for
very
many
things.
It's
it's
a
very
limited
thing,
but
places
like
our
certificate
creation.
Api
will
accept
one,
and
so
it
does
have
utility
to
make
it
a
little
easier
to
build,
but
yeah
the
people
who
would
who
would
use
these
methods
are
I'm
not
looking
at
YouTube
but
I'm.
Sure
Kevin's
on
the
call
and
levi's
here
and
I'm
here
and
I.
Think
Barry's
off
today
and
that's
pretty
much.
A
F
A
D
Right
so
on
the
subject
of
subject:
public
key
info
for
EC
diffie-hellman
for
reasons
that
I
don't
understand
that
I
didn't
build
it
I
just
inherited
it.
We
have
a
separate
type
called
EC
diffie-hellman
public
key.
You
can't
build
them.
You
can
only
get
them
built
by
an
EC
diffie-hellman,
but
the
public
key
class
here
can't
export
itself
as
a
subject
public
key
info,
you
have
to
have
kept
around
its
parent,
which
it
won't
give
you
for
layering
and
encapsulation
reasons.
A
E
A
D
So
the
only
way
you
can
ever
get
one
of
these
is:
you
have
an
instance
of
EC
diffie-hellman
and
you
access
its
public
key
property,
which
shouldn't
have
been
a
property
because
it's
a
factory
instead
of
a
give
you
a
shared
reference,
but
still
so
you
call
that
property
and
it
gives
you
the
appropriately
derived
type
for
the
native
layer
that
you're
working
with
at
the
time,
and
then
those
will
just
all
implement
these.
So.
E
D
G
A
G
A
I
mean
generally
find
of
like
cases
where
99%
of
implementations
are
provided
by
the
platform,
because
then
we
can
do
it
at
the
same
time,
it's
a
bit
more
shitty
when
you
have
an
open-ended
ecosystem,
because
then
you
have
this
Lent
my
problem
right
when
people
you
know
they
don't
want
to
call
the
new
API
because
well
it
always
blows
up.
Yeah.
D
A
One
yeah,
so
let
me
try
to
pitch
context
back
in
here.
Oh
yeah
I.
Remember
like
yeah
I
added
a
bunch
of
questions
because
I
didn't
quite
know
what
it
was
so
bottom
line.
Is
it's
some
esoteric
C++
thing
that
does
nothing
to
do
with
donate,
because
the
way
stuff
works
in
our
world
is
very
different
from
the
way
it
works
in
C++
land,
so
they
actually
ship
things
that
are
namespaces.
We
don't
try
to
know
about.
D
I
They
want
to
be
using
the
news
c
bus
pass
features
in
that
share
piece
too,
and
you
know
if
this
apostrophe
or
doesn't
support
them,
they
may
have,
cannot
use
them,
and
you
know
to
code,
doesn't
look
as
pretty,
and
so
like
one
question,
I
would
ask
for
this.
One
is,
but
they
still
need
it,
because
this
was
one
of
the
options
they.
I
To
make
this
make
this
happen,
I
think
they
were
also
looking
at
other
options.
You
know
just
emit
at
the
local
copy
or
distribute
and
don't
without
rec
or
engage
in
a
public
service.
So
I
think
that's
something
to
double
check,
whether
it's
the
required
belief
is
still
required.
I
think
it's
kind
of
nobody
not
to
to
take.
You
know
just
yeah
support
so.
I
A
D
Yeah
I
mean,
unless
they
were
planning
on
making
whatever
feature
set,
needs
to
interact
with
this
be
net
5
only
they
would
either
need
this
to
be
somewhere
published
in
a
net
standard
ref,
or
they
would
need
to
do
the
they'll
embed
the
attribute
when
they
need
it,
at
which
point.
Maybe
we
don't
need
the
public
one
right.
A
A
A
G
Mean
on
its
face,
the
scenario
sounds
reasonable.
Like
I
I,
don't
know
what
settings
are
available
in
Z,
Lib,
compressed
stream,
so
I
don't
know
if
the
like
compression
level
abstraction
makes
sense
for
us
like
do
we
need
to
add
another
Raziel
of
a
specific
parameter
here.
Just
someone
needs
to
researcher
I
mean.
A
A
G
D
Magic
header
right
so
is
this
a
problem.
The
HTTP
client
assumes
that
deflate
and
and
Z
Lib
and
a
header
are
compatible
or
is
this
cos
says
here,
content
encoding
deflate.
So
if
this
is
deflate
and
it's
legal
is
deflate,
then
then
it
seems
like
we
would
just
have
a
bug
and
deflate
stream,
but
it
it
did
say
that
on
the
acceptable
encodings
that
Z
Lib
was
one
of
them
yeah.
The
only
other
question
I
would
really
have
is,
which
I
think
is
covered
by
that
example.
A
I
mean
I
mean
Steven
the
thread,
that's
the
right
behavior
for
that's
the
right
way
to
fix
it.
I
am
maybe
not
maybe
it's
just
me,
but
I
feel
more
like
what
was
said
earlier.
It's
like.
Why
can't
we
do
this
transparently
in
the
flight
stream
directly
I
guess
reading
should
be
transparent,
right.
Writing
will
Poli
require
top
down.
D
A
Which
but
that
one
you
could
handle
by
just
saying?
Well,
if
it's
the
magic
header,
then
I'll
just
ignore
it,
but
that
wouldn't
work
for
right,
because
you
would
have
to
know
whether
you're
supposed
to
write
it
or
not,
but
I
guess
right,
yeah,
I
guess:
maybe
it's
actually
more
work
to
make
the
Constructors
do
the
right
things,
because
then
you
have
a
fairly
non-trivial
constructor
configuration,
maybe
using
a
different
type,
actually
is
easier
than
that.
A
G
D
D
A
D
Yeah,
so
I
have
no
idea
what
the
implementation
will
look
like
on
this,
but
the
public
surface
area
of
effectively
adding
the
four
or
two
constructors
and
then
overrides
as
necessary,
seem
I
guess.
Base
stream
is
the
only
potential
difference
and
that
was
done
on
again.
It's
weird
deflate
stream
exposes
bass
dream,
so
gzipstream
exposes
base
stream,
and
now
this
exposes
base
stream,
and
it
makes
me
wonder
why
we
don't
have
a
inheritance
hierarchy
here,
but
we're
matching
the
pattern
and
Steve's
not
here
to
explain.
D
E
D
E
D
D
G
G
G
I,
don't
quite
understand,
but
if
you,
if
you
read
the
thread,
there
was
a
demonstration
of
the
kinds
of
problems
that
caused,
but
regardless
like
it,
it
really
should
be
best
practice
for
us
anyway.
If
we
implement
ie
in
your
mobility
or
I
call
people
on
T,
we
also
should
implement
the
non
generic
one
as
well.
Oh.
A
G
B
D
A
D
D
I
D
G
Is
that
throw
we
can
look
at
what
int
and
long
and
other
types
too
and
just
follow
the
established
pattern
there,
but
yeah
I,
wouldn't
I,
wouldn't
want
to
force
arbitrary
third
party
code
to
implement
I
caught
to
implement
regular
compared
to
if
they're,
implementing
the
I
comparable
of
T
interface,
but
because
this
is
an
exchange
type.
We
should
do
those
just
to
make
the
ecosystem
happier.
G
A
A
D
I
A
I
A
I
A
string
builder
right,
it's
it's
specific
to
strange,
like
the
divider
he
invoke
marshalling.
Does
it
just
like
that?
A
black
box
that
you
know
takes
a
type-
and
you
know
all
the
annotations
on
it
and
it
will
tell
you
this
is
how
it
will
be
marshaled,
and
you
know
to
answer
that
the
black
box
is
giving
for
this
next
ring
out,
isn't
kind
of
but
isn't
intuitive.
You
know,
yeah.
D
D
I
G
D
D
A
A
Mean
I,
to
be
honest,
I
am
Not
sure
I
buy
the
off
by
default
situation.
A
lot
but
like
it
seems
to
me
if
you
think
something
is
super,
noisy
that
it's
off
by
default
and
very
friendly
in
nature,
I'm,
not
sure
it's
worthwhile
building
in
the
first
place.
But
if
the
team
feels
super
strong
that
we
should
ship
this
I'm
wrong,
you
know
throwing
a
fit,
but
it
seems
to
me,
like
I've,
been
pretty
fully
invest
resources
elsewhere.
If
we
feel
that
strongly
about
it's
not
being
on
by
default,
maybe.
D
G
D
A
Yeah
I
mean
I
think
off
by
default,
and
then
you
turn
off
becoming
a
warning.
I
guess
makes
more
sense,
naughty
suggestion,
because
a
tease
suggestion
is
just
you
know
where
issues
go
to
die
because
there's
this
very
long
list
of
things
so
you're
not
very
likely
to
see
this
right.
If
you
write
a
Viper's.
D
D
Like
this
would
be,
if
you
you
know,
we're
doing
something,
and-
and
you
had
you
were
either
working
on
your
performance
or
hyper
performance
was
a
goal
right.
You
would
go
to
the
analyzer
settings,
you
would
enable
the
entire
performance
category
and
then
you
would
fix
everything
it
suggested
at
you
right.
E
G
I
The
marshal
basically
does
that
already
you
know,
maybe
it's
not
as
efficient
as
it
can
be,
but
the
problem
is
they
get
the
extract
of
a
D,
the
extra
the
it's
still
like
I,
think
idea,
but
this
analyser
is
really
telling
q
is
don't
use
string
builder
at
all
right.
It's
the
using
the
single,
the
in
cycling,
lock.
Signature
is
just
tip
of
the
iceberg.
Right.
G
Yeah
so
I
think
I
think
you
was
right.
I
think
the
Marshall
were
uses
its
own
native
memory
functions,
but
that
does
raise
an
interesting
question
where,
if,
if
the
analyzer
is
telling
you
don't
pass
him
string
builder,
like
turn
the
string
to
hold
her
into
a
rented
char
array
and
then
pass
down
the
rented
char
array
like
again,
that's
something
the
marshal
or
could
do
on
your
behalf.
Moving.
I
D
I
And
that
kind
of
restructuring
we
have
done
to
fix
these
warnings.
In
our
you
know,
in
the
libraries
we
like,
we
are
fixing
the
stringbuilder
marshalling.
You
know
performance
issues,
it
wasn't
just
like
local
change.
Oh
you
know
like
really
sting,
though
everywhere
and
do
like
local
tweak.
It
was
always
like
you've
not
really
factoring
of
the
code.
I
D
Because
I
looked
at
it
as
I
thought,
it
was
saying
effectively
the
Marshall
or
is
you
know,
roughly
speaking,
just
calling
stringbuilder
dot
to
string
and
passing
that,
so
it
makes
a
copy,
it
throws
it
away.
You
pass
the
same
one
to
another
P
invoke,
it
makes
another
copy,
throws
it
away
and
that
it
has
GC
concerns.
If
this
is
telling
you
hey,
instead,
you
want
to
rent
or
use
a
a
rented
managed
buffer,
instead
of
letting
us
do
malloc
and
free
in
in
the
runtime
that
doesn't
feel
like
it's
actually
buying
anything.
D
C
Not
only
doesn't
Marshall
it,
it
also
marshals
back
it,
so
it
creates
a
it,
creates
a
character
array.
It
copies
the
contents
of
the
stringbuilder
into
that
array.
It
passes
that
new
array
into
native
land
native
land
does
everything
and
then,
depending
on
the
in
out
attributes,
you
have
I,
don't
remember
what
the
default
is.
It
may
take
that
array
and
copy
its
contents
back
into
the
stringbuilder
you
originally
passed
in,
so
that
any
mutations
are
preserved.
D
A
D
D
G
A
C
So
today,
the
most
of
the
win32
api
is
have
a
Doc's
page,
and
on
that
page
it
explicitly
lists
whether
you
need
get
last
error
need
to
call
get
last
error
and
also
the
library
it's
exported
from
and
alternative
names
it
might
be
available
under
and
I
actually
have
a
tool
that
I
use
for
my
own
Windows
and
drop
bindings.
That
queries
against
a
local
copy
of
that
Docs
repo
to
validate
that
my
own
bindings
are
correct.
D
I
A
You
guess
also
depends
on
how
they
want
to
structure
the
analyzer
right.
I
mean
like
this
like
to
concerned.
One
of
them
is
just
be
way
it's
time,
because
we
don't
have
the
spelling
exactly
the
one
is
well.
The
thing
you
have
to
find
doesn't
actually
exist
as
far
as
we
know,
so
you
have
a
type
of
somewhere,
I,
know
and
they're
kind
of
complementary.
I
D
D
All
right
so,
when
we
added
I,
think
disposed,
crypto
stream
gain
to
dispose
async
and
as
part
of
implementing
that
Steve
actually
implemented
a
method
called
flush.
Final
block
async,
which
was
the
async
version
of
flush
final
block,
but
it
isn't
public
and
the
synchronous
version
is
public.
So
this
is
hey.
Can
you
make
the
asynchronous
version
public
instead
of
just
requiring
or
instead
of
the
only
way
of
doing
it
is
to
call
dispose?
Async
suppose
I
think
does
more
work
than
just
this
right.
D
A
G
A
A
D
I
D
A
A
Don't
think
that's
what
this
thing
is
for:
it's
not
about
it
enforcing
it's
just
saying
if
you
have
a
language
that
honors
this
property,
that
by
a
third-party
analyzer
framework
or
because
the
compiler
natively
understands
the
attribute,
you
get
effectively
an
information
that
you
otherwise
wouldn't
have
gotten
right,
so
that
basically
we
will
still
keep
designing
our
bcl,
assuming
that
people
will
not
have
overridden
those
methods
right,
because
it's
just
a
suggestion.
People
should
be
overriding
those.
A
So
that
means
you
still
have
to
ship
an
actual
physical
implementation.
That
does
something
sensible
and
sensible,
sometimes
means
throwing,
because
there
is
no
actual
implementation
you
could
provide,
but
if
people
actually
derive
from
the
time
you
want
them
very
strongly
to
override
these
methods,
and
so
all
we
would
do
is
you
would
just
change
the
IDE
to
just
generate
that
code?
A
Right
and
I
would
argue
that
doesn't
even
require
compiler
work,
because
you
know
you
could
imagine
in
a
world
where,
if
you
do
control
dot
on
you
know
a
typing
you
derive
from
it
in
in
VB.
You
know
whatever
code
spits,
the
IDE
does
for
that,
can
totally
honor
that
property
right
and
just
basically
omit
the
overrides
for
these
methods,
but
it
doesn't
require
a
compiler
Americans,
just
IDE
work,
and
so
could
F
sharp
right,
I
mean
I'm,
not
sure.
A
F
sharp
has
a
control,
dot
implement
kind
of
thing,
but
if
they
did,
they
could
do
the
same
thing
right
so
like
this
is
more
of
a
you
know,
framework
author
kind
of
like
power
tweak,
so
that
when
people
override
these
things,
they
get
better
behavior
out
of
the
box.
But
it's
not
meant
to
be.
Oh,
my
god.
We
have
an
actual
way
to
tell
people
like
you
need
to
override
this
method
and
then
enforce
it
or
something
like
yeah.
I
A
And
so
that's
why
I
think
I'm
totally
fine
with
these
soft
things
being
you
know,
custom
attributes,
and
then
the
idea
is
just
a
little
bit
smarter
about
them.
That
that
to
me
seems
like
the
best
compromise
that
I
can't
see
us
doing
anything
in
the
run
time,
I
can't
see
us
doing
anything
in
the
compiler
layer.
For
these
things,
it's
just
you
know
it's
a
constraint.
D
D
But
now
those
all
seem
like
reasonable
arguments
to
me
and
I
think
I
looked
at
the
attribute
targets
and
those
are
the
only
things
that
can
be
virtual.
So
that
looks
like
the
right
attribute
usage
to
me
and
then
the
analyzer
would
be
if
the
most
derived
virtual
for
a
particular
virtual
slot
has
this
attribute.
Then
it
warns
that
you
should
be
overriding
it
right.
D
A
D
D
D
A
D
D
A
G
A
D
A
Mean
there
will
be
something
we
could
probably
easily
track,
what
I
wouldn't
even
see,
look
at
things
you're
introduced
in
this
release.
I
would
probably
just
do
a
blind
scan
for
virtual
methods
and
abstract
types
whose
body
doubles
plugged
in
and
not
supported
and
they're
just
review
those
because
I'm
pretty
sure
we
have
a
lot
of
them.
A
G
Because
we
generally-
and
this
was
mentioned
earlier
like
but
generally
we
fall
into
one
of
two
buckets
right-
you
you
have
to
implement
this
in
order
for
the
functionality
to
even
work
or
something
like
stream,
where
you
should
implement
this,
or
else
your
consumers
are
gonna,
be
in
for
a
bad
time.
Yeah.
I
G
A
Mean
I
guess
that's
kind
of
the
thing
we
have
to
like
when
we
actually
walk
the
list.
We
probably
find
some
categories
where
it
makes
sense
and
where
it
doesn't
make
sense,
but
I
I,
don't
know
things
that
generally
work,
I,
probably
wouldn't
necessarily
flag
them,
because
then
you
drown
the
the
people.
A
On
the
other
hand,
the
only
person
that
you're
flagging
are
people
that
derive
from
these
types,
which
is
probably
as
much
much
smaller
set
to
begin
with,
but
I
will
also
say
that,
depending
on
what
type
you
are
looking
at,
if
I
derive
from
stream
chances
are
I,
probably
do
it
in
a
unit
test
or
some
other
thing
on
the
side,
where
I
don't
care
about
curve.
I
just
want
to
intercept
some
data.
D
If
you
hit
this
base
virtual,
because
we
have
to
take
the
span
which
may
have
been
from
an
array
copy
it
to
an
array
or
a
new
array
and
then
call
the
other
thing
and
because
of
which
one
was
defined
first,
so
it's
we
can
do
one
attribute
for
the
both
or
defined
two
really.
This
is
sort
of
you
as
the
user
experience
for
the
team,
yeah.
A
A
We
should
either
be
wrong.
Maybe
we
should
just
instead
of
saying
should
be
overrated.
We
should
describe
what
it
does
like
bass
is
saying,
you
know,
less
optimal
based
implementation
throws
equals
true
versus
throws
equals
false,
and
then
the
analyzer
can
handle
that
and
say
you
should
override
this
guy.
D
A
This
one
is
an
interesting
candidate
right
because
it's
I
mean
it
doesn't
throw,
but
it
basically
never
works
right.
So
you
basically
have
a
non-functional
behavior.
In
this
case
your
basic
missing
feature
versus
the
async
one.
It
works
is
just
slow
or
maybe
it
slows
the
wrong
word,
but
maybe
doesn't
actually
do
it
synchronously
or
might
cause
a
deadlock
or
something
like
that
right.
That's
yeah,
I,
guess
yeah.
Let
me
give
me
two
me
think
about
this.
G
G
D
D
Mean
the
analyzer
would
maybe
just
be
an
independent
vector
of
the
same
semantics
but
sure
the
yeah,
so
the
question
is
really
what
level
of
granularity
and
categorization
do
we
want
on
these
things
of
this
is
this
is
going
to
throw?
This
is
a
optional
feature
that
is
disabled.
This
is
a
very
bad
implementation.
Please
give
me
a
better
one,
but
it
works.
H
G
Yeah,
the
you,
you
could
imagine
that
if,
if
the
analyzer
does
influence,
what
right
click
implement,
abstract
class
does,
and
you
could
imagine
that
some
of
the
methods
have
a
default
body
of
thrown
it
on
and
throw
new,
not
implement
exception,
and
some
methods
have
a
default
body
of
return
based
on
whatever
based
on
you
know,
this
attributes
flags
some.
How.
G
D
D
A
Yeah
I
mean
that
will
be
the
IDE
team
right,
which
is
kind
of
like
Cyrus
and
Friends
I
mean
like
the
yeah
I
mean
yeah
I'm
kind
of
concerned
about,
like
us,
not
being
able
to
declaratively
indicate
these
different
cases
because
there's
my
leaders
down
to
maybe
we
don't
have
an
attribute.
Maybe
we
literally
just
have
a
bass
analyzer
that
we
can
derive
from
the
SDK.
That
does
the
work
and
then
we
can
differentiate
there,
but
just
generating
different
diagnostic
IDs.
D
A
D
A
D
It
defaults
or
win
or
whatever
right
so
then
it
would
be
like
win
performance,
win,
optional
feature
win,
always
so
the
throw
a
once
would
be
always
override
this,
and
that
enum
describes
the
few
simple
relationships
we
have
and
the
default
would
be
always
so
you
could
just
say
should
override
and
it's
just
like
yep.
This
should
be
overridden
and
you're
like
oh,
should
override
performance
of
like.
Oh.
D
A
A
D
And
then
the
code
generator
could
look
at
the
kind.
The
analyzer
could
look
at
the
kind
for
changing
the
diagnostic
ID,
and
you
know
whether
it's
on
by
default
or
not,
because
I
assume
that
we
would
take
the
ones
of
hey
this
member
always
throws
you
really
really
really
want
to
override
it,
and
that
that
one
would
be
a
on
by
default.
With
the
the
TFM
right
like
we,
that
it
would
start
being
a
new
I
guess
really
we
don't
even
need
to
TFM
walk
it.
A
A
D
A
A
D
G
A
A
A
We
are
down
to
29
and
you're
the
only
two
things
that
I
think
are
in
the
five
whole
months.
No,
no,
let
me
double
check,
but
these
are
the
connection
abstractions
and
then
the
exposed
transactions.
Eight
points
in
AD
ordinate,
this
1-year
mobile
ping,
the
old
friends
and
data,
whether
that's
important
to
them.