►
From YouTube: GitHub Quick Reviews
Description
Powered by Restream https://restream.io/
A
A
Hello,
everyone
today
we
are,
hopefully
maybe
we
do
more
than
just
the
activity
source
api,
but
based
on
past
experience,
we
might
actually
need
to
full
hour
for
this.
So,
let's
see
derek,
do
you
want
to
give
us
an
overview
of
what
it
is.
B
Yeah,
can
you
share
the
screen.
A
B
Yeah
go
a
little
bit
down
for
the
proposal
itself,
so,
basically,
in
in
five,
we
have
introduced
the
activity
context,
which
is
contains,
like
the
context
of
the
tracing
like
trace
id
span,
id
and
flags,
and
some
states
and
this
activity
context.
It's
it's.
It's
purpose
it's
it
can
be
in
the
distributed
tracing
scenarios,
it
can
be
transferred
over
the
wire
and
when
it
gets
transferred
over
the
wire
I
mean
it.
B
It
will
get
serialized
in
some
two
fields,
so
one
of
them
is
called
like
that
recent
parent
tracing
or
something
like
this,
which
is
get
formatted
to
some
specific
string
and
the
second
field,
is
just
as
a
states.
So
so
the
the
the
issue
here
is
like,
if
somebody
I
mean
like
in
other
end,
is
reading
this.
These
two
fields
from
the
headers
like
http
headers,
I
mean
getting
the
context
they
want
to
convert
these
two
fields
back
to
the
activity.
B
Context
object,
so
they
need
to
parse
it
back
and
and
create
the
activity
context
object
from
it,
which
is
like
you
know,
it's
not
that
that
complicated,
but,
but
still
I
felt
like
you
know,
we
don't
expect
everyone
need
to
do
that.
Who
is
going
to
parse
it
towards
the
fields
themselves
and
create
the
activity
context
from
it.
B
We
thought
I
mean,
like
the
proposal
here,
is
just
like
to
follow
the
pattern
for
try
bars.
We
thought
about
like
to
have
the
constructor,
but
the
point
is:
if
we
got
malformed
ids
I
mean
we
are
going
to
throw
and,
and
the
cooling
pattern
would
be
not
not.
C
B
This
state
is
just
like
property
and
the
value
I
mean
like
in
the
in
the
context
of
the
tracing
itself.
You
can
add,
like
some
properties,
with
some
values
so,
and
this
is
get
formatted
like
like
property
name,
equal
value,
comma
property,
name,
2,
equal
value,
2
and
so
on,
and
all
of
this
are
continuated
in
just
one
string.
B
E
B
B
Yes,
sorry
go
ahead,
yeah,
the
only
tripods
I
mean
like
the
w3
cid.
This
is
the
one
which
is
we
need
to
parse
it,
because
this
is
constructed
as
like
two
digits
version
dash
and
tris
id,
which
is
62,
digits,
hexadeci,
digits
and
dash,
and
then
16
hexa
digits
for
span
id
and
dash
some
flags.
B
D
B
As
a
span,
instead
of
strings
yeah
yeah,
I
mean,
like
usually
white
people.
Reading
the
I
think
the
http
header
and
this
stuff,
which
is
has
the
ids.
It
will
be
strings
anyway,
but
but
if
we
are
passing,
if
we
are
passing
span
so
for
the
state
at
least,
we
are
going
to
convert
it
to
string
again
because
we
need
to
store
it
as
a
string.
E
E
A
B
B
And
the
third
one
is
just
a
flag,
which
is
it's
a
number
of
what
like
it's
a
binary
number
I
mean,
like
is
a
zero
one.
A
B
Yeah
it
just
represent
okay,
so
activity
trace
id,
for
example,
is,
is
just
a
struct
around
around
the
string,
so
it
will
be
constructed
as
a
string.
E
A
Callers,
you
could
argue
that
you
know
if,
if
you
basically
construct
separate
strings
out
of
the
thing
you're
passing
in
then
by
allowing
the
caller
to
pass
in
a
span,
you
at
least
avoid
the
yet
another
allocation
to
just
represent
the
thing
that
is
going
to
be
split
right.
So
in
that
sense,
yes,
you're
not
zero
allocating,
but
you
would
be
allocating
less.
A
E
A
A
B
A
B
No,
I
mean
like
nobody
would
would
do
parsing
themselves,
I
mean
if
we
provided
this
ebr
right,
so
so
yeah
I
mean
like
imagine
like
you
are
getting
like
htv
response
I
mean
like
and
in
the
header
you
have
this
string
wc
id
and
you
want
to
create
the
activity
context
from
it.
So
you're
passing
to
this
api
and
you
will
get
the
object
and
that's
it
so
there's
so
we
are
doing
the
parsing
ourselves,
not
not
the
caller
doing
any
any
other
way.
I
mean
any
other
person,
gotcha.
G
B
A
B
F
And
there
is
a
version
in
this
transparent
thing,
so
if
it
changes,
we
can
have
another
internal
parsing
for
the
next
version
of
the
standard.
B
D
Saying
I
mean
it
probably
is
a
you
know
new
allocated
string
because
it's
a
subsection
of
the
whole
thing
that
you
pass
in,
but
I
mean
I
was
just
you
know
wondering
like
what
is
our
guidance
in
general,
because
it's
not
only
about
the
span
the
moment
you
have
the
span
tray
parsing
apis.
I
thought
we
have
a
new
pattern
that
tells
you
how
many
characters
were
successfully
parsed,
so
you
can
kind
of,
like
you
know,
receive
this
data
in
some
kind
of
buffer
and
keep
parsing
and
and
advancing
forward.
D
E
Yeah,
to
be
honest,
I've
never
seen
that
pattern
used
outside
of
utf-8
parser,
but
utf-8
parser
is
meant
for
kind
of
a
unique
scenario
where
you're
reading
like
a
protocol
or
or
things
coming
in
from
the
wire,
whereas
with
this
you
would
expect
it
to
be
potentially
delimited.
Somehow,
where
you
would
already
know,
here's
the
exact
chunk
that
I
want
you
to
parse.
So
if
parsing
succeeds
it
by
definition
consumed
everything.
D
But
you
see
if
it's,
if
it's
delimited
and
it's
not
handling
you
know
it
doesn't
stop
at
some
point,
then
you
have
the
problem
that
you're
getting
a
buffer
with
the
limiters.
Now
you
have
to
chop
them
into
strings
which
cause
lots
of
allocations
potentially,
and
then
you
pass
it
to
this
method
and
it
chops
it
even
more
into
the
id,
and
you
know
the
constituents
of
of
the
whole
time.
E
Yes,
but
I
don't
I,
I
don't
think
any
of
our
other
tripars
static
methods
on
these
types.
Follow
that
pattern,
though,
if
we,
if
we
wanted
something
like
that,
then
we
could
probably
do
it
on
utf-8
reader
or
utf-8
parser,
since
that's
where
all
of
the
other
similar
apis
are
yeah.
D
B
G
D
G
But
the
way
this
method
would
be
consumed
is
like
by
passing
the
value
of
a
header
into
it
and
outside
of
the
very
prototype
high
performance
web
servers.
Most
of
them
just
return,
give
you
string
as
the
header
value,
so,
while
you're
right
that
we
should
think
about
it.
I
would
think
I
I
would
say
the
most
common
use
case
just
doesn't
allow
us
to
give
the
value
in
the
span
form.
Okay,
yeah,.
D
So
that
makes
it.
I
know
that
david
is
trying
to
push
the
networking
team
to
give
access
to.
You
know
headers
in
the
more
efficient
way,
but
I
guess
when
we
have
that
we
can
add
the
method
correct,
like
we
basically
can
add
a
static
alternative
that
takes.
E
D
B
H
B
Also
with
the
constructor
is,
is
people
I
mean
like
if
somebody
see
like
we
can.
If
the
constructor
is
available,
they
can
just
use
the
constructors,
and
at
that
time
they
can
run
into
the
problem
of
the
person
I
mean
throwing
and
this
stuff,
so
it
will
be
good.
I
mean
like
if
we
have
just
tripods
only
I
mean
like
it's
telling
people
like
this
is
the
right
way
to
do
it.
D
B
D
D
So
I
would
say
the
same
here
we
if
we,
if
you
think
that
it's
okay
to
just
have
tripars
methods
which,
by
the
way,
if
we
were
starting
from
you,
know
kind
of
not
having
the
the
guideline
for
a
very
long
time.
I
do
think
that
kind
of
the
tripods
methods
are
just
better
and
we
should
just
have
them
only,
but
is
that
an
official
thing
we're
changing
the
guideline
or.
B
E
It
it
makes
it
more
usable.
Basically,
like
you,
don't
you,
I
would
imagine
many
callers,
probably
can't
recover
from
parse
returning
from
tripar's
returning
false
and
having
a
method
that
just
aborts
things
like
throwing
an
exception
is
very
useful
to
our
developer
audience,
but
what
I'm
not
suggesting,
adding
a
constructor,
I'm
just
suggesting
adding
a
parse
method
in
addition
to
tripars,
just
like
we
have
on
int
and
gwydd,
and
everything
else.
B
B
B
E
So
that
to
me
what
that
sounds
like
is,
we
actually
want
an
api
done
that
doesn't
return
well.
What
so,
what
would
they
do?
They
would
they
would
new
up
a
default
activity
context
and
then
just
use
that
yeah,
so
it
sounds
like
in
that
case
we
actually
for
the
common
user.
Don't
want
a
method
that
returns
true
or
false
at
all.
We
want
the
method
that
returns
a
real
or
fake
activity,
context
right.
B
E
Okay,
so
yeah
a
guideline.
A
guideline
is
not
a
death
pact
right,
it's
it's!
You
know
something!
That's
supposed
to
inform
influence
our
decisions
for
this.
If
you
know,
if
the,
if
the
designer
of
this
api
is
telling
us
that
it's
realistic
to
expect
people
have
a
fallback
rather
than
just
expecting
an
exception,
then
I
would
consider
that
a
valid,
exceptional.
D
It's
really
needed
here,
I
think
so
tarek.
I
would.
I
would
argue
that
locally.
If
you
look
just
at
this
api,
you
could
argue
that
it's
better
without
fires-
and
my
argument
is
actually
not
about
you
know
levi
is
saying
that
there
are
the
scenarios
and
it's
more
usable.
D
I
actually
don't
even
think
about
this.
I
think,
in
the
context
of
the
whole
platform,
we
taught
our
customers
that
they
can
always
rely
on
finding
both
methods
and
suddenly
you
would
have
some
apis.
We
would
start
you
know
apis
would
start
creeping
in
that
don't
have
both
methods.
I
think
the
net
value
the
negative
is
for
the
whole
platform,
not
for
this
api.
D
D
D
A
Mean
I
think
so
if
we
ever
fix
the
networking
stack
to
actually
give
you
headers
in
a
faster
way,
then
I'm
still
somewhat
skeptical
that
we
would
push
people
to
call
plumbing
apis.
To
do
that,
I
think
it's
more
likely.
We
would
offer
an
api,
like
you
know,
get
activity,
context
from
http
context
or
something
and
then
that
thing
fishes
out
the
headers
in
some
efficient
way
right.
I
don't
think
we
want
mainland
people
who
just
do
tracing
to
manually
construct
these
things.
A
Right
I
mean,
probably
you
want
to
just
have
a
one-line
method
that
gets
you
the
activity
context
and
that
user
spans
great
but
sure
I
don't
think
we
would
push
people
towards
that.
So
in
that
sense,
I
don't
think
that
you
know
the
the
parse
method
that
takes
a
string
would
lead
people
down
the
wrong
way
or
try
parts
for
that
matter.
A
A
All
right
so
then
anything
else
about
this
did
they
would
say
anything
more
in
chat.
E
That
came
up
earlier
of
the
term
w3cid.
I
didn't
see
that
term
used
in
any
other
public
api.
Is
it
used
anywhere
else
in
a
publication.
D
One
more
question
about
the
trace
state
parameter
since
it's
nullable:
yes,
should
it
be
defaulted
for
in
the
parse
method,.
D
Be
defaulted
to
null
how
you
defaulted
in
the
pattern
of
try,
try
part,
no
just
just
the
powers.
D
A
A
B
C
B
G
But
is
it
true,
like
this
pack,
almost
always
talks
about
propagating
both
values
along
so
like
scenario
where
your
only
have
transparent
or
you
forgot
to
parse,
the
tray
state
header
would
be
rare,
like
maybe
we
shouldn't
have
the
overload.
So
people
remember
to
parse
both
all
the
time
and
like
if
they
really
really
don't
have
the
trace
state,
then
they
can
always
pass
now.
A
Yeah,
I
would
say
like
if
it's
very
common
practice
to
not
have
it,
then
I
think
it
makes
sense
if
the
common
practices
you
always
have
one.
I
would
agree
with
you
so
to
me
it's
kind
of
like
the
you
know.
If
it's
very
common,
then
I
wouldn't
have
it.
C
A
Of
the
wrong
overload
great
that
kind
of
norm
also,
I
guess,
raises
the
point
of
like:
should
we
make
this
actual
optional
on
the
other
one
as
well,.
C
A
Yeah
I
mean
the
only
benefit
of
defaulting.
Is
that
you
kind
of
know
that
it's
okay
to
not
pass
it
in
the
value?
I
mean
the
nullability
kind
of
hints
at
that,
but
the
vast
majority
of
people
still
don't
do
nullables.
So
they
probably
don't
realize
that
this
is
not
something
you
need
to
pass
in,
but
I
think
I'm
okay
with.
D
Yeah,
I
need
to
run
guys
too,
because
I
I'm
so
swamped.
D
A
B
A
Relatively
straightforward,
so
the
one
thing
that
we
talked
about
was
for
windows
specific
apis.
The
plan
was
that
we
will
mark
them
as
windows,
7
0.,
the
reasoning
being
that
that's
the
minimum
we
support
and
instead
of
us
chasing
down,
which
apis
were
actually
implemented
when
we
just
use
the
lower
bound
and
then
eric
gerhart
pointed
out
that
that's
actually
not
super
useful,
because
first
of
all
that
also
no
means
that,
if
I
check
for
the
api,
I
kind
of
have
to
check
for
the
version
number,
which
you
could
argue,
the
address
consistency.
A
But
then
the
other
problem
is,
you
already
have
existing
code.
That
does
basically
what
we
told
people
to
which
is
runtime
information.sos
platform,
os
platform.windows,
and
given
that
this
doesn't
include
a
version
number
like,
we
would
always
flag
these
calls
now,
and
so,
if
we
were
to
just
mark
it
with
windows,
we
can
actually
get
away
with
fairly
reasonable
semantics.
A
By
saying,
if
you
don't
say
a
version
number,
you
basically
mean
0.0
and
if
you
do
an
os
platform
check,
it
basically
means
you're,
asserting
a
minimum
version
of
0.0,
which
no
means
that
in
combination,
if
we
just
mark
them
in
specific
apis
with
windows
without
version
number,
all
these
checks
now
suddenly
don't
cause
any
noise
in
your
code.
They
all
are
considered
now
basically
correct
code
and
that's
not
necessarily
a
practice.
I
would
recommend
for
every
window
specific
api.
A
I
would
just
say
we
only
do
it
for
apis
that
are
basically
supported
by
all
versions
of
net
core.
If
we
add
new
apis
that
are
requiring
a
higher
version
of
windows
like
you
know,
windows,
8,
8,
1
or
10,
or
something
we
will
still
annotate
them
with
those
version
numbers.
But
you
know
for
things
where
we
really
don't
expect
people
to
run
environments
that
don't
have
them.
It
seems
kind
of
pointless.
E
That
makes
sense,
is
there
anything
do
we
have
any
linux
or
mac
apis
that
fall
under
the
same
category?.
A
Probably,
although
we
don't,
I
mean
linux
is
kind
of
a
sad
example
in
this
in
that
world,
because
we
don't
have
many
linux
specific
apis
today
right.
The
only
thing
that
I
know
of
is,
if
you
will
this
quint
open,
ssl,
and
that
might
be
similar.
Yes
for
for
ios
and
android,
you
could
say
that
you
know,
given
that
it
will
not
support
ios
4
or
something
right
that
anything
that's
older
than
a
certain
ios
version.
A
The
reason
windows
is
different
here
is
because
we
have
window
specific
apis
in
the
otherwise
cross-platform
base
layer
right
so
registry
and
echo
apis
are
available
when
you're
just
built
for
net
five,
and
so,
if
you
just
built
for
net
five,
there
is
no
minimum
version
number
right,
and
so
we
would
now
say
everything.
That's
window
specific.
You
have
to
actually
have
a
version
check
versus.
If
you
build
a
wpf
or
winforms
app
same
reasoning
would
apply
right.
A
Linux
is
the
only
one
where
that
might
happen,
but
like
for
linux,
we're
also
in
this
position
where
version
numbers
are
generally
not
something
that
makes
a
lot
of
sense.
So
I
guess
yeah.
I
can
totally
see
an
api
being
linux
specific,
but
what
it
really
means
is
any
version
of
linux.
H
A
Yeah,
because
we
don't
expose
the
ios
bindings
in
the
net
5
tfm,
you
would
have.
A
A
Well,
I
mean
it
depends
on
what
you
mean
by
the
api
right,
I
mean
like
you.
Yes,
you
cannot
expose
any
ios
specific
apis
in
the
sense
that
you
can't
use
the
official
bindings,
because
we
don't
give
you
the
official
bindings
of
the
net
5
tfm
right,
but
you
can
have
your
own
types
that
you
use
to.
You
know
p
invoke
and
marshall.
A
If
that's
what
you
can
do
in
the
same
way
that
if
I
have
a
p
invoker,
I
can
define
my
own
classes
and
structs
that
are
then
either
marshalled
over
or
copied
to
some
private
things
that
are
being
marshaled
right
and
then
what
you
can
do
is
you
can,
of
course,
mark
your
own
api
as
yet
this
api
requires
ios,
so
you
can
just
forward
the
the
version
check
to
your
customers
or
you
can
do
it
for
your
customers.
If
you
abstract
it
away
somehow.
I
I
A
Well,
I'm
saying
what,
if
so
in
principle,
you
can
do
that
right.
So
the
analyzer
and
the
the
platform
check,
mechanics
that
we
have
in
the
platform
would
support
that.
The
challenge
is
that
we
don't
give
you
bindings
against
5.0,
and
so
the
only
reason
why
we
have
bindings
for
windows
in
five
hours,
because
we
like
this
windows,
tfm
thing
didn't
exist
back
then
right
so
like
everything
that
is
windows.
A
Specific
also
happens
to
be
in
the
cross
platform
tfm
already,
but
we,
but
we
not
all
of
it
by
the
way,
not
win
forms,
not
wpf
right,
but
because,
with
five
always
said,
wpf
and
winforms
will
only
be
in
that
five
dash
windows
either.
So
if
you
want
to
call
those
apis,
you
have
to
actually
cross
compile
as
well,
and
the
cross
compilation
would
be
the
canonical
way
how
you
would
abstract
it
you
would.
You
would
give
your
customers
a
public
void,
do
something.
Then
you
would
say
pound
if
this
do
that
pound.
I
A
Unless
you
are,
you
know
having
access
to
eric
and
you
can
directly
ask
him
what
to
do,
but
that
one
is
not
going
to
change
anytime
soon
and
we
also
don't
have
you
know
the
the
typical
vs
problems
of
you
know
that
the
cross
compilation
is
not
fully
plumbed
through
the
ui
experience,
but
you
know,
building
a
new
get
package
that
is
cross
compiled
is
literally
a
checkbox
in
vs.
At
this
point,
you
just
have
to
deal
with
the
fact
that
you're
cross-compiling-
and
that
comes
with
some.
A
I
So
as
we
move
forward
in
time
and
we
drop
wind,
7
support
and
mac
and
ios
end
up
dropping
their
legacy
versions
right
will
we
conceptually
be
okay
with
going
and
changing
existing
version
checks
like
let's
say
in
three
years
when
windows
7
is
fully
not
supported
anywhere,
even
with
paid
support
or
whatever
right?
Are
we
conceptually?
Okay
with
going
and
changing
existing
apis?
That
say,
like
min
version,
win
10
and
just
changing
those
to
be
no
version.
A
A
I
would
just
question
the
value
that
you
provide,
because,
presumably,
if
people
targeted
these
operating
systems
already
without
n5,
they
would
have
to
have
version
checks
in
them
today,
and
so
you
basically
now
say
well,
if
you
were
to
target
you
know,
if
you
write,
if
you
would,
if
you
were
to
write
a
brand
new
project,
then
the
benefit
of
these
you
know
simplified
bindings
would
not
be
that
you
don't
have
to
do
version
checks.
A
I
Yeah,
I
I
imagine
the
two
things
are
one
net
new
code
and
two
notifying
users
that
hey
this
code
is
effectively
dead
now
on
dotnet,
seven
and
so
you're.
Actually
you
know
you,
you
have
this
code,
you
have
this
additional
maintenance
cost
that
you
really
don't
need
anymore,
because
you'll
never
be
able
to
run
on
that
platform,
because
we
just
don't
support
it
anymore
right.
I
So
so
I
think
there's
benefit
both
to
new
code,
which
allows
you
to
write
simpler
code
from
the
get-go
and
also
existing
code,
where
you're
able
to
identify
code
that
you
don't
need,
like
win10,
has
a
newer
version
of
libgdi
as
a
baseline.
And
so
you
could
say
you
don't
need
to
check
for
libgdi
6
anymore,
because
you
can
assume
61
is.
Is
there.
A
Yeah,
I
mean
basically
what
you're
asking
is
the
inverse
analyzer
right.
There
basically
says
if
you're
running
under
a
god
clause
is
any
of
the
apis
you're
calling
actually
requesting
the
api
version.
You
are
checking
for
which
we
don't
have
today,
but
that's
kind
of
what
you
would
have
to
do
to
actually
let
people
know
that,
oh
by
the
way,
you're
checking
for
version
number
that
you
don't
have
to
anymore.
Otherwise
you
don't
benefit
from
this
right.
E
Well,
it's
so
that
there
definitely
is
a
benefit
to
making
new
code
easier
right,
like
one
of
the
things
that
we've
been
mentioning,
for
you
know,
20
years
is:
why
are
we
paying
now
for
the
sins
from
the
you
know,
late
90s,
but
I
I
think
the
analyzer
that
you
and
tanner
were
just
talking
about
off
by
default
is
useful.
Just
from
the
general
category
of
hey,
here's
10
lines
of
code
that
you
can
shrink
down
to
two
right.
G
E
More
of
a
like
a
modern
paradigm
type
analyzer-
I
don't
know
if
we
have
a
category
for
that
right
now,.
A
I
don't
even
think
it
needs
to
be
on
off
by
default.
It
would
I
mean
you
just
have
to
make
sure
that
it's
that
it
doesn't
have
false
positives
right,
but
if
it
kind
of
works,
the
way
I
described
it
seems
this
is
generally
desirable
right,
because
it
probably
means
you
you
immediately.
I
mean,
if
you
just
do
normal
development
right,
you
call
some
apis.
We
warn
you,
you
know
start,
you
know
guarding
the
calls
you
refactor
your
code
and
all
of
a
sudden.
A
It's
like,
oh,
you
know,
you
call
a
different
api
that
requires
a
you
know,
a
minimum
or
sorry
only
a
smaller
version
of
windows,
where
you
know
accidentally
like,
require
a
higher
version
of
windows
right,
that's
like,
even
even
without
us,
changing
the
platform.
Versioning
that
still
seems
beneficial
to
make
sure
that
your
code
is
actually
checking
what
it
should
and
not
more,
not
less,
but
yeah.
It
seems
like
I'm.
A
E
I
don't
I
don't
necessarily
know
if
that
analyzer
by
itself
would
be
all
that
useful,
but
it
came
with
a
bunch
of
other
if
it
came
with
a
bunch
of
other
here's
how
to
modernize
your
code
analyzers,
then
I
think
it
has
utility.
G
E
E
Let
that
stop
us
from
doing
this,
though,
and
I
I
would
still
be
a
fan
of
what
tanner
had
suggested
regarding
like
once
7-0
goes
out
of
support.
Then
we
we
start
re-baselining.
E
A
I
We
have
internal
checks
which,
at
least
within
corelib
or
the
framework
itself,
might
be
beneficial
to
have
these
for
our
own
purposes,
and
some
of
those
are
wind,
10,
specific,
such
as
in
win
gdi
or
lib
gdi.
E
Yeah
and
asp.net
does
some
get
proc
out
or
get
proc
address,
hijinks
to
figure
out
what
capabilities
your
os
supports
and
they'll
you
know
call
enlightened
apis
if
they're.
H
I
I
Today
and-
and
I
think
the
general
concept
is
you
know
if
we
are
exposing
stuff-
that's
win.
Seven
specific
today
win
10
has
added.
You
know
a
slew
of
new
apis
that
we
may
eventually
take
a
dependency
on.
H
I
A
I
mean
xamarin
generally
xamarin,
essentially
generally,
doesn't
they
do
capability
apis
now
for
this
stuff,
but
like
the
idea,
is
that
they're
basically
cross-platform
similar
to
what
you
know
we
have
in
the
bcl
right?
A
The
only
thing
is,
if
it
is,
I
asked
us
the
winforms
guys
like
because
they
added
new
apis
for
the
for
some
stuff,
that
vista
added-
and
I
said
like-
is
there
anything
that
you
added
that
isn't
in
win7
the
answer
was
no
and
I
think
like
if
they
would
start
to
add
some
things
like
I
don't
know,
windows
10
added
some
shelf
feature,
and
then
they
start
adding
those
concepts
to
winforms
or
wpf.
Then
we
may
have
the
exact
same
situation.
A
We
would
say
yep,
there's
a
new
property
on
form
or
whatever,
and
that
would
be
you
know,
supported
os
platform.
Windows
10
point
something
right
and
then
the
experience
would
be
very
similar.
It
would
be
a
bit
more
tricky
there
if
you
consider
the
designer,
because
you
don't
actually
write
the
code
yourself,
so
flagging
designer
generated
code
might
not
be
what
we
want,
but
I
guess
that's
a
problem
we
can
tackle
when
they
actually
do
that.
A
E
Yeah,
the
only
thing
I
can
think
of
is
that
I
know
that
asp.net
like
websockets
on
iis,
for
instance,
they
do
have
to
have
some
os
guards
there,
but
they
don't
expose
their
own
public
apis
using
these
attributes.
Instead
they
use
a
they
use
like
an
I
feature,
interface
type
thing,
and
then
you
would
detect
the
presence
of
that.
So
they
have
a
different
way
of
solving
this.
In.
H
C
Actually,
I
think
we
do
have
a.
We
do,
have
an
api
that
doesn't
work
on
win7
and
dot
net
5
for
tls.
G
C
Also,
this
doesn't
seem
to
the
api
doesn't
seem
to
handle
things
like
openssl
version.
C
A
Yes,
you
can't
yeah,
you
can
say
like
this
is
conditioned
on
some
other
thing.
You
can
only
talk
about
a
particular
os,
because
that's
the
only
thing
we
realistically
can
do
anything
checking
for
right,
but
I
mean
you
could
imagine
that
we
map
this
right,
like
you
could
say
that
we
know
that
openssl
version
x
is
supported
on
these
platforms
and
then
we
can
transcode
this
into.
That
means
these
platforms
are
supported
right,
but
that's
probably
problematic,
because
openssl
is
a
moving
target
as
well
right
and
they
may
add
new
support
for
operating
systems.
A
You
know
older
or
newer
for
that
matter,
so
that
might
be
hard
right.
I
mean
I
would
generally
say
the
way
I
see
this
is
like
there's
kind
of
two
kinds
of
apis.
Then
right
there
is
the
actual.
You
know
cross-platform
api,
that
we
provide
and
then
we're
on
the
hook
to
make
whatever
crazy
gymnastics.
A
Here's
particular
integration
points
that
we
provide,
that
you
know
like
open,
ssl
or
you
know
wmi
or
something
like
this,
and
then
we
would
try
to
make
that
work
across
a
certain
set
of
operating
systems
that
we
happen
to
support
right,
and
so
in
that
sense
we
get
to
save
what
we
support
right,
if
there's
a
newer
version
of
openssl
that
supports
windows
vista
for
whatever
reason,
but
you
know
we
didn't
build
it
this
way
we
only
built
the
dependency
for
for
for
windows
7.
Then
that's
fine
right
like
that.
A
All
right,
I
think
we
are
now
kind
of
out
of
time.
For
anything
else
I
mean-
maybe
this
one
here.
It
should
not
be
super
controversial
because
we
just
talked
about
it.
A
So
when
I
proposed
a
set
of
windows,
specific
apis
jeremy
mentioned
that
openssl
should
be
marked
as
not
supported
on
windows,
which
back
then
we
didn't
have
an
actual
way
to
do
this,
and
now
we
actually
have
that
it's
the
unsupported
os
platform
attribute,
and
we
would
basically
I
propose
we
would
mark
the
whole
assembly,
like
this
saying
yeah,
there's
no
version
of
windows
that
supports
it.
A
Jeremy
hinted
at
the
fact
that
we
may
be
able
to
support
it
in
the
future,
based
on
some
work
that
windows
might
be
doing,
and
then
we
would
just
you
know,
add
another
attribute
to
that
which
would
be
supported,
os
platform
windows
x,
dot
y,
and
that
would
basically
indicate
that
you
know
openssl
is
not
supported
on
windows
unless
you
own
this
version
or
higher.
E
So
my
I
did
a
comment
on
that
offline.
I
think
to
some
people
when
windows
is
moving
to
a
model
where
things
are
provisioned
via
the
store,
rather
than
in
any
given
version
of
the
operating
system.
So
the
idea
is:
let's
say
that
you
know
the
version
of
windows
that
comes
out
next
year
might
have
support
for
openssl,
but
you
would
still
have
to
acquire
an
enablement
package
through
the
store.
So
now
you
have
a
philosophical
question:
is
a
version
check
sufficient,
or
do
you
also
need
to
perform
a
capability
check.
A
Well,
I
mean,
I
would
say
no,
I
would
say
you
know
we
can
look
up
what
os
versions
that
store
package
provides,
support
for
which
clearly
wouldn't
be
win.
Seven
right,
because
the
store
is
effectively
at
least
eight.
Oh
right,
but
probably
it
would
probably
be
ten
point.
Something
would
be
my
guess,
and
so
we
would
just
say
yeah.
A
The
minimum
is
ten
point
something,
and
then
you
may
still
have
to
acquire
that,
but
in
the
same
way
that
you
know
if
you're
running
on
a
windows
server,
you
may
have
to
enable
long
path,
support
or
something
that
we
know
we
can
detect
and
tell
you
in
an
exception
meshes,
but
we
wouldn't
be
able
to
do
it
aesthetically,
and
so
I
think
that's
the
way
we
would
do
it.
I
mean
the
minimum.
We
would
just
fail
at
runtime
with
an
actionable
error.
That
says
sorry,
you
didn't
actually
acquire
the
package.
A
Please
download
that
from
the
store,
or
we
would
just
tell
people
like
sorry
like
you
know,
we
can't
do
this
or
we
basically
just
say.
Okay.
Maybe
there
is
an
actual
way
if
this
is
popular
enough,
if
we
can
put
an
attribute
on
the
method
that
says,
require
store
package
xyz
and
then,
if
we
have
fancy,
we
aggregate
all
call
sites.
You
have
generate
your
manifest.
That
says,
your
app
that
you
just
built
requires
these
four
store
packages
to
be
on
your
box
right
and
that
becomes
ever
an
issue.
A
E
A
Well,
but
that's
what
I'm
saying,
I
think
it
would
be
right,
because
you
would
basically
say
you
know
if
whatever
the
package
is
that
goes
into
the
into
the
store,
will
have
a
minimum
os
version
that
that
this
package
runs
on
right,
and
that
will
be
the
version
I
would
put
here
and
then
there
is
this
orthogonal
thing
of
like
yeah.
By
the
way
you
have
to
install
this
store
package
to
use
openssl
and
that
we
can't
express
unless
we
do
work
right,
I
mean
in
in
concept.
A
E
Right
and
and
now
I
would
need
to
guard
the
call
site
with
if
os
is
supported
and,
and
has
you
know,
package
installed
right
well,
yeah,
if
you
wanted
guard
for
that,
I
guess
yes,
but
now
why?
Why
do
I
have
if
a
and
b
guarding
the
call
site,
if,
instead
of
just
having,
if
b,
because
if
b,
is
always
going
to
give
me
the
correct
answer?
Why
am
I
even
performing
an
os
version,
jack.
A
E
I
E
A
Yeah,
I
would
agree
with
that.
If
that
is
the
thing
I
mean,
I
guess
so,
let's
say
we
ship
now
with
unsupported
start
from
windows
and
then
in
the
dot
net,
6
time
frame
what
you
described
happened
at
that
point.
I
would
just
strip
the
attribute.
I
would
just
say
sorry,
there's
no
platform
check.
You
can
do
the
check
you
have
supposed
to
write.
Is
this
and
then,
if
we
really
feel
fancy
enough,
we
would
write
a
one-up
analyzer
for
that
or
we
would
generalize
it.
E
Yeah
and
by
the
way
like
just
to
clarify,
I
have,
I
have
no,
you
know
knowledge
whatsoever
of
the
os
team
actually
going
to
do
this.
It's
just
this
is
the
direction
they're
heading
with
a
few
other
things,
so
we
need
to
be
prepared
for
how
we
want
to
deal
with
the
world
where
this
does
come
to
fruition.
Right.
G
E
So
yeah,
as
is
here,
seems
fine
with
the
knowledge
that
in
the
future
we
might
have
to
remove
it
yeah.
I
guess
that's.
E
I
I
I
I
A
E
A
A
I
A
I
A
A
This
is
marked
as
api
approved.
Okay,
let's,
let's
try
something,
I'm
not
sure
my
tool
will
pick
this
up,
but
I
can
try.
Let's
do
this,
let's
change
it
back
to
approved
to
just
trick
my
tool
and
then
see
whether
that
actually
works.
A
It
was
suggested
yeah
that
should
work,
it
won't
suggest
to
add.
The
question
is
just
whether
the
it
becomes
a
nor
because
it
just
happened
in
sequence,
but
I
think
it
should
handle
it.
It
wasn't.
You
should
put.
C
A
Well,
tomorrow,
I
have
the
the
other
issues
that
I
marked
as
blocking.
So
we
have
console
logger
and
then
there's
this
one
here
that
I
hope
I
read
enough
details
to
actually
talk
about
it,
and
then
this
one
was
basically
a
rename
suggestion,
yeah
great
and
then
the
rest
would
be
backlog.