►
Description
Join members from the .NET teams for our community standup covering great community contributions for Framework, .NET Core, Languages, CLI, MSBuild, and more.
A
A
A
Hello
friends,
I
think
we
are
now
live
unless
I
messed
something
up
again.
So
this
is
our
language
and
want
to
communicate
stand
up
today
with
me,
we
have
a
few
people,
so
I
introduce
myself
again
and
then
the
other
people
can
go.
So
I'm
landworth,
I'm
a
pm
on
the
platform
team.
A
A
For
us,
so
I
think
fuller
wants
to
go
first
right.
He
had
a
cool
demo.
B
C
Yeah,
I
don't
know
about
cool,
but
yeah,
so
pretty
much.
The
main
thing
from
the
f,
sharp
language
side
of
things
is
that
we
are
now
done
with
f
sharp
five
from
a
feature
standpoint.
So
I
think
I
wrote
a
blog
post
a
little
while
ago
saying
that
there
would
be
one
more
tweak
that
tweak
has
basically
been
implemented
for
one
of
the
features
that
we're
shipping,
and
so
now
the
teams
focus
up
until
the
donet5
release
is
going
to
just
be
bug,
fixes
and
incorporating.
C
You
know
some
feedback
that
we
get
from
some
of
the
features
that
we
finished
over
the
next
I
think
month
and
a
half
two
months
or
so
now
and
then
and
then
we'll
be
in
like
hard
lockdown,
probably
taking
things
like
very
severe
bug
fixes
until
the
don
i5
release,
which
is
also
going
to
be
the
five
release.
C
C
Okay,
we
only
have
like
a
short
amount
of
time
to
make
sure
that,
like
any
possible
bugs
and
regressions
that
we
may
have
like
not
quite
accounted
for
get
fixed
before
it
goes
out,
but
I'm
sure
it'll
be
a
good
release
because
we've
been
getting
a
lot
of
people
using
the
previews
of
these
features
for
a
long
time
and
fixing
things
along
the
way.
So,
speaking
of
that
last
time
I
demoed
interpolated
strings.
C
I
won't
be
demoing
that
again,
because
that
it's
already
there
one
thing
I
did
make
mention
of
is
that
we
had
a
feature
called
open
type
declarations
and
that
was
going
in
there,
but
I
did
not
have
a
demo.
C
That
was
because
the
bits
were
not
inside
of
the
internal
build
of
visual
studio
that
I
was
using
to
demo
things
off
of
so
the
only
thing
I
could
have
shown
was
a
editor
full
of
compile
errors,
and
so
I
wasn't
going
to
bother
doing
that
so
instead,
now
that
everything
is
all
hooked
up,
I'm
going
to
actually
do
stuff.
So
let
me
share
my
screen
here
should
have
visual
studio.
Everybody
should
be
able
to
see
this
without
any
issue.
Okay,
so
this
is
just
an
f
sharp
script
using
a.
C
C
That's
basically
what
this
is
except
we
think
ours
is
named
a
little
bit
better
because
it
is
about
really
opening
up
a
type
to
expose
stuff
inside
of
it.
So
one
of
the
classic
ones
is
open
type
system,
dot,
math
right,
and
so
you
can
type
pi
you
can
type.
You
know
I
get
max.
I
don't
have
to
go
math.max,
you
know
ceiling.
C
If
you
can
spell
correctly
there,
we
go
things
like
that
right,
so
this
is
whenever
there's
a
static
class
that
contains
static
methods
on
it,
that
this
is
sort
of
like
the
one
of
the
primary
use
cases.
For
that
sort
of
thing.
You
can
also
do
this
on
your
own,
so
I
can.
I
can
go
my
static
class
in
f
sharp
and
I
can
go
static.
Member
m.o.
C
Spell
your
name
directly:
there
right
and
the
static
class
is
actually
just
a
class
that
is
both
abstract
and
sealed.
That's
actually,
literally
what
it
is
under
the
covers.
If
you
compile
a
static
class
down
in
c
sharp
down
into
il,
it
is
a
class
that
is
abstract
and
sealed.
So
I
can
go
open
type,
my
static
class
and
I
can
unqualified
access
mo.
I
don't
need
to
say
my
static
class.memo.
C
This
is
a
tool
that
might
be
that's
probably
going
to
be
used
more
by,
or
rather
the
the
it's.
The
ability
to
expose
static
stuff
is
probably
going
to
be
used
more
by
by
library
authors
than
anything
else,
but
there
is
a
rather
interesting
addition
that
we
did
to
this.
That
is
fairly
unique
for
f-sharp,
so
consider
a
module
that
I've
called
my
module,
and
I
have
a
function
thing
right.
Just
a
unit
returning
function
does
nothing.
Let
other
from
function.
C
X
is
x
times
x,
whatever
that's
like
square,
but
like
say
I
have
a
whole
bunch
of
these
functions
here,
so
you
have
like
20
or
30
of
them.
What
I
can
normally
do
is
I
can
go
open
my
module
and
I
can
open
up
this
module
and
expose
everything.
That's
in
there
right.
D
C
And
there's
an
a
there's,
a
b
and
there's
a
c.
What,
if
I
want
to
access
my
union,
but
I
don't
want
to
access
anything
else
in
here.
Well,
there's
an
easy
way
to
do
that
today,
my
module
dot
a
b
c
like
that
kind
of
stuff.
But
what
if
I
don't
want
to
do
that,
though,
what
if
I
want
unqualified
access
to
a
type,
but
I
don't
want
to
access
anything
inside
here.
Well,
there's
no
way
to
actually
accomplish
that
in
fsharp.
Today,
until
f,
sharp
five.
C
Now
I
can
go
open
type,
my
module
dot,
my
union
and
now
I
can
get
unqualified
access
to
these
union
cases.
So.
D
C
C
You
know
nested
classes,
you
can.
You
can
actually
even
do
interesting
things
like
open
type,
system.collections.generic
of
list
of
int
and
it
will
actually
open
up
a
like
stuff
and.
C
Isn't
actually
a
good
example
because
there
isn't
anything
useful
in
there,
but
it
will
basically
make
it
so
that
the
the
generic
type
that
you're
working
with
unqualified
from
that
point
is
an
int.
You
can
actually
also
do
this
in
c
sharp,
which
is
interesting.
Most
people
probably
don't
know
that
you
can
use
ecstatic
a
static
class
and
parameterize
it
with
a
generic
type,
but
so
yeah.
This
is
sort
of
the
last
feature.
That's
now
shipping
in
f
sharp
five
along
with
I
believe
I
counted
it.
C
I
believe
it's
11
other
features
that
we
shipped
I'm
not
going
to
go
over
all
them
right
now,
but
I
will
be
writing
a
blog
post,
probably
with
the
the
donet5rc
alongside
like
whenever
donna5rc
comes
out,
it's
gonna
be
like
five
rc
as
well,
and
so
I'll
have
a
blog
post
that
just
basically
it's
gonna
go
through
every
single
feature
that
we
shipped
and
just
sort
of
combine
all
the
different
things
that
we've
done
in
previous
blog
posts
just
have
to
like
a
giant
mega
blog
post
and
then
probably
do
that
again
for
for
the
release
as
well,
and
that's
what
I
got.
B
C
Yeah
it
was,
it
was
okay,
so
that
was
actually
pretty
fun.
Is
it
your
first
time
you
see
this
water
bottle
so
so?
Well,
actually
so
I
gotta,
I
don't
know
if
you
can
kind
of,
I
have
a
new
mic.
C
Yeah,
no,
no,
I'm
not
gonna
speak
into
it
all
creepy,
but
I
didn't
have
this
for
the
donut
rock
show,
and
so
I
just
had
like
this
webcam
from
the
office
that
was
kind
of
not
very
good
and
kind
of
just
had
like
the
built-in
microphone
that
sucked,
and
so
I
was
on
the
thing
with
carl
franklin
and-
and
I
was
speaking
to
him
and
then
he's
like
wait.
Wait
phillip
hold
up
I'm
going
straight
with
you,
you
sound
like
crap
dude
and
I'm
like
really
he's
like
yeah.
C
This
is
like.
Do
you
have
anything
else,
because
this
is
gonna
sound,
really
really
bad?
On
the
podcast
like?
Oh
no
and
we
tried
like
my
laptop
and
it
was
the
same
problem,
and
I
just
I
sounded
like
I.
C
I
think
he
said
that
I
sounded
like
I
was
inside,
of
a
bathroom
made
out
of
metal
like
like
that's
how
awful
it
sounded,
and
so
we
figured
out
that
I
could
turn
the
levels
through
windows
on
that
on
that
thing
way
way
down
and
then
put
the
webcam
on
the
rim
of
this
water
bottle
and
then
point
it
up.
At
my
face
with
the
the
webcam
turned
off
so
that
it
acted
as
a
microphone
and
so
like
the
podcast
went
clearly
and
the
sound
was
okay,
but
after
that
happened,
I'm
like
okay.
B
Drum
it
is
I've
been
on
with
you,
and
so
that's
like
that
was
a
good
call.
That
was
a
really
good
call
to
do
that
and
I
am
so
impressed.
Let
me
guess
it
was
richard
that
figured
now
ben
it
was
carl
that
figured
out.
That
was
a
trick
that
you
can
do
well.
C
It
was,
it
was
a
collaborative
effort,
so
what
carl
figured
out
the
trick
and
then
he
said
I
needed
to
find
a
way
to
get
it
close
to
my
mouth
and
I
didn't
feel
like
holding
it.
So
then
I
saw
a
water
bottle
and
I'm
like,
oh,
I
could
just
put
it
on
the
rim
of
the
water
bottle
and
yeah.
It
worked
out.
Okay,.
A
B
Good
yeah,
so
we
didn't
get
a
question
which
I
can
answer
pretty
clearly,
which
is
which
version
of
vs
is
going
to
contain
f5
rtm
support
and
that
will
be
update,
8.
and
so
yes,
update,
8
comes
out
in
november
and
november.
Is
our
timeline
for
all
future.net
releases
forever?
B
Well
right,
as
far
as
we
can
tell,
we,
we've
got
the
commitment
now
this
schedule
and
we'll
be
aligning
with
one
of
the
updates
in
visual
studio
is
updating,
so
the
current
previews
is
where
you'll
find
net5
on
its
way
to
rtm
yeah.
So,
let's
see
oh
yeah,
baby
equipment
free
might
work
yeah
and
I'm
not
a
crap
camera
that
doesn't
zoom,
and
so
you
can
see
my
whole
living
room.
You
know,
which
is
unfortunate.
B
I
mean
I
could
get
one,
but
it's
not
the
one
I
want,
and
so
it's
been
hard
for
me
to
do
that
and
believe
it
or
not.
I've
been
on
all
sorts
of
places,
including
uh.net
rocks
and
my
surface
pro
mic
is
what
I'm
using
and
it
is
kicking
ass.
It's
kicking
the
the
mic
on
the
camera.
Doesn't
work
very
well,
but
the
mic
on
my
surface
just
does
just
fine
and
I
I
you
know
get
in
touch
with
richard.
They
had
to
tell
me
like
all
right.
B
B
I
hope
it's
someplace
down
the
road
for
all
of
us.
We
all
would
like
to
see
that
yeah
yeah
all
right.
Okay,
so
hey
can
we
talk
about
vb.
B
All
right,
all
right
so
vivi
is
like
in
this
opposite
mode.
Then
it's
in
opposite
mode.
Then
then
I
get
the
wrong
person
big.
Let's
see,
if
I
can.
Alright,
I'm
gonna
remove
myself.
B
Okay,
so
we'll
just
go
back
to
that:
okay,
there
we
go
okay,
let's
let's
just
go
to
the
code
and
not
worry
about
trying
to
to
talk
without
the
code
for
a
second.
So
our
goal
for
vb
for
for
the
uh.5
timeframe,
is
to
get
winforms
working.
Well
now
that
sounds
like
it's
just
going
to
be
a
like.
B
It
doesn't
sound
like
as
big
a
deal
as
it
is,
but
we
did
a
lot
of
things
to
win
forums,
in.net
core
that
were
different
than
dotted
framework,
and
one
of
the
big
ones
was
that
the
the
designer
itself
is
now
out
of
prac
and
for
for
vb
that
made
a
difference,
because
we
have
to
talk
to
the
editor
to
set
up
the
with
the
handles
clause.
B
So
when
you
set
up
to
handle
the
get
the
behavior
for
an
event,
then
that
is
in
a
in
the
code
in
a
different
way
than
it
is
in
c
sharp,
basically
c
sharp
with
one
place
and
a
vb.
You
look
well
anywhere,
and
that
was
actually
really
hard
to
do,
and
so
I
realized
that
this
is
going
to
be
not
like
it's
like
a
it's
a
demo.
That's
really
important
for
me
to
share,
but
I
know
that
it
not
maybe
doesn't
quite
have
the
flash
of
some
other
demos
is.
B
I
am
going
to
click
this
button.
Okay,
click
the
button
and
we're
going
to
go
to
code
and
we're
going
to
go
to
a
previously
exist
as
a
form
load.
It
did
not
go
to
the
button.
It
should
have
gone
to
the
button.
Hang
on
a
second
we'll
get
that
let's
go
back
over
here,
and
I
know
I
clicked
on
the
wrong
thing.
So,
let's
just
try
this
again.
I
clicked
on
the
button.
B
Let's
click
on
the
button
and
with
formula
I
got
to
check
on
that,
but
we
did
not
create
the
the
problem
previously.
Is
we
created
a
new
one?
Every
time
we
double
clicked
on
it,
and
so,
regardless
of
whether
you
had
one,
I
don't
know
why
it's
going
to
form
one
instead
of
going
to
button
one.
This
is
last
night's
bets.
Quite
literally,
I
picked
them
up
this
morning,
loaded
them
on
my
machine.
This
is
very
new
stuff
to
get
that
fixed.
B
The
other
thing
we've
been
working
on
is
vb
has
a
special
way
of
doing
things
and,
if
you're
a
vb
programmer,
you
probably
don't
even
know
how
that
works
behind
the
scenes.
So
let
me
just
explain
a
couple
of
things
that
we
do
here
so
one
of
which
is,
if
you
say,
show
off
files.
The
my
project,
node
expands
into
having
more
interesting
things,
and
the
high
dpi
is
just
a
temporary
thing
in
the
nightly
build.
B
But
in
behind
this
there's
a
file
called
my
app
and
my
app
is
what
defines
the
features
that
you
have
available,
which
you
know
if
you're
a
vp
programmer
via
the
vb1
forms
project
properties.
So
you
come
into
project
properties
and
you
set
various
things,
and
so
we're
also
super
excited
that
this
is
now
enabled
and
that,
if
you
come
down
here
and
click
make
single
instance,
that
seems
like
a
good
thing
to
click,
and
then
we
just
go
back
to
my
app.
B
Then
single
instance
is
now
true,
and
if
we
go
back
and
we
say
wait,
wait,
wait
wait.
I
didn't
really
want
single
instance.
I
wanted
that
to
be
false,
and
then
we
go
back
and
it's
now
false
right
here.
So
that's
super
exciting.
For
us
there
was
a
lot
of
work
done
to
get
to
get
there.
The
vb
demos
are
a
little
bit
of
a
anticlimactic,
because
for
us,
what
we're
trying
to
do
is
make
these
new
these
these
things
that
are
special
to
vb
that
have
not
worked
in.net
core
work
in.net
course.
B
So
it's
it's
these
kinds
of
things
that
are
kind
of
a
smush
individual
studio
that
we've
been
working
on
and
the
other
thing
is
yes,
we
did.
I
just
did
show
true
and
false
on
single
instance,
I'm
not
actually
going
to
run
a
single
instance
app,
but
we
do
expect
that
visual
basic
on.net
core
will
have
single
instance.
If
you
want
it
for
c-sharp,
you
should
definitely
ask
for
it
and
a
single
instance
at
means.
B
If
you
don't
know
that
when
the
application
starts
up,
it
looks
for
previously
existing
instance
of
the
same
application,
and
if
it
finds
one
it
says
well,
wait.
You
can't
start
another
one
and
passes
whatever
you
had
as
command
line.
Whenever
you
were
passing
into
the
instance,
you
were
trying
to
start.
B
That
goes
into
a
special
event
on
the
instance
it's
already
running,
and
so
that
allows
you
to
behave
in
the
same
general
way
that
an
old
mdi
app
would
have
done
when
back
in
the
day,
when
word
would
be
one
application
that
would
just
open
new
new
pages
that
it's,
that
kind
of
behavior
which
now
you're
pro
you
may
not
be
doing
an
mdi
app,
but
you
may
be
using
that
feature
to
keep
perhaps
a
service
from
being
started
more
than
once,
or
some
other
reason
that
you
want
to
have
only
a
single
instance
running
so
we're
working
on
that
and
some
of
the
stuff
we
definitely
have
work
to
do.
B
I'm
definitely
definitely
a
little
nervous,
but
we're
still
we're
working
on
getting
vb.
There's
an
awful
lot
of
things
do
work
today
we
definitely
have
some.
We
definitely
shot
some
bugs
and
so
we're
we'll
be
working
on
those
and
that's
kind
of
the
status
of
db.
And
yes,
I
do
care
about
vb.
Somebody
says
thank
you
for
caring
about
vb.
Yes,
I
do
care
about
vb.
I
I
care
about.
B
I
care
about
a
lot
of
things
and
you
all
that
use
our
tools,
you
care
about
vb,
you
care
about
other
things
too,
and
that's
why
I
I
also
personally
like
vb,
but
it's
the
folks
out
there
and
we
think
the
best
thing
for
folks
out
there
is
to
take
vb
into
net
core.
B
But
we
have
absolutely
not
deprecated
visual
basic
and
the
fact
that
we're
slowing
the
language
down
right
now
is
is
caused
some
confusion
on
that.
So
I
just
want
to
say
every
chance
I
get.
No,
we
have
not
deprecated
vb
we're
investing
in
it.
We're
making
these
investments
we're
making
investments
every
time
you
get
a
new
version
of
visual
studio.
B
You
may
not
even
notice
it,
but
you've
got
more
features.
It
just
works
better
and
that
almost
all
most
new
features,
most
new
code
fixes
and
analyzers.
Most
of
that
is
created
for
both
visual
basic
and
c-sharp.
Just
as
a
matter
of
how
microsoft
does
things
and
so
yeah,
that's
where
we
sit
right
now
with
visual
basic
and
I
just
wanna
check
and
see
if
anybody
else
has
anything
on
vb
before
we
see
what
else
we
want
to
talk
about
today,.
B
B
C
Yeah,
well,
I
mean
I
think,
what's
great
about
this
is
this?
Is
this?
Is
the
sort
of
stuff
that,
like
I
mean
part,
part
of
what
has
made
net
core
difficult
over
the
past
couple
of
years,
has
been
things
that
people
just
sort
of
expected
to
be
there
and
and
work
like
really
well
the
way
that
it
did
just
on.net
core
I've
been
coming
along
incrementally,
and
this
is
just
a
great
example
of
that,
where
you
know
people
can
move
to
dynacorp,
and
you
know,
at
least
for
the
most
part,
have
stuff
work.
B
There's
some
things
that
are
still
going
to
be
challenging
for
people.
So,
for
example,
you
still
have
to
worry
about
the
the
project
file
transition.
So
I'll
show
you
a
visual
basic
project
file.
We
can
now
just
double
click
to
see
it
and
the
let's
see
here
we
go
now
folks
that
are
used
to
see
sharp
are
going
to
think.
B
This
is
a
little
noisy
and
part
of
the
answer
is
yes
right
now
we're
a
little
noisy,
but
we'll
there's
a
few
things
you
can
see
here,
one
of
which
is
we've
changed.
The
way
tfm
works.
Emo
can
follow
up
on
that.
So,
instead
of
having,
if
you're
used
to
3.1
win
forms,
there
was
an
sdk
that
included
winforms
for
many
reasons,
including
to
better
support.
Multi-Targeting
we've
moved
that
into
the
tfm
the
root
name.
Space
is
a
specific
thing.
B
Some
other
things
here
are
specific
vb,
we'll,
probably
move
the
property
group
into
editor
config.
We
just
haven't
done
that
work,
yet
the
my
type,
that's
what
drives
the
magic
in
in
visual
basic
and
we
think
right
now
we're
going
to
leave
imports
in
the
project
file,
because
we
think
visual
basic
programmers
may
want
to
come
in
and
change
that
and
that
actually
having
that
visible,
is
probably
the
right
thing
to
do
for
visual
basic
rather
than
tucking
it
away
in
the
sdk,
in
which
case
you'd
have
to
exclude
one
you
didn't
want.
B
So
if
you
didn't
want
system.drawing
you'd
have
to
do
an
exclude,
and
so
we
think
that's
a
little
bit
backwards
feeling.
So
we
think
we're
probably
going
to
do
that
and
then
we're
going
to
try
to
clean
up
the
rest
of
this
stuff.
So
there
is
going
to
be
probably
in
68
there'll,
be
a
little
bit
of
messiness
in
this
and
a
few
other
places
and
then
we'll
tidy
things
up
for
69..
B
So
that's
you
know
it's
the
track
that
we're
on
but
yeah,
but
we
are
trying
to
make
it
as
easy
as
possible
to
move.
That
is
the
goal.
That
is
absolutely
the
goal.
A
A
Yeah,
so
what
you
see
there
on
screen
is
basically
our
new
target
frameworks
are
like
we
used
to
have
just
you
know:
net
one
net,
two
net
three
net,
four,
and
now
we
actually
have
net
five,
which
is
the
successor
of
dot
net
core,
slash
dot
net
standard
and
in
order
for
us
to
reason
about
like
different
operating
system
support.
So,
for
example,
if
you
target
net
5,
we
assume
you
want
to
run
everywhere.net
runs
now.
A
But
if
you
want
to
access
windows
apis
like
winforms
or
wpf,
which
this
app
is
it's
a
winforms
app,
then
you
basically
say
dash
windows,
which
basically
gives
you
access
to
to
all
the
the
window,
specific
apis
and
what's
cool
with
that,
is
that
it's
basically
very
easy
for
you
to
understand
how
compatibility
works,
so
we
don't
have
disjoint
tfms.
Now
we
have
just
tf
apps
with
suffixes.
If
you
will
so,
we
will
have
in
the
dot
net.
A
6
time
frame
will
also
support,
ios
and
android,
and
so
then
you
will
have
net
6.
You
know
net
6,
dash
windows,
net,
6,
ios,
that's
six
dash
android
and
then
it's
relatively
obvious
who
is
compatible
with
whom,
by
the
sheer
notion
that
everybody
who
shares
the
same
version
number
or
has
a
lower
version
number
is
compatible
with
the
higher
version
number
right.
So
it's
a
it's
much
easier
to
to
to
understand
that
than
it
was
with
net
standard,
because
you
had
to
understand
that
net
core
app
three
supports.
A
So
there
was
one
question
in
chat
that
I'm
not
entirely
sure.
I
understand
what
the
question
is
and
that
I
think
I
clicked
on
it
earlier
by
accident,
but
let
me
just
scroll
back
now:
jerome
was
asking:
how
has
it
been?
How
has
being
able
to
support
new
platforms.net
evolved
over
the
years?
For
example,
we
have
now
adding
apple
silicon
support
for
the
runtime,
so
I'm
not
entirely
sure
what
the
question
is,
but
I
guess
fundamentally
like
yes,
we
do
add
new
platforms.
A
I
mean
we
just
did
a
lot
of
investment
in
arm,
for
example,
so
you
can
actually
find
this
on
our
blog.
We
regularly
blog
about
it.
I
think
richard
block
posted
about
our
arm
support
that
we
just
did.
We
did
a
bunch
of
intrinsic
support
over
the
last
year
and
a
half
and
we
basically
added
apis
that
allow
you
to
access
cpu,
specific
instructions
for
all
the
different
architectures
that
we
support,
and
yes,
we
I
mean
dotnet
has
always
supported
multiple
architectures,
I
mean
even
in
the
fabric
days.
A
You
know
there's
x86
as
x64,
for
example,
and
I
think
in
the
good
old
days
you
may
have
even
supported
architectures
that
we
then
dropped
at
some
point
because
nobody
cared
about
them
anymore.
A
I
remember,
for
example,
windows
nt
had
like
weird
alpha
support
and
stuff
going
on,
so
that's
not
really
new.
I
mean
it
is
a
little
bit
easier
of
an
open
source
project,
but
I
mean
not
not
much.
Has
changed
in
that
world.
A
Yeah,
so
like
the
one
thing
I
want
to
quickly
talk
about,
let
me
actually
try
to
share
my
screen.
Let
me
try
this
hey.
It
worked
like
a
charm,
so
there's
a
new
blog
post
that
you
may
want
to
read.
It's
not
that
new.
A
It's
like
now
at
this
point,
10
days
old
almost
so
it
is
a
about
a
new,
primitive
data
type,
so
you
probably
are
now
float
and
double,
or
single
and
double,
depending
on
which
naming
convention
you're
using
and
so
a
new
type
called
half,
which
is
basically
a
16
bit
floating
point
number
and
it's
unlike
the
other
numbers.
A
A
So
it's
another
example
of
something
that
is
relatively
new
in
the
dot
net
core
world,
where
we
actually
now
add
support,
for
you
know
more
more
advanced
types
and
similar
to
intrinsics
it's
an
area
where
we
actively
push
the
envelope
and
you
know,
try
to
make
more
advanced
scenarios
easier
with
net.
A
Another
thing
I
wanted
to
quickly
talk
about
is
john
wrote,
a
blog
post
also
about
10
years
ago,
where
we
added
a
bunch
of
analyzers,
so
you
may
have
heard
of
rosen
analyzers.
A
What
we
haven't
done
so
far
is
we
have
not
shipped
any
analyzers
in
the
box,
so
they
were
all
new
get
packages
that
you
had
to
hunt
down
and
install,
and
so
one
of
the
big
changes
with
dot
net
5
is
that
we
added
support
for
a
ton
of
analyzers
in
the
box,
which
no
means,
if
you
do,
you
know,
file
new
project
and
you
create
a.net
5
app
by
default.
A
These
analyzers
are
enabled
there's
this
new
console
called
analysis
level,
which
is
basically
our
way
to
say.
Well,
regardless
of
the
target
framework,
you
may
want
to
get
access
to
more
advanced
code
analysis,
so
you
can
just
bump
the
analysis
level
to
a
higher
value,
and
then
you
basically
get
access
to
to
those
things
without
upgrading
your
tfm.
But
if
you
don't
set
any
any
any
analysis
level,
then
it's
defaulted
based
on
your
tfm,
so,
for
example,
if
you
target
net
five,
then
we
assume
the
value
is
five.
A
If
you
target
net
crap
or
older,
then
it's
basically
four
right,
and
so
this
way
we
can
add
new
warnings
to
the
compiler.
We
can
add
new
warnings
in
you
know
by
adding
custom
analyzers,
and
this
way
you
basically
have
symmetry
still
between
what
you're
building
locally
and
when
you
build
on
a
machine
with
a
new
sdk
right.
We
don't
just
want
to
magically
inject
these
analyzers
without
you
changing
something
in
the
project
file,
because
otherwise
people
are
confused
with
it
but
locally.
They
get
three
warnings.
A
They
build
on
the
ci
machine,
something
they
get
200
warnings
and
it's
like
well
what
nothing
has
changed
and
so
by
basically
saying
yeah,
it's
tied
to
the
tfm
or
you
explicitly
opt
into
a
higher
level.
It's
it's
part
of
the
project
file
of
what
you're
getting
effectively,
and
so
we
have
a
bunch
of
those
built
in
there's
a
interesting
demos
here
thing
that
he
has
down
the
road.
A
For
example.
This
was
one
of
those
things
that
we
originally
did
in
russian,
but
then
we
had
to
back
it
out,
because
people
didn't
like
that.
We
added
new
warnings,
but
basically
very
common
bug.
People
have
in
code
is
that
at
some
point
they
had
a
class
and
they
changed
to
a
value
type,
and
then
they
have
comparisons
to
null,
and
there
will
always
be
faults
right
if
you
compare
value
types
to
to
null,
that's
never
going
to
fly
so
it's
kind
of
nice
just
to
see
that
you
get
these
more
advanced.
A
C
Well-
and
I
think
what's
really
nice
about
this-
is
like
this.
This
gives
us
a
really
really
good
dial
to
be
able
to
put
in
some,
I
guess,
like
domain
specific
analysis
for
parts
of
net
apis,
especially
some
apis
that
have
been
around
for
a
while.
C
That
can
sometimes
be
a
little
bit
tricky
and,
like
ideally,
of
course
like
any
new
api
is
perfectly
designed,
and
you
know
there's
no
way
that
you
could
ever
misuse
it
but
like
the
reality,
is
that,
like
you
know,
there
are
ways
that
you
can
misuse
stuff,
and
so
we
can
sort
of
you
know,
and
we
can't
just
like
change
those
apis.
C
You
know
because
that
would
break
everything,
but
you
know
we
can
add
in
things
like
this
and
then
give
people
a
dial
to
basically
say
like
you
know
how
much
they
want
to
be
warned
with
with
that.
I
think
we
call
it
warning
waves
internally.
C
Basically,
you
sort
of
you
sort
of
say,
like
you
know,
okay,
how
strict
do
I
want
the
compiler
to
be
here
and
it's
you
know
we
kind
of
have
like
a
sensible
default
for
don
at
five
versus.net
core
three
one
and
and
and
on
a
framework
as
well,
so
that
like,
if
you
weren't
getting
all
of
these
warnings
before
then,
you
won't
get
a
whole
bunch
of
new
warnings
unless
you
explicitly
opt
in
but
for
new
stuff.
We're
gonna
continually
opt
in
with
more
of
these
kinds
of
analysis.
C
Oh
sorry,
so
more
of
these
kinds
of
diagnostics
triggering
which
I
think
is
great
like
I
think
that
so
far
it
seems
like
a
lot
of
the
feedback.
At
least
on
the
blog
post
has
been
pretty
positive
about
this
yeah.
A
I
think
that's
I
mean
it
cuts
both
ways.
Right,
I
mean
like
one
of
the
problems
is
that
we
take
compact
very
seriously
right
to
a
point
where
sometimes
it's
very
painful,
where
we
can't
do
the
right
thing,
because
the
wrong
thing
has
been
shipped.
The
problem,
I
think
in
practice,
will
be
that
you
know
finding
the
dial
whether
the
middle
ground
is,
but
I
think
we
all
convinced
ourselves
that
I
guess
adding
more
warnings
over
time
is
fine,
because
we
have
to.
A
I
guess,
appreciate
that
our
understanding
of
the
code
in
the
apis
grows
well
beyond
bishop,
when
we,
when
we
ship
those
right-
and
I
feel
like
there's-
also
this-
this
overarching
thing
that
we
also
try
in
the
bcl,
where
we
try
to
make
more
scenarios
possible,
and
sometimes
these
more
advanced
scenarios
come
with
trade-offs
right.
So
here
is
our
json
apis.
A
Then
there
are
cases
where
we
made
the
api
slower,
because
we
wanted
to
say
if
you
misuse
the
api
accidentally,
we
don't
want
memory
leaks,
so
we
don't
want
security
issues
because
you're
right
to
the
wrong
buffer,
for
example,
and
so
some
of
these
things
we
could
mitigate
by
saying.
Okay,
we
don't
do
that,
but
instead
we
basically
ship
an
analyzer
that
you
know
flags
incorrect
usage
of
an
error.
A
So
we
can
effectively
say,
like
you,
can't
misuse
the
api,
or
at
least
the
particular
thing
you
want
to
optimize,
for
you
can't
do
it
doing
correctly,
and
then
we
can
live
with
some
things
where
yeah
it's
a
some
people
might
actually
write
a
notepad
and
never
run
the
analyzers,
but
like
since
analyzers
are
part
of
the
build
process,
you
will
eventually
run
them
and
you
when
you
compile
right
and
so
the
idea
would
be
pretty
much.
Everybody
runs
the
analyzers
eventually,
and
so
we
are
okay
with
saying
yep.
A
This
api
is
a
bit
harder
to
use,
but
it's
a
high
performance
api
and
you
can't
really
misuse
it
and
I
think
that's
an
interesting
direction
for
us,
because
so
far,
the
way
we've
worked.
This
we've
thought
apis
right
and
then
that's
it
right
and
then
the
awesome
team
added
a
bunch
of
analyzers
for
the
language.
But
we
didn't
really
do
anything
for
specific
apis
and
I
think,
moving
forward.
We
will
change
to
a
world
where
my
team,
when
they
are
building
apis.
We
also
think
of
analyzers
and
code
fixes.
A
B
I
think
one
of
the
things
about
this
and
the
whole
warning
was
idea,
is
that
one
size
doesn't
fit
all,
and
you
know
projects
even
with
one
organization
and
one
programmer
for
the
same
projects.
They
don't
it's
not
one
size
fits
all.
You
want
to
go
back
to
the
code
for
just
saying,
because
there's
one
thing
I
just
wanted
to
to
point
out,
which
is
oh,
never
mind:
it's
not
the
code
that
had
the
number
in
it.
B
So
at
any
rate,
each
of
these
there
it
is
so
each
of
these
warnings
also
has
a
number,
and
so
you
also
in
addition
to
collecting
the
warning
wave,
you
can
then
opt
out
of
individual
warnings,
so
I
do
think
overall,
an
investment
in
at
least
your
active
projects
in
having
the
right
set
of
things
enabled
is
worthwhile.
So
if
you
can
meet,
you
know
the
warnings
that
we
all
give
you
great
fantastic.
B
If
some
of
those
really
worry
you,
then
you
can
kick
them
up
to
an
error,
so
you
absolutely
can't
comply
with
it
and
then,
if
some
of
them
are
things
it's
like,
you
know
what
I
really
don't
even
want
to
worry
about
that
then
you
can
set
it
down
to
information
or
totally
turn
it
off,
and
it
is
an
investment
in
that.
But
I
really
believe
that
if
that
gets
your
code
into
the
place,
that
you
want
your
code
to
be
for
that
project,
and
so
I'm
super
happy
that
we
finally
have.
B
I
think
we
have
the
dials
right.
So
we
have
this.
You
know
this
big
dial
of
the
warnings
that
come
with
the
system
and
that
we
try
not
to
make
changes
to
unless
we're
really
compelled
because
some
people
do
have
you
know
street
warnings
is
errors.
That
means
it's
a
break.
So
we're
really
careful
about
that
in
c
sharp
and
then
we
have
the
analyzers,
and
now
you
can
warning
waves,
which
is
a
set
of
analyzers,
and
then
you
can
turn
things
on
and
off
individually.
B
So
I
think
we
kind
of
have
the
right
dials
like
a
like
it.
You
know
you're
in
the
ballpark
and
then
you
know
the
big
dial
and
then
the
little
tiny
dial
for
each
one.
So
I'm
pretty
happy
about
that.
I
wish
we
could
figure
out
how
to
do
it
for
ms
build,
but
I
think
we're
pretty
on
track
for
visual
studio
things.
You
know
we
missed
two
comments
in
the
in
the
questions.
If
we
want
to
go
back
and
grab
those
now,
you
know
for
if
we
want
to
move
on.
A
When
you
say
so
yeah,
that's
that's
an
interesting
one.
So,
basically
the
idea
here
is
there
is
no
such
thing
as
a
non-existing
version.
So
when
you're
building
we
will
determine
the
version
number
that
basically,
the
idea
is
that
the
the
minimum
or
that
the
version
number
is
defaulted
based
on
basically
net
five
will
have
a
default
right
and
then
net
six
may
have
a
different
default.
For,
if
you
don't
say
the
the
windows
version
number.
A
But
if
you
look
at
net
5-windows,
no
matter
which
version
of
the
sdk
you
have,
it's
always
going
to
be
the
exact
same
version
number
and
for
night
5.
That
version
number,
I
believe,
is
7-0.
So
that
means,
if
you
don't
say
the
version
number,
it's
the
same
thing
as
saying
7.0,
it's
possible
that
in
dot
net
6,
for
example,
we
default
to
you-
know
some
windows,
10
version
number,
for
example
right,
in
which
case
that's
that's
what
it
means.
When
you
don't
say
it
now,
it's
not
the
minimum
version
number
though
so.
A
Basically,
what
what
this
version
number
here
means
is
what
api
level
of
the
operating
system
do.
You
have
access
to.
So
meaning
I
can
say,
net
five
dash
windows.
You
know
10
point
blur
to
get
access
to
uwp
apis,
but
that
doesn't
mean
that
I
can
only
run
on
windows,
10
or
higher.
It
just
means
doing
compilation.
I
have
access
to
the
windows
10
apis.
You
can
still
run
a
lower
version
of
the
operating
system.
If
you
are
guarding
your
api
calls,
and
so
the
minimum
version
number
is
a
separate
property.
A
I
think
we
just
decided
yesterday
to
rename
that
I
think
now
it's
a
supported
os
version.
I
believe
this
is
sorry
supported.
Os
platform
version,
I
think,
is
the
name
of
the
of
the
property
and
that
determines
what
you're,
what
you're
basically
saying
this.
You
know
I
want
to
run
on
that
version
or
higher
right,
and
so
that
means
the
minimum
version
might
be
much
lower
than
what
you're
targeting.
A
So
the
targeting
version
is
always
the
api
level
you
have
access
to,
and
then
the
minimum
version
number
is
something
that
is
either
the
same
or
lower
right
and
then
everything
that
is
between
this
number
and
the
targeting
number
is
the
thing
you
have
to
guard
for.
That's
basically,
the
idea.
A
Does
the
new
combined
tfm
obsolete
the
runtime
identifier
like
wind,
seven
or
you
know
wind
7-x86?
No,
so
there's
two
concepts
that
we
have
in
dot
net
land.
One
of
them
is
basically
what
you're
compiling
against
and
then
the
other
one
is
what
you're
running
against
and
so
the
the
way
this
is
modeled
in
nuget
land.
Is
that
there's
different
folders?
There's
a
ref
folder,
there's
a
lib
there's,
a
runtime
folder
and
then
there's
a
lib
folder
and
the
lib
folder
basically
unifies
runtime
and
reference
folder.
A
A
That's
not
always
the
case
right
for
the
platform,
for
example,
we
very
often
have
to
say:
well
we
give
you
one
api
set
and
that's
in
some
sort
of
reference
assembly
and
then
there's
an
implementation
assembly,
but
the
implementation
assembly
might
also
reference
some
native
code
and
the
native
code
has
to
be
compiled.
For
you
know,
of
course,
particular
operating
system,
some
particular
business,
and
we
have
to
express
that
somehow
that's
what
the
runtime
identifiers
are.
A
So
when
you
go
into
the
runtime
folder,
there's
always
a
subfolder
per
what
we
call
red
right,
runtime
identifier,
and
that
one
will
still
exist
and
the
writ
mechanism
is
very
powerful.
It
allows
you
to
express
almost
arbitrary
things.
So,
for
example,
we
have
support
for
architecture.
We
have
support
for
operating
system.
We
have
support,
for.
I
think
we
at
some
point
had
support
for
aot
versus
non-aot
as
well,
and
that's
not
what
the
tfms
are
for.
A
The
tfms
are
mostly
for
modeling
what
you
can
reference,
and
that
means
the
only
thing
we
model
here
is
effectively
the
net
platform
version
and
the
operating
system,
but
we
don't
have,
for
example,
a
tfm
that
would
give
you
different
api
service
based
on
x86
versus
x64.
We
don't
do
that,
and
that
is
a
conscious
choice,
because
random
identifiers
are
very
powerful
but
they're
also
very
complicated,
and
most
people
don't
need
all
that
power,
and
so
we
want
to
have
a
system
that
is
understandable
and
still
flexible
enough,
and
so
that's
what
we
build.
B
All
right,
so
I
don't
know
if
we've
got
more
questions
on
those
I've
got
one
in
here
on
standard.
So
hang
on
just
a
second.
A
While
you're
finding
this,
I
think
the
person
that
asked
earlier
about
the
platform
support,
I
think,
based
on
the
comments,
he
was
apparently
more
asking
whether
it
was
easier
or
harder
for
us
to
add
platforms
now-
and
I
would
say
it's
not
like
it's
not
much
easier
than
before.
It's
still
a
lot
of
work
if
you
want
to
bring
up
a
new
architecture
and
it's
easier
in
the
sense
that
it's
open
source,
so
we
have
more
people
that
we
can
work
with,
but
you
still
have
to
change
the
jit.
A
B
B
I
don't
know
what
the
best
recording
is,
the
other
one
you
might
write
it's
for.
You
again
is:
let's
talk,
about.net
standard,
2.x,
r3.x
or
whatever
you
get
standard.
I
know.
A
So
yes,
so
basically
the
way
to
think
about
this
is
that
there's
not
going
to
be
a
new
version
of
net
standard.
So
two
one
is
the
last
version
of
net
standard
effectively
and
then
net
five
is
basically
the
successor
of
that
right,
because
net
five
unifies
net
core
app
and
that
standard,
and
so
that
moving
forward,
you
will
target
net
five
and
that's
six
net
seven.
Now
as
it
is
with
the
standard,
you
generally
don't
target
the
latest
version
right
because
you
wanna
run
in
more
places,
and
so
that's
the
same
argument
here.
A
Even
though
there
is
not
a
new
version
of
the
standard
that
doesn't
mean
you
immediately
drop
the
standard
and
immediately
move
to
net
five,
because
presumably
you
still
want
to
run
in
the
same
as
you
run
today.
Exactly
if
you
have
a
net
standard
to
o
library
that
people
can
consume
from
the
net
framework,
then,
if
you
retarget
to
dot
net
five,
then
dotnet
framework
can
no
longer
reference
that
right
and
the
same
reason
why
you
wouldn't
upgrade
from
202
to
1,
because
21
also
doesn't
support
that
framework.
A
So
the
general
real
idea
with
the
standard
is
you
you
want
to
target
a
version
that
is,
you
know
basically
high
enough,
so
you
can
get
your
job
done,
have
ever
access
to
the
right
apis,
but
also
old
enough
that
you
have.
You
know
the
market
share,
that
you
can
actually
reach
with
your
library
right
the
thing
with
dot
net
five
is
we
are
fully
backwards,
compatible
right,
so,
like
there's,
absolutely
zero
reason
why
you
should
upgrade
from
that
standard
two
or
two
one
to
net
five
yeah.
A
If
your
code
perfectly
fines
perfectly
compiles
fine
with
with
dot
net
5.,
the
only
exception
from
that
is,
if
you
want
to
use
nullable
reference
types,
because
net
standard
has
no
annotations
at
so
at
all
net
core
app
three
has
some,
but
not
a
lot
and
with
dot
net
five.
We
have
pretty
much
annotated
the
entire
bcl,
so
we
have
like,
I
want
to
say,
94
or
something
annotated
so,
but
I
wouldn't
necessarily
retarget
for
that.
A
What
I
would
probably
do
is,
if
I
were
a
library
author
is,
I
would
multi-target
for
net
standard
two
and
net
five
so
that
my
code
compiles
for
net
five.
So
that's
how
I
get
my
you
know
the
confidence
that
my
annotations
are
correct,
because
I
checked
them
with
the
ones
that
ship
with
net
five
and
then
I
would
only
ship
the
net
standard
two
over.
A
That's
probably
what
I
would
do,
but
in
terms
of
like
you
know
whether
you
target
net
standard
or
net
five
from
the
consuming
standpoint
is
development
like
it's
literally
just
the
the
higher
version
of
the
same
thing.
B
All
right
all
right,
we
got
a
question
here
about
small
breaks
and
I'm
pulling
up
this
yeah
during
types
from
constraints
that
we,
you
know
this
is
hard
because
c
sharp
one
of
the
things
must
be
sharp.
Is
that
it's
a
really
strong
backwards
compatibility
stories,
so
I'm
going
to
say
the
answer
is
most
likely.
No,
unfortunately,
that
warning
waves
do
not
give
us
free
reign
to
do
that.
We
designed
them
around
kind
of
an
optional.
B
This
is
an
opt-in
kind
of
thing,
and
if
we
were
to
start
making
breaking
changes,
it
would
probably
not
fit
very
well
with
that.
So
our
expectation
is
that
we
will
it
current
expectation
is
this
does
not
open
the
gates
for
c
sharp
to
do
breaking
changes,
and
I
know
that
there's
some
things
that
both
the
team
and
individuals
would
just
really
love
if
we
could
work
on,
and
I
think
that
the
answer
is
probably
going
to
be.
B
Unfortunately,
that's
not
that's
not
what
this
is
is
that's
not
what
warning
waves
is
aimed
for,
if
we're
ever
able
to
do
that,
be
a
different
feature
and
we're
certainly
thinking
about
how
to
manage
changes
around
in
this
build.
Where
you
know
every
time
we
every
time
we
move,
we
seem
to
to
break
somebody,
and
so
we
certainly
think
about
that
problem.
But
right
now
in
nc
sharp,
it's
not
high
on
there.
B
The
other
thing
we've
got
in
here
is
our
analyzers
work
cross
language
and
most
of
them
do
so.
That's
the
that's
the
goal.
I
don't
know
about.
B
F
sharp
philip
could
speak
to
that,
but
they're
rosalind-based,
and
so
the
rosin-based
ones
pretty
much
just
pick
up
c,
sharp
and
vb
at
the
same
time
years
ago,
they
designed
operation
in
order
to
have
most
things
work
in
a
way
that
would
just
apply
to
both
languages,
so
we're
pretty
okay
and
that's
one
of
the
ways
that
vb
just
gets
better
all
the
time
and
vb
being
embedded
in
the
different
teams.
B
So
the
team
that
does
the
analyzers
and
does
the
tooling
for
net
in
visual
studio
thinks
about
vb
and
thinks
about
their
best
experience
for
vb
and
then
the
languages
you
know,
then
we
have
winforms
and
spread
out
like
that.
We
get
the
best
attention
every
place
so
yeah
most
of
them
do
not
all
of
them.
Some
of
them
aren't
appropriate
every
once
in
a
while
I'll
veto,
one
going,
that's
not
the
way,
bb
programmers
work.
Don't
do
that
one
and
pretty
much.
B
Don't
do
that
so
yeah,
because,
because
you
know,
there's
things
are
different
like
like
whether
they
import
ship
here
in
the
project
file,
the
people
that
are
into
this
extremely
minimalistic
project
file.
Don't
want
to
see
that
I'm,
like
you
know,
visual
basic
programmers
aren't
so
minimalistic.
You
know
they
they
they're
a
little
bit
more,
like
tell
me
what's
going
on,
and
so
anyway,
that
that's
that
and
vb
will
vb
get
new
updates
in
future
frameworks
as
well
as
c
sharp.
B
So
I
I
want
to
really
clarify
this
difference,
because
it's
really
confused
people.
Okay,
we
have
no
current
plans
for
language
changes.
So
that
means
that
you
know
we're
not
we're
not
going
to
get
nullable
because
nullable
will
break
everybody,
and
we
don't
think
that's
what's
good
for
vp
programmers
right
now
and
it's
it's
not
a
consistent,
there's!
No
way.
We
see
right
now
to
make
it
consistent
with
vb
and
make
it
feel
like
part
of
vb.
So
language
changes
like
that.
B
They
are
not
on
the
agenda
better,
better
visual
studio,
behavior
winforms,
you
know
coming
up
to
speed
wpf
places
that
we
support
the
places
where
the
underlying
platform
can
be
supported.
Unfortunately,
we
don't
have
plans
for
asp.net
right
now
we
can
do
web
api.
B
You
can
do
it
fairly
well,
and
we
may
even
you
know,
have
some
improvements
there
like
trying
to
get
templates
which
are
harder
than
you
think
it
is
to
get
those
there,
but
we're
not
gonna
have
a
razer
engine
and
that
does
cut
out
some
of
the
scenarios
and
that's
unfortunate
that
that's
where
we
stand-
and
I
do
want
to
give
you
guys
the
most
honest
information
I
possibly
can
about
visual
basic,
because
I
think
that
it's
the
right
place
for
a
lot
of
people
to
be,
but
I
don't
want
people
to
either
move
away
from
bb,
because
they're
scared
for
the
wrong
reasons
or
be
on
bb,
with
hopes
that
we
probably
can't
realize
or
don't
plan
to
realize.
B
A
Cross
language
thing
so
the
analyzers
themselves
are,
you
know
in
the
resin
world
agnostic,
with
respect
to
c
sharp
versus
vb
it's
more
around
when
you
do
fixers,
where
you
actually
have
to
deal
with
the
language
syntax
a
little
bit
more
and
on
the
bcl
side.
Yes,
we
try
to
make
every
analyzer
have
a
fixer
if
that
makes
sense,
but
I
think
this
release,
we
did
not
do
a
great
job
with
that.
I
think
there's
still
a
bunch
of
fixes
we
need
to
add.
A
But
yes
the
idea
there
is
that
we
generally
test
all
the
analyzers
for
both
languages
and
browsing
does
a
good
job
of
abstracting
that,
for
the
fixes,
it's
a
little
bit
more
work,
but
also
not
much
more
because
you
know
vb
and
c-sharp
are
very
similar
as
philip
was
heavily
shaking
his
head
earlier.
We
don't
support
f,
sharp,
because
f
sharp
is
not
on
the
rows
and
I
operation
api.
So
currently
we
don't
support
f,
sharp
of
the
analyzers.
I
think
it's
something
that
everybody
would
like
to
see.
B
B
A
So
the
thing
is
so
there's
also
something
that
confuses
people,
because
when
we
talk
about
breaking
changes,
people
seem
to
be
under
the
impression
that
we
have
a
single
breaking
change
policy
for
the
entire
product.
We
do
not
so
we
have
different
bars
for
different
areas
so,
like
I
recently
explained
this
to
a
person
in
windows
because
they
were
asking
the
same
question
and-
and
if
you
think
about
it,
it
kind
of
makes
sense
right
like
if
you
have
different
layers
of
the
stack,
you
have
more
or
less
ability
to
make
breaking
changes.
A
So,
for
example,
the
runtime
ironically,
has
more
abilities
to
do
breaking
changes,
because
in
the
runtime
a
lot
of
the
stuff
is
behavior
and
behavior.
You
can
very
often
configure
and
also
the
gc
can
make
a
lot
more
changes
that
are
more
or
less
transparent
to
the
code,
because
you're
not
really,
depending
on
the
exact
order
in
which
ggc
operates
versus
you
know,
when
it
comes
to
the
languages,
for
example.
Well,
we
really
don't
make
breaking
changes
there
like
you'd,
be
like
we
don't
change
the
way.
A
You
know
c
sharp
does
things
if
and
you
know,
silently
change
how
your
code
generates
right
b,
because
that
is
really
hard
to
reason
about
and
nobody
likes
the
idea
of
making
changes
in
the
language.
The
bcl
is
very
similar
because
the
bcl
is
not
a
language,
but
it
kind
of
is
a
language
for
the
library
ecosystem,
because
that's
the
types
you're
using
in
your
signatures,
that's
the
it's
the
things
you're
you
know
expressing
yourself
in
and
so
yes,
the
bcl
also
has
a
very
similar
breaking
change
bar
to
to
the
languages
themselves.
A
So
we
generally
don't
do
api
breaking
changes
there
either
we
will
make
behavior
breaking
changes
if
you
think
that's
in
the
best
interest
of
everybody,
but
then
very
often
we
will
at
least
give
you
a
compact
switch
to
bring
back
the
old
behavior
or
we
stage
it
out
over
a
few
releases
so
that
people
can
absorb
the
change,
but
but
the
bars
are
usually
very
high.
A
Now,
as
you
go
up
the
stack,
you
know,
winforms
wpf,
asp.net
application
models
are
a
little
bit
easier
to
reason
about,
because
there
really
isn't
usually
a
huge
library
ecosystem
that
you
would
break
by
making
changes
there
so
and
in
asp.net's
case,
for
example,
because
they
have
web
technology.
Vap
is
moving
fast
right,
and
so
you
can't
like,
if
you're
super
conservative,
then
you
kind
of
miss
the
mark
right
and
you
basically
built
it
technology
too
late,
and
then
nobody
cares
about
it
right,
and
so
they
had
they.
They
sometimes
have
to
make
decisions.
B
They're
they're
slowing
down
a
lot,
so
you
know
look
back
in
time.
It's
just
like.
Oh
my
gosh,
those
changes
not
so
much
and
we're
going
to
be
closing
up
here
really
soon.
But
I
do
want
to
comment
on
two
more
questions
that
we've
got.
First
of
all
the
runtime.
This
is
like
runtime
analyzer
specifically,
so
one
thing:
that's
not
obvious.
B
If
you're
not
don't
work
at
microsoft,
as
we
have
two
schedules,
we
have
a
schedule
for
the
net
core
sdk
and
a
schedule
for
the
dot
network
runtime
and
the
dot
network.
Sdk
updates
every
quarter,
which
is
why
it
has
goofy
numbers
and
the
network
runtime
x,
updates
once
a
year.
So
I
can't
tell
you
what
his
schedule
is
on
analyzers
and
code
fixes
for
the
runtime,
because
they
ship
in
the
sdk,
which
means
he
could
put
them
out,
but
he
may
want
to
wait.
B
A
Like
so
one
thing
is
like
based
on
the
github
discussions,
you
may
have
seen
this
already
people
ask
for
like
okay.
When
should
we
you
know,
can
I
still
contribute
this
feature?
The
answer
usually
is.
No,
so
n5
is
slowing
down
significantly,
so
everything
you
do
right
now
is
going
into
the
master
branch
or
main
branch
depending
on
the
people
we're
in
and
those
are
no
longer
merged
into
the
release
branches.
So
now
everything
that
goes
into
the
release
is
a
separate
branch,
and
we
share
a
pic.
A
You
know
based
on
various
aspects,
but
new
features
generally
going
into
dotnet
six.
Now
you
can
contribute
analyzers
like
every
like
everything
else.
I
mean
they're
in
the
dot
net,
slash
ros
analysis,
repo.
We
have
a
good
ton
of
them.
We
also
have
a
bunch
of
issues
in
the
runtime
repo
where
we
said
okay
here
you
know
we
tag
them
with
code,
analyzers
and
so
encode
fixers.
A
So
you
can
find
them
if
you
want
to
contribute
them,
but
at
this
point
very
like
basically,
nothing
goes
to
the
dot-net
five
anymore,
so
everything
is
going
to
what
six.
B
All
right,
so
we
have
somebody
asking
about.net
six.
We
can't
open
that
except
to
say
that
you
know
we've
already
announced
that
that's
what
we
pushed
xamarin
into,
not
because-
and
I
say
that
not
because
we
can't
talk
about
it,
but
because
a
we
don't
know
yet
we're
still
trying
to
finish
five
and
yeah
b,
because
we're
out
of
time
we're
out
of
time.
We
we
need
to
stick
to
stick
to
our
schedule
today
and
phillips
already
left,
because
we
want
a
minute
to
prep
the
next
meeting.
We're
in.
B
I
know
he
goes
first,
so
I
can,
if
I
can
wait
just
a
minute
so,
but
I
am
gonna
have
to
run
because
I
don't
wanna
be
rude
to
to
my
next
meeting
where
schedule
just
backed
back
on
two
two
to
like.
B
A
I'm
I'm
revving
up
now
as
well.
Actually,
the
only
thing
I
would
say
is
like
for
dotnet
6.
We
do
have
already
posted
some
issues
with
like
things
you
want
to
do
and
we
probably
will
publish
so
you
will
get
more
details.
As
kathleen
said.
D
A
There's
still
documents
being
passed
around
though
it
will,
it
will
happen
all
right,
so
I
think
this
is
it
for
today.
I
hope
you
enjoyed
it,
and
then
I
see
you,
I
think
in
three
weeks
I
would
say
all
right.