►
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
B
C
D
C
A
D
F
A
A
F
A
A
So,
and
probably
some
of
you
who
have
heard
we
do
a
new
Jason,
API
and
donate
core
three,
oh
and
as
it
is
avaible,
is,
is
always
good
to
actually
get
somebody
to
try
them
and
give
us
feedback,
and
we
have
time
usability
studies.
I
think
last
time
on
the
team
a
long
time
ago
or
like
before
I
joined,
I,
read
a
book
written
by
somebody
on
the
team.
That
extensively
talked
about
the
usability
experience
that
they
had
in
the
2005
timeframe
and
they
did
the
first
derivative
study
on
their
father.
A
Our
API
is
and
I
think
Brad.
Had
this
nice
comment
ray
said,
you
know
the
first
time
somebody
tries
to
API
in
fails.
You
think
what
a
yeah
I
mean
here.
The
second
person
walking
you're
like
gee,
did
we
only
get
morons
and
then
by
the
third
or
fifth
version
you're
like
maybe
it's
not
the
person?
Maybe
it's
my
API
you're
a
person
fading
you're
like
it's.
Definitely
the
API,
oh,
but
why
are
we
such
a
bunch
of
morons
and
so
basically
what
they
had?
A
Is
they
try
it
for
ten
people
to
use
the
follow-up
you
has
to
read
files
and
ten
out
of
ten
people
failed
within
half
an
hour
to
manage
to
open
a
text
file
so
pretty
bad,
and
so
we
didn't
want
this
experience.
So
we
did
the
same
thing
with
system
TED,
Talks,
Jason
and
I
published
the
results
that
we
had
so
in
and
actually
we
gave
them
five
tasks
so
basically,
serialize
and
put
Apprendi
realized
with
training
comas
we
did
some
sort
of.
A
Like
you
know
passive
is
said:
okay,
what
a
common
error
cases
people
were
likely
hidden
me,
basically
weaves
them
into
the
experience
to
make
sure
that
people,
you
know,
hit
error
cases
we
think
are
common
and
whether
they
can
actually
recover
from
them.
You
know,
as
the
exception
message
understandable,
is
this
actionable.
All
of
that
so.
F
A
A
It's
fascinating,
though,
like
so
you
know
we
do
api's
for
living
right,
so
we
have
done
a
few
api's
and
we
felt
good
about
our
api.
One
of
the
major
feedback
that
we
got
was
that
one
of
our
key
api
is
like
the
jason
shield.
As
a
class
has
methods
to
Co
doesn't
be
sterilized,
but
pretty
much
everybody
failed
to
find
the
method
so
on
first
attempt-
and
that
was
because
our
methods
were
not
named
tziolis
and
deserialize
for
good
reasons.
A
We
thought,
but
we
named
them
read,
write
or
parts
depending
on
the
payload
and
yeah.
That
did
not
go
well,
so
there
one
of
the
things
that
we
had
to
change
so
there's
another
example
where
you're
like
that
is
probably
polymeric,
but
so
the
way
we
do,
these
studies
is
the
BBC
form
a
bunch
of
hypotheses
like,
as
in
like
here's,
what
we
expect
to
see,
and
then
you
know
in
the
study
you
actually
find
out
whether
that's
true
or
not,
I
mean
clearly
for
API
is
one
of
the
key.
A
You
know
instead
of
hypotheses,
as
people
are
able
to
use,
your
API
is
right,
but
usually
there's
more
depth
to
it
like.
How
would
we
use
the
API
is
whether
be
easy
to
use
whether
it
be
hard
to
use
you
know,
are
they
able
to
complete
the
tasks
at
all,
and
so
we
add
a
bit
more
details
here
and
like
what
we
think
people
will
be
able
to
do
them,
what
they
will
not
be
able
to
do.
A
The
other
thing
that's
interesting
is
usually
we
get
external
people
to
do
the
studies,
but
we
ran
short
on
time.
So
we
we
called
internal
people
to
do
the
study,
which
sounds
really
bad,
but
given
the
lot
size
of
our
team,
I
shouldn't
be
surprised
that
we
have.
You
know
we
found
a
bunch
of
people
who
never
used
to
Jason.
Api
is
in
the
first
place,
so
they
react.
You
know
as
good
as
any
other
external
person
would
have
been
so.
B
A
Yes
and
5
that
so
we
didn't
expect
people
to
complete
five
for
two
reasons:
one
of
them
we
kind
of
expected.
Everybody
has
time
for
5
left
in
the
60
minutes,
but
the
other
thing
is
5
is
one
of
those
examples
where
I
think
you
have
some
detail,
maybe
known,
because
it's
significantly
different
from
how
Jason
thought
networks-
and
that
was
for
good
reason,
so
we
so
we
thought
the
people
that
would
manage
to
get
5.
A
What
does
partially
validated
mean?
So
that
means
like
if
you
find
some
people
basis
of
50/50
split,
almost
where
you
say
what
some
people
are
playing
using
it.
Some
are
not
so
then
it's
also
partially
invalidated
yeah,
so
we're
neutral,
B
or
inconclusive.
That's
that's!
Actually,
a
good
point:
I
mean
I
just
picked
up
the
wording
from
someone
who
lies
alive
of
data
yeah,
that's
fair,
the
other
thing
that
is
interesting.
If
you,
if
you
read
through
this,
like
I,
found
that
apparently
people
didn't
know
or
most
people
didn't
know
that.
A
Actually,
no
I'm,
not
that
one
I
know
we
don't
have
zoom
it
in
sauce.
Basically,
when
you
hit
f1
in
the
IDE
and
you
carry
this
on
top
of
an
API
MSDN
opens
or
the
new
Doc's
page
opens
with
documentation
for
the
API
and
I.
Think
half
the
people
in
the
study
didn't
know
that
and
when
I
tweeted
it
a
lot
of
people
clearly
didn't
know
that
either
which
I
find
surprising,
because
that's
literally
one
of
the
oldest
features
that
VSS
is
there
and.
B
A
B
A
I
mean
that
might
be
true,
too
I
think
there's
also
I,
think
that
was
actually
period
where
everyone
was
literally
broken.
If
you
have
one
you
just
went
to
a
generic.
This
is
the
visual
studio
code,
a
little
page
and
then
I
think
that
was
when
transition
from
MSDN
to
docs
when
they
didn't
have
the
right
hook
up
yeah
I.
B
F
Sometimes
you
still
just
want
that
metadata
view,
because
it's
you
know
turfs,
but
sometimes
you
would
just
like
to
see
the
source,
and
so
how
do
we
enable
that
for
the
folks
at
home?
If
if
anyone
would
like
to
have
f12
or
say
control,
f12
show
or
control
click,
yes
or
yeah,
some
something
show
source
yeah.
Please
please
tell
us.
A
Yeah,
so
that
was
that
the
other
thing
I
did
yesterday
was
I
pulled
some
new
stats.
So
basically
we
are
tracking
how
many
people
are
moving
the
NuGet
packages
to
Learning
Center,
and
we
have
done
this
pretty
much
since
the
release
of
oh
I
believe,
and
so
we
pulled
the
latest
data
and
so
in
the
top
thousand.
A
For
example,
we
pretty
much
are
at
47
percent
now,
and
so,
if
you
apply
a
very
generous
trend
line-
and
you
extrapolate
from
there
like
you
know
about
two
to
three
years
out
is
when
everybody
will
in
the
top
thousand,
have
it
on
a
standard
package
and
for
the
long
tail
it's
very
similar,
except
there
is
more
like
if
you
know,
power,
curve
kind
of
thing
going,
because
it's
this
long
tail
phenomenon,
but
you
know
same
day
like
we
have
I.
Think
at
this
point.
A
What
was
the
number
I
think
thirty
percent
I
said:
yeah
I,
think
thirty
percent
of
all
the
packages
on
Yuga,
org
or
four
don't
isolate
assets.
I,
don't
think
it's
realistic
to
expect
you
will
ever
get
to
a
hundred
percent,
because
some
Tigers
are
just
no
longer
updated
right,
they're
just
done
or
can't
be
moved
to
done,
and
so
I
can't
be
right.
A
B
That
seventy
percent-
just
ones
that
you
could
just
kind
of
do
it
without
team.
It
was-
is
that
just
ones
that
have
something
deep,
fundamentally,
that
will
have
to
change
they're,
just
things
that
we
just
need
a
little
bit
of
changes.
So
it
sounds
like
you
did.
The
work
to
have
it
be
things
are
fairly
fundamental.
Yes,.
A
F
A
D
B
There's
a
couple
things
coming
that
are
interesting
from
from
the
SDK
CLI
perspective,
but
one
of
them
I
think
I
think
that
the
most
significant
one
for
people
is
going
to
be
that
we
have
changes
to
global
JSON
that
are
in
flight,
and
you
can
find
this
in
designs
and
I.
Don't
know
if
we've
talked
about
the
designs
repo
here,
but
we
are
trying
to
put
as
many
designs
as
practical
into
the
open
as
definitely
we
do
them
all.
B
That's
been
a
fairly
significant
request.
You'll
also
be
able
to
set
a
floor,
which
is
another
request.
So,
for
example,
if
you
know
that
your
package
is
going
to
work
with
an
SDK
of,
let's
just
say
two
dot,
one
dot,
500
or
higher,
then
you
can
specify
that
and
then
specify
for
it
to
roll
forward
even
across
majors.
And
then
you
will
never
be
broken
by
the
SDK
and
then
the
last
one
that
we're
the
last
like
big
area
that
that's
understandable.
B
This
explains
the
details
of
how
we're
accomplishing
this,
but
the
last
big
area
is
to
do
exact,
and
so,
if
you
want
exactly
this
crash,
if
it's
not
there,
then
that's
one
of
the
things
that
we're
adding
to
this
an
error
not
crash
right,
yeah,
you're
right.
No,
it's
not
going
to
crash
your
machine
or
anything,
but
but
that.
But
if
you
try
to
run
an
operation
with
the
SDK,
and
you
don't
have
that
SDK,
it
will
not
succeed
and
will
give
you
an
error
that.
D
B
B
Roll
forward,
the
current
run
time
roll
forward
plans
and
that's
what
we're
paralleling,
which
rich
helped
to
put
together,
and
that's
also
had
a
few
changes
in
the
the
dynacord
three
time
frames.
So
we
didn't
get
there
in
a
very
straightforward
manner.
There's
a
lot
of
work,
but
at
the
end,
I
think.
We've
got
the
right
approach
because
it
does
very
closely
parallel
that
there
aren't
time
stuff,
except
for
one
place,
that
it's
different,
which
I
just
want
to
remind
people
about,
because
I
understand
that
the
SDK
version
numbers
are
confusing
and
I'm.
B
Sorry,
but
the
the
first
two
digits,
the
2.1
2.2
3.0.
That
is
the
runtime
that
you
need
to
have
available
and
up
until
3.0.
That's
actually
you
need
that
runtime
from
3.0
on
you
need
like
that
runtime
or
higher
we're,
making
some
changes
around
deployment
which
I
wasn't
going
to
get
into
today,
so
the
first
two
digits
or
what
runtime
you
relate
to
and
the
last
two
digits
are
the
patch
so
that
what
we
call
the
hundredths
position.
B
That's
also
called
the
feature
band
and
that's
where
you
find
out
the
actual
version
of
the
SDK
that
you're
running
and
so
I
know
that
that's
a
little
bit
confusing
for
folks,
but
but
that
first
position
of
the
hundreds
number
is
super
important
from
the
point
of
view
of
the
SDK
and
where
that
confuses
people
is
the
current
SDK
design
is
that
we
create
a
new
SDK
for
every
visual
studio.
We
roll
that
forward,
and
so
we
have
a
two
dot
one
dot
500
that
corresponds
to
a
2.2
dot
100.
B
We
have
a
two
dot,
one
dot
600
that
corresponds
to
a
2.2.
You
know
two
hundred
and
I
know
that
he's
insane
and
we
are
changing
that
in
three,
oh
and
so
good
news
is
just
that.
Will
that
will
clean
itself
up
so
yeah?
That's
that's
sort
of
that
story.
I,
don't
know
if
you
want
to
run
anything
from
the
runtime
selection
perspective.
F
B
B
Run
on
their
beers
yeah,
so
because
what
we
are
extending
the
global
Jason
it
currently
exists.
We
didn't
do
a
deeper
redesign
because
we
wanted
to
get
it
out
in
three.
Oh,
it's
very
important
that
we
we
get
this
into
people's
hands,
we're
using
the
old
global
JSON
rules,
which
means
that
we
stopped
at
the
first
global
JSON.
So
the
very
first
one
you
hit
is
the
only
one
that
will
be
used.
B
So
if
you
have
behavior
higher
in
your
stack,
you
have
to
repeat
it
and
that
might
be
preview
versus
floor
and
it
also
might
be
a
custom
SDK.
So
there's
various
reasons
you
may
have
a
global
JSON.
You
need
to
make
sure
the
first
one
that
gets
hit
has
everything
you
need
in
it
and
we
we
are
batting
around
the
design.
We
don't
have
a
final
design
for
it
yet,
but
we
are
hoping
to
change
that
in
the
future
500
or
later
went
in
order
to
make
that
change.
B
We
have
to
create
a
new
file
type,
because
we
would
it
be
a
horrible
breaking
change
if
we
cease
to
have
that
behavior
within
global
JSON
land.
So
we
also
get
the
win
getting
to
rename
it
because
global
that
Jason
is
not
a
name
that
is,
that
is
terribly
descriptive.
It
doesn't
really
tell
you
very
much
so
we're
batting
around
that,
because
the
other
one
we'd
like
to
get
in
doing
that
is
to
know
where
the
source
route
is
of
the
repo.
B
F
So
with
that
in
place,
my
strategy,
so
tell
me,
tell
me
if
this
makes
sense.
My
strategy
for
what
I
would
want
so
I
have
a
git
folder
on
my
machine.
It's
on
a
different
place
on
on
what
than
Mac,
but
that
doesn't
matter.
I
would
probably
put
a
global
Jason
at
the
root
of
that
folder
that
says
no
previews
and
then
in
particular
projects.
I
would
rather
have
a
global
Jason
that
opts
me
into
a
preview
or
opts
me
into
using
a
specific
SDK
version
or
or
no
global
dot.
F
B
F
F
It's
that
I
want
to
default
to
like
right
now,
I
want
to
default
to
2.2
templates,
often
and
not
because
I'm
always
running
3.0
preview,
7
daily,
builds
and
then,
if
I
build
a
300
project
than
I
need
to
have
a
new
get
dot
config
in
that
directory,
because
I
can't
use
nuga
org
like
it's,
this
kind
of
fairly
horrible
space
that
horrible
experience
that
I
have
because
I
mean
I
pretty
much,
never
install
our
stable
builds
right
because
of
the
job.
I
have
so
that's
I.
F
B
B
B
So
if
you're
on
the
latest
preview-
and
you
are
trying
to
to
target
to
to
or
to
one,
you
definitely
are
going
to
have
to
make
sure
that
you
get
on
the
right
STK
first,
so
you're
gonna
have
to
get
a
global
that
Jason
on
just
to
get
to
the
right,
SDK
and
that's
dumb
and
we're
working
on
it
and
the
that
I
think
that
we're
gonna
land
that
in
three
oh,
it's
not
landed
yet
so
I'm
not
going
to
make
big
promises
on
that.
But
we
know
the
templates.
B
Selection
story
is
just
a
total
mess
across
versions
and
it's
terribly
important
that
we
get
it
fixed
along
with
some
other
things
that
they're
working
on
like
how
you
update
templates,
trying
to
get
a
better
story
on
that,
because
some
of
our
templates
do
have
a
fairly
quick
update
cycles.
So
yeah
there's
this.
E
B
B
One
of
the
one
of
the
things
that
the
vb
runtime
did
was
give
you
a
different
option
for
that,
so
there
was
a
simple
way
to
read
and
write
files.
Rather
earlier
I
don't
know
if
it
was
in
the
initial
release
or
but
by
2005.
There
was
a
way
that
you
could
do
that
and
that
wasn't
something
called
the
VB
runtime,
which
is
the
way
VB
becomes
VB
and
that
some
of
the
special
features
are
in
there
and
we're
in
the
process
of
moving
that
to
done
a
core.
And
it's
it's
it's
a
journey.
B
Early
on
that
was
several
months
ago,
worked
on
that
and
then
the
more
recently
the
financial
functions
we
had
somebody
from
the
community
port,
those
and
there's
some
porting
work
to
be
done.
If
you'd
like
to
be
part
of
that,
you
can
check
out
on
there's
a
github
repo
in
core
FX.
So
the
core
FX
repo
has
a
initiative
for
reporting
the
vbe
runtime.
A
A
D
B
View
the
initial
version
for
for
WinForms
in
300
is
going
to
look.
C
sharp,
like
it's
not
going
to
use
the
visual
basics
windows
application
base,
I
believe
is
the
name
of
it.
That's
not
going
to
be
in
place
for
300
Win
forms
is
just
not
ready
to
be
fully
usable,
so
that
work
is
a
little
bit
on
schedule,
not
behind
schedule
behind
its
it's
not
going
to
release.
B
So
the
my
key
word
is
going
to
come
in
my
and
WinForms
are
the
two
things
that
we
haven't
deported
in
this
space.
We
will
be
supporting
the
the
my
spaces
is
kind
of
a
complex
space
and
it
interacts
with
a
compiler.
It's
got
a
really
interesting
way
that
it
all
fits
together.
Email
looked
at
it
and
he
goes
wow.
That's
really
interesting
and
there
were
parts
of
it.
I
actually
thought
was
intestine
targets,
that's
in
the
compiler,
so
we've
all
been
learning
actually
a
lot
about
some
of
the
inter.
D
B
Just
it
just
works
and
that's
the
that's,
the
the
heart
and
soul
of
Visual
Basic
is
that
it
just
works
and
we're
we're
working
on
getting
back
to
that
in.net
core.
But,
like
I,
said
it's
a
journey,
it's
not
something
that
we're
going
to
just
say
here:
300,
it's
all
done!
It's
not,
but
we're
getting
there
and
there's
really
good
progress
in
in
three.
Oh
and
that's
kind
of
the
end
of
what
I
came
here
today
when.
B
We
went
with
the
current
rules.
We
felt
like
having
some
rules
on
the
new
stuff
that
were
different
than
rules
on
the
old
stuff
was
going
to
be.
We
didn't
think
that
we
could
explain
that
very
easily,
so
we
wanted
the
same
rules
for
everything
in
the
file.
I
agree
that
that
would
be
better
behavior.
We
absolutely
want
that
behavior
as
quickly
as
we
can
get
it.
But
at
this
point
it's
not
three.
Oh,
if
that's
going
to
be
post
three,
oh,
but
I
completely
agree
that
that's
the
way
it
should
work.
B
You
should
be
able
to
put
preview
anyplace
up
and
down
your
stack.
You
should
be
able
to
put
exact
anyplace
up
and
down
your
stock.
We
should
even
have
conversations
about
how
it
works.
If
you
have
something
like
a
floor
set
and
you
have
a
floor
here
and
then
you
have
a
floor,
that's
lower
up
above
we
have
to
have
conversations
about
how
that
should
work.
There.
F
B
There's
just
a
lot
of
work
that
needs
to
be
done
to
get
that
totally
right.
The
two
you're
pointing
out
should
definitely
work
in
a
way
that
just
you
know,
let's
just
take
this
one
key
piece
and
have
it
be
up
and
down
your
stock
in
a
predictable
way,
and
we
couldn't
get
that
done
alone.
We
have
to
wait
until
we
have
the
larger
picture
and.
B
I
would
like
to
give
that
to
you
as
badly
as
you
not
maybe
not
as
badly
as
you
want
it,
but
we
we
are
looking
forward
to
being
able
to
do
that.
The
short
answer
is
that,
as
you
might
be
able
to
guess
new
god
has
a
huge
number
of
things
that
they
get
us
to
do
because
everybody
relies
on
you
get
and
everybody
has
needs
for
them,
and
that
requires
a
change
to
an
API.
B
That's
not
widely
used,
except
by
the
dotnet
course
Eli,
and
so
sometimes
we
we're
fighting
for
our
features
and
right
now
that's
that's
delayed
on
a
new
get
feature.
We
want
it
very
badly.
We
want
it
for
tools
and
for
packages
and
they
will
probably
come
together
but
yeah.
We,
yes
I.
Yes,
what
can
I
say?
But
yes,
so.
F
B
B
Obviously,
this
work
going
on
of
yes
for
Mac
I
mean,
if
that's
the
question,
the
answer
is
yes,
there
absolutely
is,
and
we
have
plans
for
that.
We've
talked
about
some
of
those
plans
we'll
be
looking
at
moving
to
to
support
some
common
under
infrastructure,
more
common
infrastructure
in
five-oh
as
part
of
moving
to
the
single
net
and
I.
Think
it's
easy
to
predict
stuff,
like
you
know,
we're
gonna,
look
at
some
changes
to
things
like
Moana
mem
spills.
B
B
B
Maybe
even
before
the
next
community
stand
up
but
I
want
to
let
people
know
that's
coming.
You
can
certainly
use
out
remove
programs
today
or
whatever's
right
on
your
operating
system.
But
if
you
want
to
delay
a
little
bit,
we
might
be
able
to
make
you
make
that
easier,
because
if
you
have
a
lot,
add/remove
programs
is
a
real
pain
in
the
backside.
Yeah.
F
B
It's
actually
for
really
incredibly,
like.
Oh
really,
that's
the
reason.
Don''t
tools,
actually
our
frame
were
dependent,
they're,
not
self-contained,
okay,
and
it
turns
out
that
this
tool
has
to
be
self-contained,
because
otherwise
it
would
try
to
uninstall
it
itself
and
we
spent
more
than
one
day.
We
spent
some
time
with
the
folks
working
on
this
trying
to
figure
out
an
experience
that
wasn't
horrible
if
it
tried
to
uninstall
what
it
was
actually
running
on,
and
the
bottom
line
was
that
we
needed
to
move
it
into
a
different
delivery
mechanism.
B
B
We're
gonna
put
it
on
a
website
and
so
go
in
it.
We're
working
on
that
with
Rouen,
to
put
it
someplace
in
the
Italy
near
the
acquisition
story.
So
that's
where
we're
looking
at
putting
it
right
now.
So
when,
if
you
don't
hear
from
us
the
next
standup
exactly
where
it
is,
then
it
will
show
up
as
a
initially
as
a
preview
on
the
the
same
places
that
you're
downloading
so
the
dot.
If
user
dot
net
download
Nick
core,
you
come
to
a
web
page,
and
it
will
be
on
that.
That's.
B
B
B
So
it's
just
that
when
you
use
the
MSI
MSI
itself,
put
some
things
into
your
registry
and
has
some
extra
information.
So
we
can
do
the
rough
counting
and
things
at
the
msi
and
installers
are
set
up
to
do
for
you.
So
the
cleanup
is
a
little
a
little
bit
more
than
just
getting
rid
of
the
directories
on
linux,
where
you
don't
have
that
it
is
pretty
much
getting
rid
of
the
director
makes
sense.
So.
B
I
think
that
that's
explanation
we're
still
having
that
conversation
the
best
way
to
get
on
your
scene,
then
nice
thing
about
an
msi.
Is
we
have
a
UI
that
we
can
put
some
information
for
you
in,
including
that
it's
going
to
have
a
slightly
unintuitive
thing
about
it
that
I'm
still
behind?
We
forget
a
lot
of
information
with
the
preview.
We
might
change
this,
but
actually
running
the
tool
will
not
do
anything.
It
will
just
tell
you
what
it
would
do
and
then
you
actually
have
to
put
a
switch
on
it.
B
B
If
you
have
SDKs
and
you're
trying
to
figure
it
out
and
get
you've
just
started
with
this
tool,
we
don't
want
to
uninstall
SDKs
that
you
didn't
mean
to
uninstall
and
make
work
for
you
to
get
your
machine
set
back
up
again,
so
the
default
behavior
is
actually
not
going
to
do
anything
and
we
kind
of
have
to
let
people
know
that
because
it
will
be
a
little
bit
confusing.
But
if
you
do,
if
you
do
that
without
the
do
it
switch,
it's
gonna
tell
you
that
it
writing.
B
You
will
you'll
have
to
be
elevated
to
do
it
and
will
have
instructions
related
to
that.
It's
one
of
the
reasons
that
we
may
do
it
in
an
MSI,
because
we
can.
We
can
place
it
on
the
machine
in
a
more
appropriate
location
if
we
do
it
via
an
MSI
than
if
we
just
hand
you
in
executable.
So
that's
the
current
thinking
is
to
probably
go
with
an
MSI.
It's
a
little
more
work
for
us
up
front,
but
I
think
it's
going
to
be
good
for
at
least
our
Windows
users
and
probably
Mac
users.
A
E
F
B
We
might
at
some
future
point
add
that,
but
we
weren't
going
to
hold
this
feature
up
in
order
to
add
that,
so
we
want
to
get
a
better
uninstall'
experience
into
people's
machines,
particularly
people
that
had
primarily
run
Visual
Studio
and
have
been
installing
SDKs
with
Visual
Studio
and
didn't
have
a
good
reason
to
understand
that
we
did
leave
SDKs
on
machines
so
that
the
global
any
global
that
Jason's
would
not
break.
I.
B
Think
that
at
one
point,
when
there
were
a
small
handful
that
might
have
been
justified
at
this
point,
we
clearly
need
to
help
customers,
particularly
those
that
are
running
previews,
to
to
clean
that
up
and-
and
so
this
will
be,
it
it'll
I,
really
like
the
work.
That's
done
on
it
and
and
it's
far
enough
along
and
I
know
what
it's
going
to
look
like
in
most
aspects
and
I'm
pretty
happy
with
the
way
it's
done,
you'll
be
able
to
have
lots
of
control
over
what
you
uninstall.
B
B
B
A
B
B
F
F
But
I
can
answer
the
next
question.
This
is
more
my
bailiwick,
which
is
no.
There
is
no
plans
to
ship
the
dotnet
core
runtime
with
Windows
in
a
way
that
would
be
meaningful
for
developers.
There
are
some
Windows
teams
like,
for
example,
PowerShell
that
would
love
to
like
the
PowerShell
team
would
love
to
be
able
to
ship
PS
core
back
in
Windows,
not
just
the
PowerShell
5,
which
would
require
dotnet
core,
but
it
would
be
done
in
a
way
that
is
private
to
PowerShell
and
there's
definitely
no
announcement
on
that.
F
That's
just
what
they
would
like
to
the
reason
we're
not
doing
that
is
just
are
during
the
highway.
Well,
it's
basically
this
issue
of
you
know
we
ship
quite
quickly,
and
so
you
know,
each
windows
would
only
come
with
a
particular
version,
of.net
core,
which
would
then
eventually
become
old
and
so
like
dynacord
Rio,
for
example,
you'd
need
to
you'd
need
to
ship
that
yourself
on,
say
Windows
Server
2016,
because
obviously
it
wouldn't
be
there,
and
also
our
servicing
life
cycles,
are
different
than
Windows
that
that's
the
primary
issue.
B
B
B
B
B
B
D
B
Said
we
are
definitely
having
a
lot
of
internal
conversations
about
the
fact
it's
too
hard
to
get
the
runtime
onto
the
machine
and
we
want
to
make
people
that
are
creating
software
and
delivering
it.
We
are
working
on
many
fronts
to
make
that
experience
better,
including
improving
this
single
exe
experience,
including
looking
at
some
long-term
planning
on
acquisition
and
how
that
should
happen.
Some
of
that
is
tied
in
with
other
teams
inside
Microsoft.
So
we
are
aware
the
that
this
is
a
problem.
B
A
Yeah
on
the
node
of
we
suck
we
just
notice
again,
our
common
channel
does
not
connect
to
YouTube
for
some
reason.
So
there's
a
question:
you
know:
I
have
preview
six
installed
installed
only
for
Blaser.
How
can
I
get
the
dotnet
CLI
to
use
our
TM
runtime
by
default
of
preview?
6
installed
everything
default,
sonic
or
300?
Well,.
D
A
D
A
F
A
F
B
A
B
F
B
In
order
for
us
to
move
away
from
having
all
of
these
different
SDKs
and
this
chaos
right
now,
we
have
with
with
SDKs,
not
have
any
money
or
versioning,
and
all
that
all
that
chaos
to
fix
that
we
are
going
to
be
going
to
a
point
where
we're
updating
the
tip
we'll
be
encouraging
you
to
use
the
latest
stable
to
get
the
latest
stable
on
your
machine.
Then
you
would
use
a
global
JSON
saying
that
she
wanted
previews.
You
wanted
no
previews,
because.
B
And
you
could
opt
out
with
no
previews
which
might
actually
improve
use.
7
I
think
that's
there
in
preview
7,
it
might
be
preview
8
you,
you
will
be
able
to
do
what
you're
doing
by
setting
putting
in
a
global
JSON
with
a
previews
set
to
I.
Don't
remember
the
name
of
the
the
value,
whether
so,
whether
it's,
if
you
read
the
the
field,
it'll,
be
obvious
whether
she
said
it
true
or
false,
to
get
we're
gonna
produce,
yeah.
F
B
G
B
F
So
we
had
an
idea,
which
was:
wouldn't
it
be
good,
so
preview
7,
which
is
actually
we're
intending
on
shipping
next
week,
is
gonna,
be
a
go,
live
release,
so
we
had
an
idea.
We
have
this
website
done
at
Microsoft
comm.
It
actually
gets
a
tremendous
amount
of
traffic.
Wouldn't
it
be
a
good
thing
if
we
moved
it
to
preview
7
ahead
of
the
release
and
then
we
would
be
able
to
tell
people
like
look.
F
We
are
actually
we're
not
just
telling
you
that
we
think
that
preview
7
is
a
good
idea
for
hosting
and
prod.
We
already
have
already
done
it
so
yeah.
So
we
update
we.
Not
only
do
we
update
the
website
to
move
it
to
previews
of
them.
We
updated
the
header
to
put
this
little
powered
by
thing
in
there,
so
that
just
that
uses
some
new
AP
is
that
we
added
in
the
product
or
actually
we
fixed
ap,
is
that
were
already
in
the
product.
So
emo
had
the
first
run
at
those
AP
eyes.
F
F
F
F
A
F
F
A
B
F
B
F
B
A
B
D
D
D
So
the
the
main,
the
main
things
when
it
comes
to
c-sharp
8,
so
c-sharp
8,
is
feature
complete
now
for
dotnet
core
3o,
meaning
that
barring
some
extreme
usability
problems
if
they
exist
or
just
bugs
in
general,
between
now
and
release
what
you
get
with
the
preview
7
or
the
stuff,
that's
going
to
come
out!
Oh
yeah!
What
are
you
trying
to
do
nothing
useful?
Okay?
So
what.
D
Yeah
what
you
get
with
preview
7
is
what
you
get
at
release.
If
there's
a
bug.
Well,
we'll
try
to
fix
that
between
then
and
the
actual
release.
If
we
get
overwhelming
feedback
saying
that
something
is
absolutely
horrible
to
use
or
something
like
that,
you
know
we'll
consider
a
tweak
to
a
design
or
something
like
that.
D
So
with
that,
there's
a
few
additional
things
so
with
that
implies
compiler
analysis
that
the
compiler
actually
does
on
your
code,
and
there
are
some
quirks
to
that
that
you
can
influence
if
you
have
more
complicated
code
right
like
it's
simple
enough,
if
string
like,
if
it
just
analyzes
a
string,
input
and
set
and
like
you
put
a
question
mark
on
it
and
you're,
not
you
know
your
dotting
into
it
before
you
do
a
null
check.
That's
fine!
D
But
if
you're
doing
things
like
writing
highly
generic
code,
especially
as
a
library
author,
things
can
get
a
little
bit
trickier.
So
what
we
have
done
in
collaboration
with
the
compiler
and
core
effects,
is
we've
released,
some
attributes
that
are
a
part
of
core
effects
itself
and
these
attributes
allow
you
to
sort
of
influence
the
analysis
of
the
compiler.
D
F
D
If
what
if
we
just
throw
that
compiler
at
existing
code,
that
has
those
value
types
like
there's,
just
some
slightly
different
things
like
we're
dealing
with
okay,
tea
question
mark
means
a
specific
type
of
value
type,
a
specific
kind
of
value,
type
yeah.
But
now
we're
saying
oh,
it
means
something
else
now
and.
D
D
D
D
But
so
we
are.
We
are
gonna
ship,
it
so
instead
say
you're
a
library,
author
and
you
write
any
other
generic
code,
but
you
want
it
to
be.
You
know
you
want
no
ability
to
be
incorporated.
Well,
you
can
attach
some
apt
attributes
to
like
input
parameters.
For
example,
you
can
say:
okay
well,
I
have
a
method
that
is
parameterize
of
type
T
and
it
takes
in
a
T
input,
but
I
want
that
T
to
mean
something
I
want
it
to
like,
say:
oh,
this
is
a
nullable
T
or
this
is
a
non
nullable
T.
D
You
can
apply
an
attribute
one.
It's
called
allow
and
all
the
other
is
called
disallow,
know
on
that
parameter
itself,
and
then
that
tells
the
compiler
that
okay,
this
input
T,
is
a
specific,
as
has
like
some
specific,
has
like
an
OL
ability
to
mention
applied
to
it.
Basically.
So
this
is
really
helpful
for
library,
authors,
and
so
we
think
that
this
is
going
to
be
used
a
lot
by
people
creating
new
get
packages
and
they
want
to
incorporate
no
ability
or
non-null
ability
into
their
their
types.
D
That's
preconditions,
but
then
you
also
want
to
have
post
conditions
right,
because
there's
no
way
to
associate
some
arbitrary
function,
result
or
method
result
with
the
null
ability
state
of
something
else.
That's
like
that.
That's
getting
into
dependent
typing,
which
is
really
crazy,
that
that
sort
of
involves,
like
a
proof
system
and
a
compiler,
to
be
able
to
do
this
sort
of
stuff,
but
that
is
sort
of
useful
to
be
like
well,
if
this
thing
say
it
returns
true
or
it
returns.
D
Well,
it
can't
because
you
would
just
get
exploding
compile
times
so.
Instead,
you
can
enforce
a
post
condition
on
on
the
return
type
of
something,
and
you
can
say
it
is
either
a
may
be
null
or
a
not
null.
So
you
say
like
okay.
Well,
the
results
like
you
know
the
is
not
knowable
in
this
case.
So
then
the
compiler
can
say:
okay,
well
I'm,
going
to
assume
that
this
is
not
knowable,
because
you
have
declared
this
thing
that
I'm
dealing
with
as
such.
D
If
it
actually
fails,
that's
like
your
fault
for
not
you
know
annotating
it
like
that,
but
we
want
to
give
people
the
tools
to
do
that.
A
lot
of
this
grew
out
of
needs
by
core
FX
developers
themselves
to
be
able
to
apply
a
null
ability
or
non
null
ability
on
particular
parts
of
the
core
part
of
core
FX.
So.
B
One
aspect
of
what
you're
talking
about
is
there's
many
aspects
of
it,
but
one
aspect
of
it
is
that
there's
work
going
on
that
is
going
to
allow
some
of
the
surface
areas
that
that
Microsoft
has
in
core
of
X
to
understand
no
ability
actually
out
of
the
gate
when
you're
all
abilities
first
available
to
customers,
and
so
or
users
I
mean
whatever.
But
but
so
if
somebody
is
putting
no
ability
into
their
code
and
their
code
is
calling
things
and
core
FX
and.
D
B
D
D
B
D
D
Then
there's
also
some
additional
attributes.
They're
they're
called
conditional
post
conditions
right.
So
so
this
is
helpful
to
say
like
in
tryparse
right.
You
want
to
try
parse
out
the
value,
and
if
it's
successful
you
want
the
the
thing
that
was,
it
was
parsed
into
to
be
either
knowable
or
non
nullable
right
C.
So
this
is
conditional
on
the
bool
yeah
conditional
on
the
bool
right.
D
So
again,
if
the
compiler
had
to
track
that
like
magically,
that's
that's
totally
getting
into
like
proof,
system
level
stuff
in
the
compiler
and
you
could
just
have
you
could
like.
Maybe
in
bed
like
a
XIII
solver
inside
the
compiler.
Maybe
we
could
I
don't
know,
but,
like
that's,
that's
getting
a
little
crazy.
So
instead.
B
D
B
D
Yeah
and
so
that
this
whole
thing
of,
like
I,
have
this
method
that
returns
a
bool,
but
it
takes
in
a
ref
parameter
and
I
want
to
influence
the
null
ability
state
of
that
ref
that
was
passed
and
based
off
of
the
result
of
the
method,
that's
something
that
you
can
apply
via
metadata
and
that's
a
super
common
pattern
throughout
core
effects.
It's
also
just
a
common
pattern
in
general.
Can.
B
I
go
if
I
one
more
thing
there
for
folks
is
that
when
we're
that's
a
great
great
example,
but
that's
because
flow
analysis
can
sometimes
figure
out
whether
or
not
that
you're
gonna
get
a
return
bool
and
then
your
your
code
will
reflect
that
so
you're
gonna
have
an
if,
for
example,
that
uses
that
pool
and
so
inside
that
block,
then
the
null
ability
analysis
can
understand.
No
ability
that,
because
we
assume
you're,
gonna
use
and
if
they're
yeah
and
that's
the
context
of
what
you're
talking.
D
Yeah,
yeah
and
so,
and
so
I
mean
like
the
typical
pattern
that
people
have
is
if
they
call
try,
get
or
try
parse
or
something
like
that,
if
it
succeeds,
they
have
the
thing
right
and
so
into
people's
code.
Today,
they're
just
typing
dot
immediately
another
thing,
and
so
you
know
that's
actually
true
like
if
it
succeeded,
we
don't
have
null
as
a
result.
We
have
an
actual
thing
as
a
result,
but
there
was
no
way
for
the
compiler
to
distinguish
that
so
without
making
an
assumption.
D
So
if
you
apply,
if
you,
if
you
sort
of
I,
guess
you
could
say,
I
forgot
the
word,
but
if
you,
if
you
can
effectively
encode
an
assumption
that
the
compiler
could
say,
AHA
well,
I
know
this
to
be
true.
It
has
been
asserted
as
true,
so
therefore
I'm
going
to
assume
that
that
is
correct,
fortifies
no
you're.
Looking
for
it's
sort
of
not
like
proof
so
like
you're,
not
actually
proving
that
you
know
it
is
true
that
tryparse
gave
you
a
non
knowable
thing.
It's
like
it's
like
proof
by
assertion.
F
A
This
case,
like
tripe,
ours,
is
a
somewhat
of
a
bad
example,
because
most
of
our
tripods
api's
return
value
types
but
like
basically,
if
they
would
return
to
class.
That
would
be
the
the
example
we
would
say
yeah
be
guarantee
that
it's
never
know
when
it's
returning
true
for
this
particular
case
here,
the
dictionary
it's
even
more
complicated
because
it's
generics,
so
T
value
is
not
constrained
to
be
anything
particular,
but
it
could
be
a
video
type.
A
It
could
be
a
class
type,
and
so,
in
this
case
we're
saying
if
the
method
returns,
false
T
value
may
be
now,
so
we're
not
actually
guaranteeing
that
it's
not
null
when
its
returning
true,
because
it's
totally
valid
to
have
null
values
in
a
dictionary.
But
we
are
saying
that
you
know
it
might
be
now
when
the
return
value
is
false.
We
basically
saying
if
you
know
basically
in
the
negated
part
of
the,
if
it's
probably
an
error
right
versus
if
it's
a
generic.
B
A
The
type
system
gives
you
and
the
annotations
of
the
type
system
gives
you
is
that
you
only
have
to
look
at
every
single
edge
once
right,
like
an
all
ability
within
a
method
body.
The
compiler
will
do
flow
analysis
and
will
understand
your
rechecked
funnels.
So
you
can
do
a
bunch
of
magic
stuff,
but
it's
just
within
one
method
because
everything
it
calls
and
everything
that
it
returns.
You
are
expected,
as
the
API
author
to
encode
the
result
in
your
API,
so
the
compiler
doesn't
actually
have
to
look
into
the
calling
methods
body
to
understand.
A
What's
going
on,
because
the
master
annotated
for
its
return
types
when
its
parameter
types,
what
the
expected
contract
is-
and
that
makes
that's-
why
compilers
have
type
systems
right.
So
we
can
actually
express
things
aesthetically,
so
we
don't
have
to
analyze
the
entire
world
every
single
time.
You
make
a
change
in.
B
The
only
thing
I'd
add
to
that
is
within
your
code,
that's
already
in
the
compiler
that
it's
already
working
with
it
does
keep
some
of
that
information.
So
you
don't
like
have
to
annotate
your
own
stuff
in
order
to
get
anything
out
of
this.
It
is
smart
about
the
code,
that's
actually
in
the
active
compilation
right
now,
but
actually
as
soon
as
you
leave
that
compilation,
then
you
absolutely
have
to,
as
you
say,
just
touch
that
when
you
need
it
a
good.
A
F
A
D
The
last
one
is
about
enormous
dependence.
We
have
this
thing
called
no
less
dependence
between
inputs
and
outputs,
so
the
output
of
a
method.
You
may
want
the
null
ability
state
of
that
to
be
influenced
by
the
no
louise,
no
ability
state
of
one
of
its
inputs
right
so
like
if
you
want
the
output
to
be
knowable,
if
the
input
is
knowable
like
so
like
you
know
way,
this
actually
be
called
a
not
null,
if
not
null
and
then
takes
in
a
string
which
is.
D
D
F
D
F
B
F
B
D
B
Dotnet
I'm
sorry
for
the
c-sharp
way
of
doing
Nobles,
some
of
this
stuff
that
you're
looking
at
right
now
may
not
have
I,
don't
know
one
way
or
the
other
whether
it
has
priority
is
fairly
unique
to
it.
The
details
of
it
were
certainly
worked
out
for
specific
dotnet
scenarios.
The
details
of
it
were
not
available
whether
someone's
actually
set
similar,
something
like
an
attribute
on
some
other
system.
That
was
a
post-hoc,
no
ability
concrete.
B
D
Know,
certainly,
if
you're
using
writer,
you
have
access
to
them
too,
but
they're
they're
very
there.
Well,
it's
not
that
they're
limited
like
they're
limited,
but
that's
not
necessarily
a
bad
thing.
It's
limited
because,
like
you
can
only
go
so
far
with
strictly
attributes
and
saying
Oh
I'm
enforcing
by
convention
that
this
input
type
cannot
be
known
and
you
can
apply
like
tooling.
D
D
That's
not
like
that.
You
know
that
doesn't
allow,
like
you
know,
for
just
some
arbitrary
knowable
input
type.
Can
we
do
compiler
analysis
on
the
state
of
that
for
the
body
of
a
method
or
you
know,
can
we
relate
this
to
you
know
if
this
is
something
that
is
defined
on
an
interface
like
I'm,
sorry
that
implements
an
interface
or
are
these
matching,
for
example,
so
yeah.
A
One
thing
with
contracts:
this
code
is
more
generalized,
it's
basically
predicates
over
your
code,
which
basically
means
you
have
a
few
improver
running.
As
you
know,
you
analyze
it
with
the
with
the
coke
on
track
analyzer,
which
is
a
little
bit
of
a
very
heavy
machinery.
This
one
is
really
only
about
try
it,
so
this
basically
informs
the
flow
analysis
of
the
compiler
to
you
know,
consider
certain
things
to
be
null
anon
now,
depending
on
state,
and
so
the
way
I
think
about
these
attributes
is
the
database.
A
Is
the
long
tail
right
so
like
if
your
console
a
by
author,
you
get
a
lot
of
mileage
out
of
just
using
question
marks
and
opting
internal
ability
and
when
there
are
particular
patterns
where
you
want
to
give
your
users
a
better
experience,
that's
when
you
would
use
those
attributes
right,
so
you
know
we
had
these
attributes
I
think
we
applied
something
on
the
order
of
maybe
50
to
100
across
all
of
Cola,
which
is
about
20,000
api's.
So
that
gives
you
an
idea
on
how
much
you
would
use
them.
What
switch
the
screen
again!
A
This
has
been
on
too
long.
Sorry,
like
it
I
just
want
to
talk
about
this
okay.
So
if
you
look
at
the
edges
here,
they
they
are
effectively,
like
you
know,
ignoring,
suppress
message
and
exclude
code
coverage.
These
are
basically
the
long
tail
things
that
Phillip
is
talking
about,
and
you
know
they
are
very,
very
specialized
to
very
particular
things.
So
a
good
example
here
is
we
have
this
one
thing
called:
that's
not
returned
and
that's
not
returned.
A
If
so,
for
example,
if
you
write
debugged
or
desert
and
you're
asserting
something
is
not
now,
then
they
come,
then,
basically,
you
want
to
let
the
compiler
be
aware
of
that
and
the
way
you
do
it
is
what
we
basically
just
asserted.
We
basically
put
a
tribute
on
the
abutment
certain
says
this
method
will
not
return
if
the
condition
is
false,
so
that
that's
the
compiler
reason
about
the
fact.
A
If
you
didn't
all
check
and
debug
code
assert
that
the
next
line
would
never
executed,
that
is
violated
right
or
we
have
that's,
not
return,
which
is
when
you
say
you
know.
If
this
is
null
environment,
dot
fell
fast,
so
we
annotated
fail
fast
to
say
this
will
never
return.
If
you
call
this
method,
this
is
the
end
of
it
or
process,
not
exit
or
something's
like
that
right.
So
those
are
most
of
the
time
the
only
person
using
those
attributes
will
be
the
framework.
A
F
F
D
Yeah,
so
we
are
wrapping
up
with
that
on
the
compiler
now
that
doesn't
mean
that
we're
done
so.
This
feature
is
more
of
like
a
five-year
feature
in
that
regard,
like
I,
don't
I,
don't
think
this
is
not
something
that
like
when
300
ships
were
finished,
like
its
there's
gonna,
be
more
bugs,
there's
going
to
be
opportunities
for
better
compiler
analysis.
One
of
the
big
areas
right
now
is
tooling,
is
still
very
much
work
in
progress
with
respect
to
Knoll
ability.
D
B
A
But
in
order
for
us
to
get
there,
basically
everything
has
to
be
annotated
and
the
way
we
did
it
in
core
FX
was
we.
You
know
we
looked
at
various
strategies.
One
sided
used
to
be
considered
was
saying
before
we
implemented
ourselves,
because
so
that's
a
lot
of
work
for
us.
Maybe
we
should
just
annotate
or
reference
assemblies,
because
that
immediately
gives
customers
value,
but
by
just
using
our
API
for
the
video
doctor
palpable
or
not
is
orthogonal.
A
Youtube
is
your
a
board
at
some
point.
You
will
see
that
we
are
also
surprised
ourselves.
What
API
is
return
now
under
what
circumstances
right.
So
it's
given.
That
is
the
first
time
very
P
I
the
API
is
themselves
tell
you
what
is
not
I'm,
not
now.
That's
also
the
first
time
you
can
see
this
in
context
right
if
you
look
at
every
API
in
isolation
yeah,
it's
a
fine
contract
to
have
to
return
now
when
certain
things
are
not
true
or
whatever.
A
But
when
you
actually
look
at
you
know
the
overall
shape,
you
see
all
the
inconsistencies
you
have
and
so
I
think.
From
our
point
of
view
like
it
was
the
right
approach
to
go
up
from
the
inside
out
and
4.85.
We
will
basically
do
the
rest
of
of
the
of
the
core
platform.
If
you
will
the
PCL,
which
is
on
the
order
of
like
another
50,000
api's
and
then
I
think
from
their
own.
D
And
there's
also
another
interesting
thing
with
respect
to
annotations
is
once
they're
in
either
like
changing
an
annotation
one
way
or
the
other
is:
is
it
breaking
change,
or
or
or
rather
it
has
the
potential
to
be
a
breaking
change
now
breaking
chains,
meaning
in
terms
of
warning,
not
necessarily
an
error?
Now
that
will
be
an
error
if
people
have
warned
as
error
set
to
true,
but
so
like
that?
D
That's
why
this
this
is
happening
at
the
base
level
and
we're
trying
to
get
it
out
there
and
we're
trying
to
like
we're
trying
to
make
sure
that
our
design
decisions
that
we
make
are
correct,
because
if
we
go
in
and
change
one
of
these
things
say
we
just
had
to
change
the
knowability
annotations
on
object.
Three
years
from
now,
that's
going
to
be
kind
of
bad,
and
we
don't
want
to
do
that.
So
we
want
to
ship.
D
It
now
get
a
lot
of
feedback
on
this
and
make
sure
that
the
warnings
that
you
are
getting
are
the
correct
warnings
like
you
would
expect
to
get
these
because
you
know
oh
my
code,
it
actually
is
unsafe
in
this
way.
Thank
you
very
much
for
reminding
me
this
or
oh.
It
makes
sense
that
I
should
pass
something
that
is
non
null
here,
rather
than
something
that
could
be
null
or
the
other
way.
D
A
D
D
D
We
would
probably
make
it
string,
but
then
that
begs
the
question:
if
we
would
probably
do
that,
then
maybe
it's
a
better
to
design
decision
to
actually
do
that.
It's
it.
We
don't
really
know
yet,
because
we
haven't
shipped
it.
So
we
don't
know,
like
you
know,
with
the
the
bulk
of
people
using
this.
If
that's
actually
the
right
call
yet
yeah.
So
I
have
a
more
out.
F
Of
the
weeds
conversation
which
is
so
I
understand
that,
like
interfaces
and
for
to
a
virtual
methods
of
all
kinds,
definitely
bring
complexity,
you
know
that's
basically
what
you
guys
were
talking
about.
So
in
the
case
where
I
have
my
own
I
have
my
app
I'm
only
thinking
about
my
own
implementation.
It
has
no
virtual
methods
in
it,
they're
just
all
concrete
in
nature
and
I
sprinkle.
All
these
attributes
around.
What
does
testing
that
look
like
in
order
for
me
to
know
that
I
attributed
these
correctly?
F
D
F
Normally,
well
sure,
that's
not
really
so
that
makes
sense.
That's
not
really
where
I
was
headed,
though,
which
is,
let's
assume
I,
have
all
the
warnings
enabled
because
I'm
trying
to
get
to
purity
like
to
correctness
with
respect
to
this?
How
do
I
know
that
the
the
attributions
that
I
put
there
are
correct,
yeah.
A
A
A
D
I
guess
it's
it's
somewhat
similar
to
like
saying:
oh,
how
do
I
test
that
this
thing
that
says
it
takes
in
a
string
only
accept
strings.
That's
so
like,
if
I
define
a
method
that
takes
in
a
string.
Do
I
want
to
test
that.
Oh,
if
I
pass
in
an
integer,
it
rejects
it
well
right,
so
we
don't
really
test
like
that.
Right.
F
D
F
Tests
that
relate
to
null
ability
only
if
you
feel
like
it,
yes,
so
the
the
answer
the
email
gave
was
good,
like
that.
That
was
where
I
was
willing
to
go,
which
is
so
at
any
point
in
time.
If
you
have
these
attributes,
they
will
be
correct.
If
you
like,
to
compile,
the
compiler
will
enforce
them
to
be
correct,
but
there's
this
editorial
nature
to
them,
which
is
you
have
to
decide
if
you're
happy
with
what
it
is
that
they
represent
and.
A
There's
one
additional
wrinkle
like
similar
to
the
type
system:
you
can
cost
right,
you
can
cost,
you
know,
string
to
object,
an
object
to
string
right
and
you
know
going
from
string
to
object,
is
fine
and
going
from
object
to
string.
May
not
be
fine.
Why
do
you
make
it
a
runtime
costing
arrow?
The
same
is
true
for
now
right
we
have
this
bang
operator
and
order
basically
tells
the
compiler
to
say
the
compiler
thinks
this
might
be.
No,
but
you
were
saying
shut
up.
I
know.
A
The
idea
there
is
here,
if
you
sprinkle
those
aggressively
through
your
code
base,
then
you
basically
tell
the
compiler
I,
know
better
and
then
the
question
is:
how
would
you
find
that
out?
Only
in
the
answer
to
that
is
you
run
the
code
right,
that's
the
normal
state
of
life
similar
to
holy
well.
How
would
you
find
him
by
the
cast
exception,
so
you
have
to
run
your
code
so.
B
Let
me
let
me
make
sure
we're
really
clear
on
something
with
what
you
just
said,
which
is
you
need
to
run
the
code.
You
need
to
run
the
code
with
the
bad
values,
because
there
is
nothing
and
no
ability
that
affects
runtime
in
the
discussion
it
doesn't,
and
so
the
this
is
all
compiler
based,
which
means
that
you
have
to
have
a
test.
That's
going
to
pass
in
a
value
that
and
then
you're
going
to
blow
up.
B
You're
gonna
have
to
create
the
situation
that
no
ability
was
designed
to
keep
you
out
of
in
order
to
be
able
to
wear
like
code
and
see
so
it's
actually
a
pretty
high
bar
to
hit
that
in
in
a
in
a
realistic
way.
It's
actually
gonna
be
really
hard
for
people
to
know
if
they've
annotated,
correctly
yeah.
D
Sir
I
don't
know
if
it's
hard
so
much
as
it's
not
any
more
difficult
than
knowing.
If
the
system
that
you
are
writing
is
doing
the
right
thing
anyway,
it's
like
there's,
there's
the
right
thing
from
like
a
unit
test
standpoint,
if
you're
just
like,
say
you're,
building
a
Windows
application
or
something
then
there's
also
the
right
thing
of
like
okay.
Well,
am
I
displaying
like
the
right
information
for
users
that
it's
it's
very
similar
to
that,
like
you
know,
are
the
contracts
that
I'm
defining
in
in
between
my
system.
B
D
B
No
suppression
off
so,
if
you
put
the
exclamation
point
in
then
you're
getting
to
a
situation
where
it
will
be
harder
to
see
whether
you're
giving
the
person
the
right
information,
so
I
would
definitely
suggest
that
if
you're
using
this
no
suppression
operator
the
explenation
point
much
either
there's
something
in
the
process
that
that
you
haven't
become
one
with
that
you
haven't
got
the
whole.
You
know
the
whole,
it's
it's
not!
It's
not
quite
working
smoothly.
Yeah,
yeah
and.
A
I
think
I
would
agree
on
that,
because
I
think
I
would
say
that
it's
almost
saying
it's
a
code
smile
but
I
wouldn't
go
that
far.
It's
the
same,
as
you
would
say,
if
you
have
a
strongly
if
you
move
from
JavaScript,
let's
say:
c-sharp
I
usually
move
from
basically
no
taiping
taiping
that
any
sort
of
casting
is
a
bad
smell.
All
right
that
I
think
that's,
that's
that's
not
true
there.
A
The
the
reality
is
that
type
systems
can
only
represent
what
what
did
what
the
compiler
can
set
a
clean,
oh
and
that
is
not
to
say
that
there's
more
things
you
could
statically
now
that
there
are,
but
the
compiler
just
says:
I've
not
been
I'm,
not
going
to
be
a
theorem
provers.
So
I
will
not,
for
example,
track
how
these
four
variables
in
conjunct
by
communitarians
our
variables,
for
example
right.
A
So
there
would
be
cases
where
the
compiler
just
can't
know
that
certain
things
are
not
now,
even
though
that's
true,
and
so
that's
where
the
bank
and
operator
or
the
casting
comes
in
me
and
say
no
I
know
that
this
thing
will
always
be
a
string
or
this
will
always
be
a
null
value
right,
and
so
that's
where
you
basically
override
this.
So
in
fact,
in
core
FX
I
think
we
at
some
point
to
counter
the
the
number
of
banks
and
it's
it's
significant.
A
We
have
it
all
over
the
place,
but
also
keep
in
mind
that
our
code
is
also
not
100%
representative,
for
what
customers
who
might
write.
We
have
things
like
interlocked,
compare
exchange
where
it's
really
hard
to
figure
out
how
you
would
even
annotate
the
API
correctly
for
all
cases,
but
I
think
for
the
most
part,
it's
I
would
just
honestly
say,
think
of
it
as
like,
casting
like,
if
you
cast
from,
and
to
object,
that's
basically
what
sorry
from
object,
that's
kind
of
hoping
it
works.
A
It's
not
always
bad,
but
you're,
basically
saying
I,
know
better
and
well
as
it
is
with
all
these
things.
You
have
to
test
that,
and
you
know,
but
I
would
say
I,
don't
think
it's
bad,
because
if
even
if
it
goes
bad,
it's
not
worse
than
today
as
well,
but
you
make
it
in
our
reference
exception
or
nog.
You
would
not
accept
yeah.
F
A
F
A
D
B
F
That's
not
what
I
meant,
so
it
would
not.
Weather
warnings
are
occurring
but
like
in
the
presence
of
the
damnit
operator,
you
know
does
that
does
like
obviously
you're
you're
doing
more
human
computation
to
ensure
that
this
is
safe.
And
the
question
is:
is
whether
you
need
to
write
unit
tests
to
guard
against
something
like.
A
That
so
I
guess
like
imagine,
you
don't
have
any
notable
notations,
which
is
today
as
well
right.
Do
you
have
unit
tests
to
test?
For
that?
You
return
all
of
whether
you
accept
now.
You
might
I
mean
some
really.
You
know
people
that
are
obsessed
with
the
API
as
we'll
write,
those
when
it
says
most
people
down
right.
They
just
write
the
behavior
test.
I
guess,
if
you
move
to
non
ability,
just
means
that,
instead
of
having
to
write
tests,
you
might
get
warnings
earlier.
A
However,
even
if
you
use
level
annotations,
that
does
not
remove
the
need
for
you
to
check
and
throw
exceptions,
because
you
might
have
callers
that
don't
have
annotations
enabled
right,
so
you
always
have
to.
Even
if
you
say,
I
only
accept
non
null
strings.
A
caller
that
doesn't
use
nullable
imitations
might
still
give
you
a
null
value.
Yeah.
A
Think
of
it
more
as
a
Productivity
feature
that
the
developer,
who
writes
code
against
you
in
API
the
first
time,
knows
what
your
behavior
is
and
knows
what
the
expectations
aren't
right
and
so,
instead
of
me
passing
in
very
loose
and
then
they
let
on
faith
and
I
reference
at
an
if
statement
somewhere
because
for
the
most
part
of
me,
look
at
corvex,
for
example
by
us
adding
Malaba
annotations.
We
found
like
five
bucks
in
like
a
code
base
of
like
I.
Don't
know
how
many
hold
hundreds
of
solvent
lines
of
code
right
so
but.
B
A
Heavily
tested,
but
in
its
heavily
tested
and
like
it,
so
if
you
enable
them
existing
code
bases,
the
value
is
not
going
to
be
you
finding
more
bugs.
The
value
is
mostly
for
your
consumers
having
a
better
first
time,
experience
knowing
what
is
now
because
some
api's
are
surprising.
So
let
me
give
an
example:
path.
Get
parent
directory
will
return
null
if
there's
no
parent
directory.
B
A
B
But
that's
core
effects
which
has
a
really
high
bar
for
a
lot
of
of
the
way
it's
written.
If
you
have
code
that
has
no
asserts
in
it,
and
you
know
it
has
got
you
just
it
just
runs
it
just
works.
She
had
a
lot
of
focus
on
happy
path.
You
haven't
done
a
lot
with
boundary
conditions
in
unit
tests
yeah.
I
think
you're
gonna
find
a
lot
of
bugs.
I
think.
Actually,
it's
gonna
be
frustrating
experience
because
of
how
many
bugs
you
get.
B
But
you
know
that's
what
I
was
going
to
say
earlier
about
picking
core
lab.
Is
that
pick
the
most
core
thing?
You've
got
the
most
central
piece
that
you
told
if
you
have
the
utility
libraries
start
there,
because
picking
core
lab
was
not
an
accident
and
we
didn't
pull
it
out
of
a
hat.
It
was
what
is
that
most
central
thing
and
then
you,
you
kind
of
concentric
circles,
out
from
there.
B
What
is
calling
that
that
makes
sense
to
do
let
you
said
you
were
looking
at
the
VCL
as
being
the
next
step,
another
fifty
thousand
api's
and
then,
after
that,
looking
at
wind
forms
are
asp.net,
and
so
that
same
process
of
this
is
the
most
central
thing.
This
is
the
next
things.
The
next
thing
absolutely
that's
the
way
to
approach
this,
both
for
maximum
benefit
and
also
for
maximum
sanity,
because
your
utility
library
man,
if
it
has
a
potential,
no
reference,
you
know
you
want
to
catch
it
and
you
want
to
catch
it.
B
Today
I
mean
that
you
know
you
want
out
in
wind
form
someplace,
you
may
have
a
spot
where
it
comes
up
with
a
recommendation
to
treat
some
but
something
as
knowable
and
you
go.
You
know
that
can't
possibly
be
no
lie,
know
that
from
what
I
know
about
the
code
and
and
it's
it's
a
different
experience
than
than
it
isn't
the
very
heart
of
your
applications,
so.
D
Like
to
end
it
on
something
great
earlier,
I
said
that
these
attributes
sort
of
imply
a
proof
by
assertion
within
the
compiler,
so
I
decided
to
pull
up
the
wikipedia
article.
I'm
proof
of
my
assertion,
proof
by
assertion
sometimes
informally
referred
to
as
proof
by
repeated
assertion
as
an
informal
fallacy
in
which
a
proposition
is
repeated
is
repeatedly
restated,
regardless
of
contradiction.
This
fallacy
is
sometimes
used
as
a
form
of
rhetoric
by
politicians
or
during
a
debate
as
a
filibuster
in
its
extreme
form.
It
can
also
be
a
form
of
brainwashing.
D
E
B
D
B
D
B
C
B
A
That
note,
today,
I
aged
by
five
years
again,
I
was
sitting
in
the
cafeteria
peacefully
drinking
my
coffee
and
watching
a
youtube
video
about
PBS
space
time
and
all
of
a
sudden.
This
Joker
jumps
in
front
of
me
yells
out
of
his
lungs
and
I'm,
like
okay
and
five
people
turned
around
in
the
cafeteria,
I
think
I
aged
and
so
did
other
five
people
great.
F
Moving
to
preview,
7:00
or
sorry
did
move
to
preview
7:00,
so
we're
planning
on
shipping
that
next
week
some
people
have
been
asking
me
like
Oh.
What
what
features
are
you
still
planning
on
shipping?
Definitely
wanting
to
send
the
message
that
very
few
new
features
are
coming
in
done
at
core
3,
we're
absolutely
trying
to
shut
down
the
release,
bring
it
up
to
quality
and
make
it
so
that
you
can
ship
it
on
your.
You
know,
production
servers
and
then
start
building.
F
You
know,
windows,
forms
and
WPF
windows
desktop
apps,
so
we're
we're
getting
ready
to
be
done
and
moving
on
to
the
next
release,
which
we're
super
happy
about,
so
we'll
soon
be
working
on
three
one
and
then
five
whole
yeah,
Jordan
yeah
three
one
is
super
short
I
mean
I.
Guess
I
can
talk
about
that.
A
tiny
bit,
which
is
our
goal
of
three
one,
is
that
it
will
be
the
LTS
release
so
supported
for
a
much
longer
period.
We
are
gonna,
have
an
extremely
high
bar
for
accepting
changes
to
that.
F
B
D
Was
it
was
it
types
and
languages
I
think
that's
the
name
of
the
book
is
that
31
types
yeah
at
Apple,
yeah
types
and
programming
language
by
Benjamin
Pierce,
that's
the
name
of
the
book.
It
is
yeah
if
you're
interested
in
it,
it's
pretty
great.
It
will
teach
you
from
the
very
GetGo
it
will
define
from
the
basic.
So
what
is
a
judgement
right?
How
do
you
get
into
the
vernacular
of
describing
the
relationships
between
types
themselves
like
and.
F
D
Mathematical
or
computer
science
for
sure
also
an
English
background
might
actually
be
quite
good
because
if
you
studied
English
and
you
studied
things
like
grammars
and
the
structure
of
languages,
this
is
extremely
relevant.
Okay,
so
but
like
there's
a
Matthew
sort
of
twist
to
it,
because
once
you
start
getting
into
defining
the
relationships
between
things
like
in
a
categorical
sort
of
thing
or
a
category
theory
as
it
were,
that's
when
you
start
getting
into
like
okay.
D
F
D
F
F
With
my
grandmother
one
time
she
was
a
schoolteacher
one-room
school
I
was
since
she
was
married
to
a
farmer.
My
my
grandfather-
and
this
is
just
as
I
was
learning
XML
and
so
I
was
talking
to
her
about
parsing
cuz
parsing
is
a
big
part
of
that
thing,
and
it
was
funny
she
knew
exactly
what
I
was
talking
about,
because
she
said
that
she
parsed
grammar
mm-hmm,
quite
commonly
as
an
English
teacher
in
a
one-room
schoolhouse
in
Canada,
and
so
this
relates
to.
That
was
the
one
time.