►
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
Okay,
you
know
we're
no
life
if
I
press
the
right
buttons
and
hopefully
my
mic
works
today.
Cuz
I
didn't
get
the
big
one.
I
get
the
small
one,
because
I
tend
to
sports
to
talk,
pass
the
mic
every
single
time,
so
they
start
with
introductions.
They
sat
on
the
my
right-hand
side,
your
left
hand,
side,
Richland,
er,
I,
work
on
done
at
run
time,
I'm,
Elaine,
Grove,
I,
work
on
the
net
neck,
Library
side,
I,
guess,
Phillip,
Carter,
I,
work
on
f-sharp
and
daughter
languages.
A
A
This
is
a
great
opening,
so
it's
a
day
we're
doing
our
languages
in
one
time
a
community
stand
up,
so
you
can
ask
any
questions
about
languages,
the
runtime,
the
framework
side.
You
know
donate
five
like
we'd
known
as
a
bunch
of
stuff
had
built
or
a
glass.
We
already
talked
a
little
bit
about
what
the
build
announcements
were.
I
talked
for
I
think
15
minutes,
but
I
got
the
impression
that
people
would
like
to
see
more
stuff
and
us
more
India.
You
know
detailed
questions
so
feel
free
to
ask
on
YouTube
twitch
thing.
D
A
D
B
A
What
are
we
gonna
talk
about,
so
what
I
had
in
mind
is
like
you,
just
do
a
quick
summary
of
what
happened
at
building
in
so
they
don't
because
I,
don't
anybody
watched
last
week
and
there's
some
small
features
that
mark
maybe
we're
for
talking
about.
So
how
about
we
start
with
the
with
the
big
elephant,
the
room
if
I
find
the
right
button
again.
C
A
D
A
So
in
this
post,
if
you,
if
you
haven't,
read
it
yet,
the
key
summary
is
that
should
not
be
surprising
for
most
people
who'd
follow
us,
then
most
of
our
investment
goes
towards
dominant
core.
We
have
already
slowed
down
over
the
last
years
that
shortened
on
a
framework,
and
basically
this
post
just
reaffirms
our
position
on
this.
One
and
infirmary
is
still
supported
and
you
will
support
it.
Basically,
as
long
as
Windows
is
supported,
which
is
to
say
a
very
long
time,
and
so
basically
that
means
all
new.
C
A
D
A
I
mean
we
talked
a
little
bit
about
what
our
bar
is
I
mean
we
will
still
make
fixes
to
it,
and
sometimes
it
may
even
include
feature
work,
but
the
future
work
will
only
be
from
the
lens
of
like.
Is
this
required
to
keep
existing
apps
working
right?
It's
for
the
example
of
us
comes
up,
is
TLS
1.3
and
if
there's
a
1.4
1.5
anything-
and
it
would
probably
have
to
do
something
to
make
sure
that
apps
can
still
couldn't
continue
to
connect
to
service
of
the
right.
D
B
Certainly
from
the
F
sharp
perspective,
dotnet
cord
has
been
the
future
of
net
for
a
while.
That's
where
we've
almost
put
like
pretty
much
every
single
innovation
and
we've
pretty
much
frozen
dotnet
framework
based
tooling
for
sharp
and
we're
gonna
be
pushing
that
even
even
harder
I
mean
I.
Think
the
the
upcoming
version
of
F
sharp
is
not
going
to
be
tied
to
dotnet
core
in
any
way.
Just
because
we're
not
actually
going
to
be
shipping.
B
C
Contrasting
with
F
sharp,
like
C
sharp,
actually
now
does
have
features
which
will
only
work
on
or.net
core
compatible
runtimes
like,
for
instance,
default
interface
methods,
and
that's
something
where
we
talk
about
where
we're
not
going
to
do
as
much
innovation
in
the
desktop
framework.
This
was
a
fairly
significant
feature
for
the
runtime
to
uptake
and
that
doesn't
kind
of
meet
our
bar
going
back
to
desktop,
and
so
this
is
a
feature.
That's
only
gonna
work
on
top
net
core
and
I
still
upset
like
I.
C
Imagine
that,
as
we
kind
of
move
forward
in
c-sharp
we're
going
to
see
more
and
more
of
that,
if
you
look
at
the
types
of
things
that
we
are
considering
for
c-sharp
9,
for
instance,
we've
done
a
lot
of
talking
about
like
new
primitive
types
like
some
like
half
floats,
double
floats,
Nate
events,
things
like
that.
Some
of
these
things,
like
they're,
only
going
to
work
on
dotnet
cork,
there's
just
no
feasible
reason;
no
feasible
path
for
them
back
into
the
framework
and
I.
Think.
C
If
you
look
further
and
further
out,
you're
gonna
see
that
that
needle
is
moving
more
in,
that
direct
yeah
I
think
the
last
time
we
bumped
the
runtime
for
language
work
was
would
be
right.
2005
the
generics
is
basically
the
last
big
one.
There
was
a
small
bump
when
we
did
Nokia
embedded
Interop
types.
There
was
a
small
little
bump
in
the
run
time
for
that,
but
that
is
fairly
minor.
Yeah.
D
C
D
So
I
mean
some
people
might
be
I
mean
there's
kind
of
two
ways
of
I.
Think
interpreting
this.
This
change
in
strategy,
one
is
like.
Oh,
you
know,
I'm
a
done
to
framework
user,
so
I'm
less
than
pleased
that
I'm
not
getting
these
features
and
they're
in
the.net
implementation.
That
I'm,
using
the
other
view
of
it
is,
is
like.
D
Oh,
my
god
look
at
how
much
you
know
new
work
and
new
innovation
and
new
features
collectively
across
you
know
language,
runtime
and
framework
that
were
able
to
do,
because
we
can
only
because
we
can
focus
just
on
done
at
core
going
forward.
So,
if
you're
under
core.
This
is
amazing
news,
because
we're
able
to
unlock
a
ton
of
value
and
also
make
much
more
aggressive
changes
than
we
traditionally
made
on
done
a
framework
exactly.
C
Oh,
let's
go
find
that
bad
law
backlog
of
ideas
that
we
all
kind
of
threw
in
the
trash,
because
we
knew
the
runtime
would
never
change.
And
now
it's
it's
like
getting
those
ideas
back
on
the
table,
getting
kind
of
our
mind
and
hey.
Let's
go
talk
to
the
runtime
people
they
can.
They
can
actually
help
us
like
move
forward
now
and
we
can
actually
do
better
optimizations,
better
code,
gen
so
well,.
C
C
A
D
Rich
yeah
totally
so
this
one
is
introducing
done
in
five,
so
this
is
basically
saying
what
the
next
version
of
donek
or
is
going
to
be,
and
we
are
going
to
like
if
you
think
about
the
dinette
core
300
release,
we
took
the
remaining
set
of
kind
of
dinah
framework
functionality
that
we
thought
was
a
good
idea
to
put
on
down.
Of
course,
those
WPF
and
Windows
forms.
That's
the
3-hour
release.
D
The
5.0
release
is
basically
taking
all
the
xamarin
workloads,
so
that's
primarily
mobile,
but
also
some
gaming
stuff
and
making
that
work
in
the.net
core
ecosystem
as
well.
So
that's
one
piece
of
it.
The
second
piece
of
it
is
all
net
projects.
Now
we're
going
to
have
a
single
personality,
we're
going
to
use
SDK
style
projects
for
everything.
Donna
tools
on
the
command
line
will
work
for
all
projects
and
then
also
you'll
have
a
choice
of
two
different
runtimes
to
use
either
the
you
know
core
co,
large
it
oriented
runtime
or
the
mono
äôt
runtime.
D
So
if
you
wanted
just
like
single
XE
native
code
distribution
and
so
yeah,
that
that
will
give
you
a
lot
of
choice
and
we
feel
like
moving
forward,
this
will
be
a
great
story,
so
it
will
allow
us
to
kind
of
more
readily
compete
in
more
more
spaces.
The
other
thing
is
like
up
until
now,
like
the
mano
xamarin
products,
we're
using
kind
of
this
a
bit
of
some
of
core
effects,
but
also
some
parts
of
their
own
code,
and
so
now
we're
just
gonna
be
using
core
FX
for
literally
everything
going
forward.
D
So
it
means
you
will
get
the
exact
same
behavior
by
construction
for
all
apps.
So
we
think
this
is
a
major
step
forward
and
we're
planning
to
a
little
deliver.
The
dotnet
5
project
in
November,
2020
and
I
just
want
to
answer
one
question
that
has
constantly
come
up,
which
is
it's
like.
Oh
you
know,
if
I
have
a
done,
a
framework
project
can
I
just
like
flip
something
and
then
I'll
be
able
to
target
done
at
5
and
the
end.
The
answer
is
no.
You
should
think
of.
D
If
you're,
starting
from
dotnet
framework,
you
should
think
of
targeting
done
at
5
in
exactly
the
same
way,
is
you
think
of
targeting
done
at
core
3?
Oh
because
we
don't
intend
to
bring
any
additional
dotnet
framework
functionality
in
the.net
5
timeframe,
so
it's
gonna
be
the
same
as
done
in
cor
3
Oh
from
that
particular
perspective.
So
you
have
to
do
a
manual
porting
exercise,
but
it's
gotten
so
much
better
since
the
early
days
when
it
was
it
wouldn't,
was
quite
challenging,
mostly
because
of
bad
decisions.
You
made
yeah.
A
Go
back
to
the
Franken
before
of
the
of
the
frameworks
that
we
have
today,
like
I
mean
if
you
look
at
the
evolution
of
the
of
toniest
and
a
portable
class
levels,
it's
kind
of
like
showcasing.
You
know
the
fragmentation
that
we
had
and
you
know
we've
worked
really
heavily
with
everybody.
You
know
that
it
doesn't
work
for
Microsoft
like
the
German
guys
before
we
acquired
them
the
unity
people,
and
we
really
try
very
hard
to
remove
this
notion
of
patching
this.
You
know:
inconsistent
world
view.
A
I
really
wanted
to
get
everybody
on
the
same
board.
That's
what
we
did
the
standard,
but
it's
more
like
a
you
know.
B
standard
is
still
useful
when
you
think
of
you
have
different
implementations
and
now
we're
base
is
saying,
but
wouldn't
it
be
nice
if
we
actually
had
unified
implementations,
so
they've
been
you
submit
EPR
and
it
gets
accepted,
it
basically
lights
up
next
time.
Somebody
just
produces
a
bill.
Rather
then
somebody
has
to
take
the
day
API
and
copy
and
paste
it
somewhere
else
right.
A
The
one
thing
I
wanted
to
comment
on,
though,
because
I
have
a
conversation
with
some
people
and
it
seems
to
be
a
lot
of
doubt
and
the
community
about
whether
we
can
do
this
at
all,
which
surprises
me
a
little
bit
because
they
basically
said
like
you
know.
You
have
talked
about
this
for
a
long
time
and
it
never
happened
and
I
don't
quite
understand
that,
because
if
you
look
at
the
the
actions
limitation
today,
we
look
at
mano,
they
actually
do
copy
and
paste
effectively.
A
A
And
so
I
think
the
from
our
point
of
view
there
you
have
prototypes
working
where
they
basically
take
or
FX,
take
the
mono
runtime
and
throw
them
together
and
have
things
food.
So
it's
not
like
this
pipe
dream
that
somebody
you
know
scribbles
on
the
whiteboard.
This
is
actually
big
by
actually
engineering
plan
and
you
know
actual
tangible.
C
D
I
also,
don't
think
that
we
claimed
so
we've
published
lots
of
diagrams
look
very
similar
to
this
in
the
past.
Yes,
so
maybe
there
was
some
confusion
and
I
I
definitely
apologize
if
that's
the
case,
but
the
thing
that
we
are
proposing
to
do
in
this
done
at
five
chamber
time
frame.
We
actually
never
said
before
that
we
were
trying
to
do.
This
is
fundamentally
a
new
plan
that
I
think
is
quite
dissimilar
from
anything
we've
done
in
the
past
and
what
we
have
said.
A
In
the
past
is
basically
trying
to
unify
and
more
stuff,
but
it
what
all
unification
was
by
shape.
It
was
never
by
implementation
and
I.
Think
that's.
The
lesson
learned
for
us
is
that
it
makes
more
sense
to
unify
implementation,
because
if
you
look
at
Tyson,
for
example,
they
did
not
fork
the
code
base
and
wrote
their
own
version
of
them
that
they're
not
into
core
FX
as
binaries
and
they
put
their
own
stuff
on
top.
So
it's
a
fairly
successful
model
for
us.
Well,.
D
A
A
D
I
mean
I
think
the
basic
point
here
is
couple
things
one
is
we
haven't
had
uniform
schedules
so
like,
for
example,
I
love,
the
Ubuntu
project,
because
they
ship
every
April
and
October,
and
every
second
April
is
an
LTS
release
in
it.
For
them
it
happens
to
be
the
even
years.
So
it's
it's
really
easy
to
reason
about
that
as
a
downstream
user
who
bun
too
so
we're
actually
adopting
something
very
similar
here,
which
is
we
intend
to
ship
at
least
every
November.
A
I
mean
the
dates
are
also
not
really
a
surprise.
If
you
consider
Microsoft
Kinect
conference
that
we've
basically
done
since
Donna
Corby
one,
so
we
basically
always
had
releases
aligns
with
them,
but
we
never
really
made
official
statements
about.
This
is
the
timeframe,
and
this
is
what
you're
getting
right.
So
that's!
So
it's
mostly
codifying
what
we
already
do,
but
base
is
setting
expectations
for
everybody.
I
think
is
a
good
thing.
Yep.
E
C
D
C
Is
definitely
and
that's
something
we're
gonna
continue
in
the
future
like
today,
if
you
actually
download
like
Visual
Studio
2019,
c-sharp
8
is
there,
but
it's
in
preview
mode.
So
it's
we're
actually
shipping
the
new
compiler
and
the
new
features,
but
we
essentially
have
everything
turned
off
unless
you
have
opted
into
the
dotnet
core,
previews
and
you're,
targeting
the
core
3,
oh
and
I,
think
going
forward.
D
C
Exactly
and
what's
actually
really,
nice
is
by
tying
it
to
us
and
allowing
us
to
have
this
little
preview
bridge
like
we're
frankly,
very
excited
about
that,
because
it
answers
a
question
that
we've
had
for
a
long
time,
which
is
how
do
we
get
new
versions
of
language
out
there
to
the
most
people
before
RTM,
so
that
people
can
essentially
just
set
a
flag?
Try
some
things
out.
Give
us
feedback.
Tell
us
what's
good
about
this.
What's
bad
about
this,
and
we
can
iterate
fast
right.
C
A
Let's
look
at
some
questions
because
there's
some
things
it's
a
bit
all
over
the
place,
but
I
think
that's
just
the
nature
of
questions.
One
question
is
very
specific.
Does
concurrent
dictionary
get
add,
get
our
add
methods?
Is
that
threat
safe
or
not
like
I
just
reassured?
The
idea
of
the
method
is
to
be
atomic,
at
least
right,
so
that,
depending
on
what
you
mean
by
that
I'd,
say
I.
C
Assume
that
they're
I
assume
that
the
user
there
is
referring
to
the
overload
which
takes
a
delegate
because
concurrent
dictionary
in
general,
is
always
data
safe,
like
you
can't,
there's
no
way
to
call
the
methods
on
dictionary
from
a
bunch
of
different
threads
and
corrupt
the
internal
data
structure.
That's.
C
That's
the
entire
purpose.
The
getter
add
method,
though
one
overloads
takes
essentially
a
delegate
which
produces
the
eventual
value.
I
believe
the
question
is
whether
or
not
that
is
called
one
time
or
multiple
times
I
see,
and
my
understanding
is
that
delegate
can
be
invoked
multiple
times,
but
I.
It's
pretty
clearly
documented.
If
you
check
the
docs
on
them.
D
A
I
mean
it's
not
gonna,
I.
Think
the
question
is
what
cocaine
you
rot
in
a
delegated.
You
may
have
to
assume
your
code
is
not
atomic
right.
So
then,
like
if
you,
if
that
violates
your
thread
safety,
then
that's
bad,
but
I
think.
The
idea
of
this
is
basically
you
produced
a
value
which
means
a
lot
compare
exchange
or
something
along
those
lines.
And
then,
if
you
know
we
may
have
to
call
the
add
method
again.
Yes,
sorry,
the
factory
method
again
will
DIMMs
be
in
different
methods.
A
A
D
A
Discussion
that
we
have
right
now
is
that,
so,
if
you
look,
if
you
look
at
them,
there's
only
two
aspects
to
it.
One
of
them
is
if
I
compile
against
net
standard.
What
the
compiler,
let
me
offer
my
own
dims,
all
right,
that's
one
X,
but
the
other
thing
is:
would
we
use
dims
within
the
standard
itself,
I
goobie
actually
define
before
members
or
interface?
That's
right.
We
really
know
the
answer
to
the
second
one.
Second,
one
is
going
to
be
no
like
this
release.
A
It
will
not
do
any
of
that
work,
probably
because
there's
no
plan
to
do
that,
but
the
first
one,
basically
we
will
be
okay-
could
be
considering
allowing
you
to
do
that,
and
that
is
mostly
a
function
of
like
okay.
Can
we
get
all
the
runtime
people
that
the
implement
net
standard
to
agree
that
oh
yeah?
If
the
compiler
lets
you
create
those
of
your
cave
of
loading,
that
code
successfully
right
and
there's
some
disagreement
around
that
nature
right
now,
I
think.
D
Right
so
my
understanding
from
overhearing
some
of
these
conversations
is
it's.
These
concerns
have
relatively
little
to
do
a
scheduled,
meaning
about
getting
a
certain
amount
of
work
done
in
a
in
a
certain
timeframe.
It's
more
about.
We
haven't
quite
kind
of
navigated
through
all
the
potential
bad
things
that
could
happen
right,
yeah,
so.
A
A
Chattering
yeah
is
that
what
they
should
look
on?
Well,
there's
the
diamond
thing,
and
then
there
is
the.
You
know:
I
think
that
the
I
think
the
question
that
most
people
have
is:
what's
the
scenario
for
it
and
one
of
the
key
drivers
for
us
was
better
interruptive
Java,
where
basically,
they
used
dims
in
the
same
way
that
you
know
we
ended
up
using
I,
guess
extension
methods
on
our
interfaces
right.
So
it's
a
pretty
heavy
use
on
there
and
compared
on
our
side.
A
B
The
F
sharp
side
we're
planning
on
for
the
Donna
core
3
release
to
be
able
to
consume
in
dims,
but
not
actually
produce
them.
We
don't
feel
that
producing
them
is
like
in
line
with
the
goals
of
that
sharp,
but
you
know
we're
kind
of
open
to
feedback
on
that.
We
just
want
to
make
sure
that
if
we
see
when
we
don't
explode,
that's.
A
A
D
It
was
nice
working
with
you
guys.
I
would
suspect
that
you
know
many
of
these
tools
and
visual
Studios.
An
example
of
this
will
continue
being
primarily
Dyna
framework
oriented
yes
until
they
actually
make
some
kind
of
a
significant
announcement
about
being
more
dotnet.
Corian
did
so
I,
don't
think
we
I
I
certainly
haven't
talked
to
that
team
about
a
big
switch.
A
True,
though,
is
that
if
you
look
at
the
the
larger
partners
like
SharePoint,
Exchange
and
all
the
other
ones,
that
are,
you
know
pretty
sizable
in
in
terms
of
lines
of
code,
almost
all
of
them
already
talked
to
us
about
porting
parts
to
donate
core,
if
not
all
of
it,
so
that
it's
so
it's
more
like
a
function
of
win
against
motive
will
be
my
guess,
sure,
yeah
exercise,
I,
don't
even
know
what
it
is.
I
know.
E
D
A
B
Serp
is
generally
I
mean
you
you
can
it's
just
you
have
to
register,
I
mean
you.
Have
you
wouldn't
use
F
sharp
records?
He
would
use
a
class
the
way
that
you
would
do
it
in
c-sharp,
but
keep
in
mind
there's
no
like
proper
UI
support
for
that
like
or
rather
I
should
say,
there's
no
proper
designer
support,
so
I
mean
my
advice.
If
you're
doing
anything
with
WPF
is
you
do
it
with
c-sharp
and
you
call
in
to
f-sharp
code?
If
you
want
user.
C
C
B
D
B
So
that's
and-
and
you
know,
if
you're
not
if
you're
fine
with
no
designer
support,
then
you
could
absolutely
do
that
in
F,
sharp
it's
just
it's
generally
easier
to
do
it
with
a
class.
There's
also
a
question
about
new
when
you
I
I,
don't
really
know
what
the
new,
when
you
is,
because
I
wasn't
paying
attention
for.
B
C
C
B
More
templates
are
out
into
the
studio,
719
short
answer:
I,
don't
know
whatever
they
arrived
yeah
it's,
but
it's
not
a
top
priority
for
us
at
this
time.
Some
of
the
templates
are
set
up,
but
there's
still
more
work
on
the
edge
of
functions
to
Lang
site
to
make
it
a
good
experience
like
you
can
plop
some
of
that
individual
studio
today,
but
it
would
not
really
be
that
good,
so
I
think
it's
better
to
just
not
have
it
in
visual
studio
as
a
fountain
to
experience
until
it
totally.
D
B
A
point
where
it's
good
enough,
yeah
we're
we're
confident.
Yeah
I
mean
like
even
use,
F
sharp
itself,
but
it's
basically
like
they
within
their
tools.
They
they
don't
have
a
way
to,
like
add,
add
a
new
file
to
an
item
group
yet
and
like
that.
Basically,
the
project
system
can
do
that,
but
the
other
functions
tools
can't
yet,
and
so
that
needs
to
get
solved
because
fight
learning
matters
and
so
I,
without
that
it's
sort
of
like
in
a
weird
state,
and
so
we
don't
want
to
put
that
in
visual
studio
at
that
time.
A
C
Yes,
so
if
you
actually
like,
we've
made
a
couple
of
changes
on
how
cancellation
works
for
I
a
sink
and
numerable
I,
don't
remember
the
exact
issue.
But
if
you
go
to
c-sharp
playing
and
you
look
for
the
async
enumerable
proposal,
we're
pretty
careful
to
link
all
the
language
design
notes
which
relate
to
it.
If
you
look
at
the
most
recent,
one,
it'll
have
all
of
the
like
crisp
details
and
what
we
did
for
async
enumerable,
but
in
summary,
what
it
comes
down
to
is
kind
of
on
your
iterator
methods
on
your
async
iterative
methods.
C
Now
you
can
mark
a
cancellation
token,
as
I
want
to
take
this
and
give
this
to
every
enumerator
separately
and
that
we
will
then
the
compiler
will
do
to
work
through
the
work
to
kind
of
combine
that
at
the
for
each
time
to
make
it
all
work.
The
details
are
a
little
bit
hairy,
which
is
why
I'm
not
getting
into
them.
D
Definitely,
no
that
would
sit.
Okay,
yeah
I
mean
one
of
the
things
that
we
find
is
the
level
of
variance
in
the
amount
of
context
people
have
is
is
very
high,
yes
yeah,
so
you
know
you
talk
to
one
person
and
they
basically
know
everything
in
more
than
you
and
then
you
talk
to
another
one
and
it's
like
oh
yeah,
Evan
Ben,
the
internet
in
a
few
years,
so
I'm
just
catching
up,
bring
me
up
to
speed
and
I
don't
mean
that
in
a
negative
way.
It's
just
it's
very
varied.
The.
A
Problem
is
that
just
asked
a
question
on
geo
cities
right
so
nobody's
know
so
yesterday,
I
think
was
yesterday
last
week,
I
think
there
was
somebody
paying
us
on
Twitter
and
asked
a
question
that
I
think
never
came
up,
and
that
goes
back
to
context
that
person
basis
said
so.
My
boss
wants
to
know
whether
I
can
install
donate
core
and
botnet
family
on
the
same
machine.
Are
you
saying-
and
you
know
fullscreen
on
speakers-
we
don't
need
the
schedule
anymore.
Oh
I
see
what
a
thing.
A
I'm,
like
we're
not
talking
about
Rich's
personal
tea
consumption,
no,
the!
So.
The
question
basically
was
that
it's
not
net
core
in.net
framework
and
I
saw
them
safely
on
the
same
box
and,
and
they
said
well,
there's
no
official
documentation
and
what
we
never
wrote
any
because
that
never
occurred
to
us
as
a
thing
to
officially
say,
because
it
seems
very
obvious
that
that's
the
safe
right.
A
D
A
D
So
so
yeah
we're
working
through
that,
but
it's
a
very
exciting
project,
there's
a
lot
of
new
ground
to
break,
because
you
know
the
way
I
think
about
webassembly
is
I,
think
about
it,
just
like
another
chip.
So
if
you
know
imagine
we
were
gonna
support,
arm
128,
but
I
think
about
it
in
the
same
way.
So
it's
basically
webassembly
is
a
32-bit
chip
that
can
can
run
in
lots
of
places,
but
it's
specifically
in
the
in
the
browser.
So
that's
that's
the.
D
D
Totally
like,
for
example,
one
of
the
things
we're
doing
is
we
do
have
support
in
the
dock.
What
it's
proposing
it
by
the
way
we'll
be
publishing
this,
hopefully
soon
publicly,
but
like
one
of
the
things
I
was
we
were
talking
about
is
so
we're
not
gonna
supports
a
thread
create
we
might
even
throw
in
that
particular
method,
but
we
will
support
tasks
because
that's
kind
of
necessary,
and
so,
but
we
since
there's
only
one
thread.
D
D
C
D
D
C
D
A
Why
do
you
got
money
in
a
sandbox
environment
right,
so
I
think
that
there's
some
questions
on
how
V
you
know
how
many
of
the
donator
standard
api's
will
actually
work
to
the
extent
that
we
can
just
make
them
work
right.
It's
wedding
became
probably
not
hide,
as
you
said
right,
but
hopefully
some
other
api
is.
We
can
just
make
it
work,
so
you
nice
little
special
treatment.
B
D
A
B
D
Those
two
statements
are
a
gold,
true
yeah,
like
I
I,
definitely
encourage
people
to
you
know,
make
their
own
choices,
but
I've
worked
with
a
bunch
of
big
customers
who
have
very
strict
policies
on
the
sort
of
software
that
they're
allowed
to
enable,
and
it
tends
to
be
kind
of
more
though
either
government's
or
you
know
huge
corpse.
So
we.
A
D
D
C
C
We
actually
spent
a
really
significant
amount
of
time
implementing
source
generators
and
kind
of
going
through
that,
and
what
we
end
up
finding
is
basically
that
the
compiler
support
is
in
terms
of
complexity
like
not
that
complex.
It's
actually
a
pretty
small
feature.
The
the
problem
source
generators
is
actually
getting
the
experience
right
like
right.
How
do
what?
What
the
sorcerers
do
for
the
ide,
for
instance
like
if
every
piece,
if,
if
a
source
generator,
gets
my
entire
program
as
input
to
generate
files,
then
that
means
like
on
every
keystroke.
E
C
Build
time
there
are
some
issues
with
build
time
that
we
have
to
work
out,
but
ultimately,
with
source
generators,
we
kind
of
ran
out
of
runway
and
c-sharp.
Seven
nullable
was
too
big
and
c-sharp
eight,
but
I
get
trolled
with
source
generators.
I
promise
you
at
least
three
times
a
week
every
week,
so
I'm
confident
it's
something.
We're
going
to
look
again
in
the
future.
You're.
B
B
But
like
it's,
it's
challenging
because,
like
your
intellisense,
it
depends
on
downloading
information
from
a
web
service
and
maybe
there's
some
problems
there
and
then
all
of
a
sudden,
your
intellisense
is
a
little
wonky
and
then
you
come
knocking
up.
Microsoft
Store
and
you
say
hey,
why
is
the
F
star
tooling
bad?
And
then
you
go
well
what's
the
issue
and
then
here's
the
tie
provider
and
then
sometimes
it's
fine
and
sometimes
it's
not
and
like
it's,
it's
very
complicated
to
deal
with
yeah.
D
C
A
That
was
how
I
told
your
colleague,
and
he
was
first
in
yesterday.
I
said
like
that
I
mean
this
is
fundamentally
a
hard
problem
to
solve
in
C++,
because
you
have
macros
and
templates
where
effectively
it's
a
form
of
code
generation
at
compile
time,
which
makes
it
really
hard
to
to
have
tooling.
That
is
always
correct
and
fast
and
responsive
and
like
these
things
are
just
at
some
point,
you
have
to
decide
what's
more
important
to
you
all
right
and
yeah
I.
A
C
And
then
also
when
it's
hard
to
think
about
like
the
performance
challenge,
we
have
like,
we
really
strive
to
give
users
the
most
like
correct,
intellisense
experience
possible
in
c-sharp,
but
with
source
generators
are
now
saying
that
I
have
to
have
the
output
of
third-party
code
to
make
intellisense
correct
and
like
what,
if
they're,
not
very
performant.
So
are
we
giving
like
a
kind
of
a
MIG
like,
as
Phillip,
said
kind
of
like
an
up
and
down
IDE
experience,
because
sometimes
they
produce
their
code
fast
enough
that
we
can
produce.
C
It
include
in
our
intellisense,
and
sometimes
they
don't
like,
and
that's
just
a
real.
How
do
we
make
it
so
that
the
users
aren't
just
completely
always
confused
at
what's
happening?
How
do
we
give
them
a
predictable
experience
in
a
world
where
we
can't
make
guarantees
about
how
fast
right
we
can
get
the
data.
C
B
A
Doing
it
at
build
time
is
super
hard
today
right,
but
so
like
there's
a
few
examples
that
we're
doing
the
product,
but
in
the
new
SDK
star
projects
we
no
longer
have
this
assembly
info
CS
father,
we
just
generate
the
assembly
infos
doing
build
right
and
you
can
look
at
how
that's
being
done
is
just
a
temp
cs4,
that's
generated
it's
added
to
the
clean
list
and
then
it's
injected
in
blah
blah
blah,
and
you
can
do
this
today
and
I
mean
they're
people.
Are
you
get
packages
that
try
to
automate
that
a
little
bit?
A
But
the
thing
is:
if
you
want
to
participate
in
the
bill,
there's
actually
quite
a
lot
of
work.
It's
very
error-prone.
It's
very
easy
to
get
into
states
where
things
don't
get
cleaned
up,
or
you
know
you
have
stale
output
or
whatever,
and
so
people
often
just
say
screw
it
I'll
just
do
reflection
and
reflection
in
it
at
runtime,
because
that
always
works
I,
don't
have
to
inject
any
artifacts
into
the
build
process.
But
that
fundamentally
does
not
play
very
well.
A
When
you
have
things
like
äôt
or
you
know
your
smaller
devices
or
you
know
you
just
pay,
runtime
costs
for
things
that
I
could
be
should
have
been
paid
at
design
time
already.
So
it
would
be
great
to
have
a
story,
but
but
I
think
that's
basically
the
you
know
the
concern
that
we
have
great
anyway.
So
what
was
the
question
you
said.
D
B
B
Spk
style
uses,
what's
so
both
used.
What's
call
the
project
system,
which
you
can
think
of
is
like
an
operating
system
kernel
within
Visual
Studio
that
just
manages
tons
and
tons
of
different
resources
and
that
kernel
that
is
used
for
dotnet
ACK
style,
although
is
a
lot
better
than
the
old
one
in
certain
ways
like
it's
much
more
responsive
as
kind
of
everything
is
asynchronous.
There's
some
new
features
that
are
built
on
top
of
it.
B
There's
like
20
years
of
features
and
bug,
fixes
and
just
legacy
things
that
exist
out
there,
that
the
old
one
supports
and
the
new
one
does
not.
And
so
you
know
you
can
certainly
mix
and
match
and
upend,
especially
if
you're
doing
new
stuff.
You
can
certainly
like
change
your
target
framework
to
be
dotnet
framework
and
the
new
SDK
style
stuff,
and
everything
will
probably
be
just
fine,
but
if
you're,
if
you're,
using
like
sequel
projects,
flavoring
xamarin
today
things
like
that,
it's
it's,
it
doesn't
even
support
that.
B
D
B
C
And
this
is
one
of
these
problems.
That's
not
even
it's
not
completely
within
our
control
because,
as
you
mentioned,
there's
actually
two
project
systems
under
the
hood
that
are
operating
and
Visual
Studio
is
an
extensible
environment,
and
that
means
that,
like
whenever
we
look
at
ourselves
and
say
that
hey
we
have
this
problem
where
we
depend
on
very
specific
behavior
of
this
old
one.
There
are
customers
out
there
who
write
plugins
to
visual
studios.
C
B
Exactly
and-
and
you
know
you
may
depend
on
an
extension
that
does
not
support
the
new
project
system
and
may
never
support
the
new
project
system
and
there's,
even
if
we
fixed
absolutely
everything
which
would
take
forever
but
say
we
added
support
for
every
single
capability
in
Visual
Studio
that
Microsoft
own
still.
There
would
be
a
subset
of
users
who
would
be
unable
to
work
in
that
environment,
yeah.
A
D
So
there's
another
post,
I
wrote
one
of
the
things
we've
kind
of
started
to
do
is
so
we
feel
like
we're
part
of
the
docker
community.
So
there's
a
docker
con
in
San
Francisco
every
year
and
this
year
it
was
in
April,
so
we
put
in
a
post
to
coincide
with
it
and
we
posted
on
the
first
day
just
to
kind
of
explain
what
we're
doing
to
advantage
the
docker
scenario.
D
So
this
one
is
basically
about
we've
really
kind
of
taken
this
approach
to
make
dunnock
or
a
real
container
runtime
and
there's
a
few
different
things
that
are
necessary
for
that.
So
you
can
kind
of
scroll
down
and
I'll
just
cover
the
the
the
headings.
So
one
is:
we've
moved
to
just
using
less
memory
to
by
default.
So
that's
definitely
a
good
thing.
The
other
one
is
that
you
can
specify
how
much
memory
a
given
docker
containers
should
be
able
to
use
so
I
think
the
lowest
is
like
10.
D
It's
either
like
ten
er,
yeah
I
think
it's
10
megabytes
and
go
up
as
basically
as
high
as
you
want,
and
so
the
product
now
completely
honors.
That
and
does
the
right
thing
and
we've
tested
it
below
100
megabytes
and
it
works.
So
that's
awesome.
The
next
one
is,
you
can
do
the
same
thing
except
to
CPU.
We've
done
a
bunch
of
work
to
make
sure
that
the
product
does
the
right
thing
with
the
CPU.
D
That
was
actually
in
some
ways
harder
than
the
memory
one,
because
you
have
to
think
about
things
like
the
thread
pool
and
make
sure
that
the
scheduling
that
we
have
in
the
thread
pool
has
the
right
notion
on
how
many
CPUs
are
on
the
machine
and
then
the
funny
thing
about
this.
If
you
end
this
is
what
most
of
all
those
paragraphs
is
about
is
the
with.
D
When
you
specify
the
CPU
limit
for
docker,
it's
actually
like
a
real
number
with
a
decimal,
but
the
thread
pool
is
only
oriented
on
CPUs
in
terms
of
integers,
so
we
had
to
kind
of
deal
with
the
impedance
mismatch
between
those
two
things.
Another
one
is:
we
had
a
bunch
of
people
ask
us
to
add
PowerShell
to
the
dotnet
core
SDK
images
for
like
over
a
year,
so
we
finally
did
that
we've
been
working.
D
Super
closely
with
the
PowerShell
team,
they've
been
awesome
to
work
with,
and
so
we've
enabled
that
in
three,
oh
and
I
think
oh
and
then
we
also
moved
to
on
a
Microsoft
container
registry.
That's
where
we're
pushing
our
images
now,
so
we
still
have
pages
on
docker
hub
that
tell
you
what
all
the
images
are
that
that
we
support,
but
the
registry
that
we
use,
basically
where
the
container
image
blob
storage
is
is
on
in
Azure
in
Microsoft,
container
registry
and
I
think
that's,
basically
it
so
yeah,
so
we're
super
focused
on
actually
ISO.
D
So
one
more
thing
about
this,
we're
super
focused
on
the
container
scenario.
We
had
gotten
a
bunch
of
feedback.
That
said,
you
know
we
weren't
quite
doing
what
people
wanted
and
so
that
this
work
is
for
that
and
we'd
love
to
get.
You
know.
More
feedback
based
on
3:02
tell
us
where
we're
still
not
quite
meeting
your
expectations
on
where
you
want
improvements.
So
we
are
we're
super
focused
on
that.
So.
A
Lot
of
blog
content,
but
basically
one
of
the
questions
we
get
is
like
with
the
fabric
support
inaudible,
and
that
case
you
can
see
here.
This
is
if
I
can
get
access
to
my
keyboard.
There's
like
three
PRS
right
now,
but
there's
also
this
really
really
tiny
number
here,
where
I
just
search
for
not
able.
So
we
merged
a
lot
of
PR.
So
we
basically
added
my
little
annotations
throughout
the
bcl.
A
We
will
not
have
the
whole
fabric
annotated
by
300,
like
we
focused
on
effectively
what
we
call
the
core
library,
which
is
system,
the
private
Qalamoun
implementation
side.
But
it's
like
publicly
facing
this
about
twelve
dll's
or
something
like
that.
That
basic
will
be
fully
annotated
by
trio
and,
as
you
can
imagine,
that's
a
lot
of
code.
A
A
lot
of
the
code
is
also
fairly
low-level,
which
means
you
know
we
cheat
a
lot,
so
the
type
system
has
a
hard
time
understanding
what
we're
doing,
and
so
we
took
us
a
while
to
to
actually
plumb
them
through
the
implementation.
We
could
have
just
annotated
the
public
API,
but
we
felt
like
we
don't
know
whether
the
public
API
is
correctly
annotated.
A
D
A
So
there's
a
I
think
Jerry
Falwell's
has
appeared
on
this,
but
like
basically
the
border
boys
don't
in
some
areas,
it's
kind
of
like
an
editorial
aspect
to
it
like
there's,
not
necessarily
a
clear
contra,
if
you
actually
think
of
nullable
as
a
as
a
runtime
constraint,
where
it's
like
the
true
type
system,
actually
enforces
that,
then
you
wouldn't
have
the
conversation
right,
but
the
reality
is.
Our
type
system
does
not
actually
forbid
you
to
use
analysis.
A
In
fact,
there's
many
holds
if
you
will,
but
you
can't
produce
an
ounce
and
we
don't
try
to
like
you
know,
combat
somebody
who's
malicious.
Let
me
just
try
to
give
you
an
experience
where
you
can
express
your
intent,
and
the
question
is
after
15
or
20
years.
In
our
case,
what
was
the
intent
of
object
to
string,
for
example
right,
so
we
had
a
lot
of
conversations
about
what
annotations
that
should
have,
and
you
know
maybe
we
should
go
with
that
and
I
won't
do
that
again.
Well,
it's
just
me
combating
people.
D
C
C
That's
not
a
tiny
corner
case
like
that's,
actually
a
bigger
corner
case
than
you
thought
and
I
think
when
we
get
that
feedback
we'll
have
to
take
it
in
and
make
it
make
decisions
on
it
in
society,
rinse
and
repeat,
rinse
and
repeat,
but
I
do
expect
there
to
be
some
back
and
forth
on
those
decisions
like.
If
you
look
at
the
the
questions
we
had
with
two
string
like
that
was
a
pretty
like
calm,
civil,
not
contentious,
debate
and
but.
C
D
B
A
few
dimensions
here
that
I
think
we
need
to
probably
blog
about
like
first
of
it
is
like
the
in
which
context
can
I
use
it
to
mention,
and
then
there's
the
you
know,
certainly
from
Microsoft's
perspective.
You
know
this
we're
not
typically
in
the
business
of
giving
you
more
warnings,
but
the
goal
of
this
feature
is
to
give
you
warnings
if
you're
doing
things
that
are
considered
unsafe
and
those
warnings
are
going
to
roll
out
more
and
more
over
time.
You
know,
as
more
things
get
annotated
more
things
that
microsoft
owns
get
annotated.
B
B
We're
gonna
have
to
come
out
with
broader
messaging
on
that
and
and
and
the
fact
that
even
you
know,
if
absolutely
everything
was
perfectly
annotated
in
terms
of
what
we
owned
and
what
we
shipped
they're,
still
going
to
be
late
and
adoption
from
third-party
packages
and
like
daya,
and
so
as
people
start
absorbing
that
stuff
like.
How
does
how
does
that
all
yeah.
A
I
mean
they
haven't
published
yet,
but
I
mean
our
current
line
of
thinking
is
basically
three.
Oh,
we
will
ship
and
notations
for
basically
the
bottom
stack
of
dotnet,
not
all
of
the
VCL
but
the
bottom
part
of
it,
and
then
our
goal
is
to
get
most,
if
not
all
the
annotations
in
by
500,
meaning
we
have
basically
a
year
to
get
them
in
so
within
that
year.
Basically,
we
will.
A
So
that's
kind
of
no
matter
what
time
frame
we
pick.
Eventually,
you
have
to
ship
something
stable.
That
by
definition,
must
be
incomplete
because
we
don't
own
the
entirety
of
the
dotnet
ecosystem.
Right
so,
and
we
feel
like
this
300
to
500
flee
a
year-
it's
probably
good
timeframe
to
get.
You
know
at
least
something
different
portion
of
the
ecosystem.
A
You
know
the
James
Newton
kings
of
the
world
adjacent
nets
right,
but
you'll
probably
still
have
a
very
long
tail
that
will
probably
take
probably
five
to
ten
years
realistically
to
get
everything,
annotated
right
and
some
things
evolve.
We
never
be
annotated
because,
there's
nobody's
you
know
it's
not
so.
D
C
It's
a
language
lawyer,
a
language
lawyer
question,
so
the
annotation
is
in
general
like,
for
instance,
like
you
talk
about
the
null
ability,
the
question
marks:
they
they
have
the
same
rules
as
like
Cohen
they're.
Basically,
we
allow
overriding
in
Cohen
contravariant
ways,
so
you
can
take,
for
instance,
a
method
that
has
a
string
question
returned
and
you
can
override
it
with
a
method.
It
just
returns
during
question
and
that's
just
basic
substitution
principles.
It's
you're,
making
the
contract
stronger,
not
weaker.
C
In
the
same
way,
if
you
have
a
method
which
takes
a
string,
a
normal
string,
you
can
override
it
with
one
that
takes
string
question
because
you're,
just
if
once
again
expanding
the
inputs
to
a
method
or
shrinking
the
outputs
to
a
method
yeah.
So
if
you're
familiar
with
the
rules
of
Cohen
contravariance,
you
can
pretty
much
apply
them
null
ability
and
overwriting.
So
nothing
new,
no
nothing
new
same
thing
just
apply
to
a
new
yeah.
That's
what
I
meant
yeah
and.
A
A
Without
no
send
it
to
come
out
at
the
same
time,
I'm
starting
core
three,
oh
yes
should
start
we're
still
targeting
Senate
I
think
you
will
be
asking
for
to
Oh,
be
my
guest
I
mean
don't
in
Senate
will
be
a
thing
for
a
very
long
time.
Like
we
already
said,
the
dotnet
framework
for
eight
will
still
implement
on
a
Senate
200
only
so
to
one
basically
means
you
are
effectively
only
on
the
you
know
the
dotnet
core
Bates
platform
moving
forward,
if
you
will,
but
we
don't
have
a
convert
stack
yet
right.
A
D
A
I
think
that's
definitely.
We
are
discussing
I.
Think
that
my
personal
viewpoint
is
that
eventually
we
will
stop
doing
that
standard
for
sure
the
question
is:
is
it
one
is
a
it
kind
of
depends
on
how
much
work
we
can
get
in
before
that,
but
I
think
the
idea
is
that,
even
though
we
have
a
converged
platform,
I
think
the
intent
would
be
that
that
is
the
one
that
you
just
target
right.
D
A
So
the
tricky
thing
is,
we
have
to
think
about
how
we
probably
allow
people
so
right,
bounty
of
code
right
where
they
say
a
pound.
If
iOS
I
call
some
iOS
API
upon
defender,
I
called
some
Android
API
rights
reserved
to
enable
multi
targeting
and
some
meaningful
fashion,
and
that
is
the
things
that
we
don't
well.
A
C
B
There
was
f
sharp
the
language
with
a
compiler
that
did
a
bunch
of
stuff
independently
of
Microsoft,
a
bunch
of
things
that
were
open-source.
There
was
a
big
community.
There
were
alternative
packagings
to
F
sharp
that
were
not
only
on
Windows,
and
then
there
was
a
visual
F
sharp,
which
was
Microsoft
packaging,
F
sharp
for
consumption
on
windows
through
Visual
Studio,
and
that
was
basically
it
and
there's
kind
of
historically
been
attention
there,
where
a
lot
of
F
sharp
developers
were
like,
but
I
want
to
deploy
on
an
on
Windows
machine
yeah.
B
But
for
you
know
it's
not
that
there
was
like
this
active
hostility
towards
the
idea
of
it.
It's
just
the
priorities
were
surrounded,
we're
basically
surrounding
Windows
in
Visual
Studio,
and
that's
that's
just
not
really
the
reality
for
F
sharp
anymore
I
mean
we.
We
view
windows
in
Visual
Studio
as
an
important
operating
system
and
development
environment
for
F
sharp,
but
not
the
only
operating
system
and
the
only
development
environment
that
we
care
about,
and
certainly
with
the
rise
of
dotnet,
core
and
usage
of
F
sharp
on
dotnet
core
sounds.
B
Know
it
just
it
just
kind
of
felt
weird
to
have
this
Microsoft
slash,
visual
F,
sharp
repository
when
everything
that
we
were
doing
was
sort
of
in
the
context
of
helping
F
sharp
the
language
grow
and
take
non-windows
non
visual
studio
environment
seriously,
and
you
know
not
be
like
a
Microsoft
thanks.
So
much
as
a
dotnet
thing,
and
we
felt
that
you
know
making
a
change
to
our
repository
and
being
a
part
of
the.net
foundation
was
very
well
aligned
with
that.
It's
also
less
stuff
for
me
to
type
in
a
URL.
So
I
like
that.
D
C
B
B
We
got
by
off
from
everybody
within
Microsoft
and
it
was
like
alright
it's
time
and
none
of
us
had
the
permissions
to
actually
move
the
repository
and
so
I
sent
some
emails
around
and
nobody
was
answering
so
then
I,
just
ping
Jared
and
I'm,
like
hey
Jared,
do
you
have
admin
permissions
within
Microsoft
and
dotnet
he's
like
yeah
and
YK
moved
this
repository
and
he's
like?
Ok,
I'm
glad
you're,
you're.
B
A
B
C
C
A
D
B
A
D
C
B
And
whenever
an
individual
says
oh
I'm
gonna
withdraw
some
money
because
you
know
I
say:
oh
I
want
to
pay
for
my
living
expenses.
Well,
I
do
open
source
development,
it's
a
fully
transparent
thing
like
you
get
into
every
single.
If
you're
a
backer,
you
get
a
notification
every
time.
Somebody
withdraws
money
and
you
can
see
the
invoice
amount
and
it's
it's.
Actually
it's
pretty
radical,
so
yeah,
it's
it's!
It
sounds.