►
Description
Join members from the .NET teams for our community standup covering great community contributions for Framework, .NET Core, Languages, CLI, MSBuild, and more.
A
A
A
B
A
B
I,
wouldn't
talk
a
little
bit
about
the
idea
of
a
dotnet
config
I
I
want
to
talk
about
it's
something
that
is
like
brand-new
and
our
thinking,
and
so
we're
doing
design
and
I.
Think
it's
a
great
time
to
talk
to
you
all
about
what
we're
thinking
on
the
design
and
very
early.
You
can
have
feedback
on
something
that
is
very
early
in
its
design
stage
and
so
I
think
it'd
be
great
and
talk
about.
Why
some
other
things
we
can't
just
grab
something
we've
already
done
so
I'll
talk
about
that
sounds.
C
A
A
B
A
B
A
A
And
you
know
if
you
ever
try
to
target
or
if
you
ever
try
to
write
code
that
runs
in
multiple.
You
know
dotnet
environments,
then
you
realize
that
it's
not
that
simple
right.
We
have
these
boxes
on
the
left-hand
side
that
make
it
appear
very
simple,
but
the
Devils
in
the
details
and
there's
lots
of
complexity
because
we
have
there
many
boxes,
and
so
the
pen
I've
done
had
five
is
to
actually
make
fewer
boxes
rather
than
trying
to
draw
another
box
around
it
and
pretend
it's
simpler
than
it
actually
is.
A
But
that
still
sounds
very
abstract
and
we
have
had
many
questions
up
with
people.
What
that
actually
practically
means
so
I
have
a
slide
where
I
want
to
talk
a
bit
about
what
technologically
happens
under
the
covers.
So
of
course,
you're
done
in
framework
for
X
all
right,
of
course,
you're
done
a
course.
We
won.
We
just
shipped
that
one
as
LT
s
and
then,
of
course
we
have
the
same
platforms
right,
and
so
one
way
to
think
about
this
is
that,
first
of
all
about
an
framework
for
X.
A
We
consider
this
feature
complete,
so
it's
not
dead,
which
many
people
say
because
we
still
service
it.
There's
no
ships
with
Windows.
So
it's
actively
maintained.
You
know
we
do
security
patches.
So
if
you
have
any
apps
running
on
that,
there's
no
need
for
panic.
It
just
means,
don't
expect
innovation
on
that
platform.
Why
we're
not
going
to
enable
a
new
kind
of
Jade
we're
not
going
to
add
new
API
is
so
the
stability
is
basically
the
primary
feature
of
the
platform,
then,
on
the
course
site,
of
course,
there's
more
platforms
to
come.
A
You
know,
and
after
that
my
course
you
know,
3
X
people
would
have
the
expectation.
The
next
one
is
called
Donaire
core
for
all
right
and
then
one
of
the
things
you
want
to
do
is
you
want
to
convert
the
Zeeman
platform,
because
that
one
is
still
ongoing,
of
course
cemented
or
neck,
or
you
could
invert
that
strong
above
dotnet
core
and
then
it's
because
of
that
we
basically
said:
look
let's
just
rebrand
on
a
core
four
as
done
at
five,
and
the
five
does
two
things.
A
One
five
is
bigger
than
four,
so
it
kind
of
sends
a
clear
signal
to
people
that
are
not
in
framework
that
you
know
the
evolution.
Moving
forward
is
going
to
be
done
on
core
based
not
on
air
frame,
work
based
and
then,
because
you
know
we
convert
them
and
without
proof
dotnet
quorum.
You
considered
written
firm
work,
basically
done,
there's
not
really
a
need
anymore
in
the
brand
to
to
emphasize.
This
is
core.
A
So,
basically,
that's
why
we,
you
know,
decided
to
drop
the
core
and
just
call
it
dotnet
five
and
then
the
next
versions
done
at
six
done
at
seven
and
so
on
and
so
forth.
So
that's
fundamentally
what
it
is
so
I
think
I've
done
at
five
as
effectively
just
dotnet
core
plus
plus
right.
It's
just
an
evolution
of
the.net
core
platform
with
more
features.
But
fundamentally
it's
it's
the
dotnet
core.
You
already
know,
so
it's
not
fundamentally
different
beast
yeah.
B
I
think
that's
great
there's
a
couple
things
on
the
salmon
side.
I
could
add.
I
am
NOT
a
salmon
programmer,
but
my
role
in
the
SDK
I
am
involved
in
figuring
out
how
some
of
this
is
actually
going
to
come
together
on
the
ground
in
the
things
that,
in
the
best
we
deliver
and
xamarin
is
going
to
be
able
to
run
on
dotnet
core.
That's
with
that.
That's
what
that
arrow
actually
means
is
right.
Now
it
runs
on
on
mono
it'll
run
on
dotnet
core
right.
A
B
A
Still
like
the
idea
of
dotnet
standard,
yes,
the
the
primary
idea
of
torreón
standard
is
to
write
class
Labatt's
that
run
in
multiple
environments
and
that
one
will
still
be
available
for
donate.
Five
and
I
will
talk
about
how
that
will
work
in
a
bit
more
detail.
The
other
question
was
dotnet
course
cross-platform.
Does
it
mean
women
are
cross-platform?
No.
B
A
Of
course,
we
remain
or
I
don't
net.
You
know
cross-platform
story.
The
the
bigger
problem
that
you
have
today
is
that
if
you
want
to
run
in
multiple
environments,
you
know
there's
two
ways
to
go
about
this.
One
of
them
is
you
just
write
code
once
and
that
code?
You
only
use
this
cross-platform
concept
and
it
works
everywhere,
but
it
only
gets
you
so
far
right
if
you
want
to
build
an
application
that
feels
native
on
iOS
or
feels
native
on
Android
or
feels
native
on
Windows.
A
Eventually,
you
want
to
call
AP
is
that
are
specific
to
these
environments
and
one
of
the
goals
we
have
of
dotnet
is
to
make
these
transitions
between
cross-platform
and
perform
specific,
very
easy
and
also
give
you
tools
and
tooling,
and
you
know
in
form
of
IDE
and
other
things
to
not.
Let
you
accidentally
call
cut
from
specific
API
is
right,
so
there
still,
you
can
do
it,
but
we
want
to
make
sure
that
you
are
aware
when
you
do
it
and
make
sure
that
it's
intentional.
A
A
So
don't
sign
it
like
I
mean,
let's
just
go
back,
one
slide
here
and
I
hope
I
can
zoom
in
actually
I.
Think
I
can
yes,
I
can.
So
when
you
look
at
the
slide
here
right,
you
realize
we
have
three
different
platforms
and
then
there
is
this
bottom
layer
that
we
draw,
which
is
dotnet
standard.
Really
what
this
is
it's
kind
of
I
don't
want
to
say
the
word
fake,
because
it
sounds
very
negative,
but
it's
very
I
think
it's
a
good
mental
model
to
think
about
this
right.
A
So
the
the
big
boxes
you
have
on
top
I,
actually
physical
implementations,
but
these
are
actual
runtime.
This
is
an
actual
fabric.
Implementation
of
actual
you
know,
code
behind
it,
doting
Senate
doesn't
have
any
code
or
no
Senate
is
just
effectively
the
shell
or
the
you
know
the
set
of
API
is
that
they
all
share.
So
it's
it's.
It's
a
it's
a
synthetic
framework
right.
It's
a
it's,
a
virtual
frame
that
you
can
target,
but
you
still
need
an
actual
implementation
to
run
on
what
that
means
in
practice.
A
Is
that
if
you
want
to
add
an
API
to
dotnet
standard,
we
have
to
implement
this
API
multiple
times
right
ones
for
framework
ones
for
core
ones
for
zimmern
right
and
then
that
dead
basically
always
means
that
the
standard
by
definition
has
to
lag
behind,
but
the
value
is
that
what
we
have
three
different
platforms?
And
you
don't
want
to
write
code
three
times
if
you
target
the
standard,
you
can
basically
pretend
there's
a
single
framework
by
the
virtual
that
we
have
this.
You
know
you
know
set
of
API.
B
A
It's
just
one
code
base
right,
there's
only
one
base
class
library
where
these
things
are
in
now,
so
so,
in
other
words,
that
no
means
that
the
standard
would
Rev
effectively
at
the
same
cadence
as
the
implementation
and
because
the
API
said
is
not
identical.
No,
that
begs
the
question
of
like:
what's
the
value
in
having
the
standard
at
all,
if
you
can
just
target
them
at
five
and
have
everything
work
everywhere
already
right,
so
that's
kind
of
the
end
of
the
idea.
I
want.
B
To
be
super
clear
on
that,
so
Dinah
standard,
T
dot,
a
retains
its
values
is
going
cross
platform
with
dotnet
framework
because
it's
stable
it
never
needs
more
than
dotnet
standard
2.0,
because
it's
not
gonna
have
new
api's,
so
don't
nest
an
or
two
Toto
stay
super
important,
but
future
versions,
of.net
standard,
if
they
exist,
won't
have
the
same
kind
of
role
because
the
going
forward
after
T
one
whatever
comes
next.
That
would
just
be
this
the
same
because
now
xamarin,
happily
xamarin
and
Donette
core
will
be
the
same.
So
yes.
A
A
So
let
me
mean,
let
me
just
motivate
this
a
bit
more.
So
if
you
look
at
today's
world
of
NuGet
package
authors,
this
is
what
it
looks
like.
So
I
picked
a
few
examples,
so
Newton
so
Jason.
This
is
what
it
looks
like
inside
of
Newton
soft
Jason.
What
you
see
here
is
what
we
call
T
FM's,
which
basically
means
target
framework
names,
and
so
that's
basic,
just
the
representation
of
all
the
boxes
that
we
showing
these
layer
diagrams
right.
A
A
If
you
will
that
tries
to
standardize
things
like
access
to
GPS,
access
to
sensors
and
that
sort
of
thing
and
look
at
all
the
names
you
see
there
and
then
even
a
very
simple
lightweight
they'd
be
very
recently
shipped
a
system
text
or
JSON,
which
is
a
very
simple
library,
because
it's
just
you
know,
parts
in
some
Jason
still
targets
to
different
platforms
right.
So
if
you're
new
to
net
and
you're
trying
to
make
sense
of
this,
like
this
is
kind
of
the
experience
you
have
you're
like
what
what
do
all
these
names
mean?
A
Why
are
all
these
version
numbers
there
like?
How
do
they
relate
to
each
other?
How
do
I
make
sense
of
that
right
and
that
is
kind
of
the
fundamental
problem
of
dotnet
standard?
If
you
will,
because
don't
add
standard
by
definition,
is
the
synthetic
framework
that
others
implement,
so
you
kind
of
have
to
have
this
decoder
ring
somewhere.
That
tells
you
which
version
of
the
platform
is
compatible,
which
version
of
the
standard
right
and
that's
that's,
a
fundamental
complexity
that
we
really
can't
remove
unless
we
start
removing
some
boxes
from
these
layer
area
grams.
A
So
one
question
that
we
often
get
is
like:
why
can't
we
just
have
a
single
framework
right?
This
is
the
hold
on
at
five
question.
Basically
does
not
need
five
mean
we
have
a
single
thing
and
the
answer
is
sort
of
no,
because,
yes,
if
you
think
of
the
doughnut
platform
API
as
meaning
things
in
the
system
namespace,
like
collections,
networking
that
sort
of
thing
yeah,
we
will
have
a
single
thing
for
that,
which
is
basically
what
Nets
an
it
is
today.
A
But
of
course,
if
you
build
an
iOS
application,
you
also
need
access
to
iOS.
Api
is
right
and
if
you're
building
an
Android
app,
you
need
to
have
access
to
Android
API
and
if
you're
building
a
Windows,
uwp
I
mean
the
access
to
WinRT,
API
is
and
so
on
and
so
forth.
Right,
and
so
these
are
very
often
you
know,
native
operating
system.
Api
is
but
on
dotnet
in
order
to
make
them
callable.
We
have
you
know
some
sort
of
projections
for
those
where
we
have
a
managed
api
is
summer.
A
That
looks
like
a
dotnet
api,
but
it
really
calls
know
as
api.
So
the
question
now
is
under
which
circumstances
can
you
see
these
api
is
if
we
only
have
a
single
framework?
What
what
makes
it
invisible?
How
can
we
reason
about
compatibility
if
we
smash
them
all
together?
So
one
option
we
have
is:
we
could
literally
make
the
API
available
everywhere
and
then
just
say:
the
iOS
API
is
only
work
on
iOS
and
that's
throw
everywhere
else.
But
now,
if
you
think
about
this,
you
know,
there's
not
like
tens
of
us.
A
Api
is
there's
thousands
of
iOS
API.
Is
it
really
doesn't
make
sense?
If
we
deploy,
you
know
thousands
of
api's
to
your
Android
app
and
all
they
do
is
throw
write
that
that
would
be
very
wasteful
and
then
yeah.
Of
course,
we
can
imagine
linkers
or
other
stuff
that
can
link
them
out,
but
it
seems
backwards
to
add
all
the
api's
and
then
try
really
hard
to
remove
them
again.
So
we
need
some
sort
of
representation
where
you
can
say
in
your
library.
A
A
But
it's
not
just
implementations.
Also
API
is
right
if,
like
skier
shop,
for
example,
is
a
UI
wrapper,
so
completely
makes
sense
to
say
if
you're
on
iOS,
you
have
more
API
since
gear
shop,
for
example
a
constructor
that
takes
an
iOS
image
on
android,
android
image
and
so
on
right.
So
it's
not
just
implementation.
It's
also
api,
so
visited
library.
Authors
want
to
vary
based
on
whether
one.
So
in
order
to
do
this,
we
have
wasted
two
options.
A
We
can
just
do
what
we
currently
do,
which
is
this
crazy
picture
I
had
initially
or
we
can
try
to
improve
this
and
actually
remove
the
number
of
names
we
do
right.
So
what
does
it
mean?
Well,
it
would
mean
if
you
continue
what
we
currently
have.
It
would
just
have
a
net
core
app
5,
because
dotnet
core
is
neck
wrap
and
you
get
speak.
A
Xamarin
already
exists
as
Thurman
Iowa
says:
I'm,
an
Android
they're,
not
all
versions,
so
one
change
would
just
make
it
so
that
you
can
actually
Express,
which
iOS
versions
you're
targeting
and
it
would
have
an
X
standard
5
and
an
instant
5
would
just
be
the
portable
bchow
that
once
everywhere.
So
what's
wrong
with
that.
Well,
one
thing
that's
wrong
with
that
is
that
the
naming
that
we
now
have
doesn't
really
reflect
the
product
anymore
might
be
called
the
dot
at
five.
A
B
A
B
The
application,
so
we
don't
think
this
is
the
way
people
will
think
about
what
they're
doing.
Basically,
what
we're
saying
is
in
simpler
words.
We
don't
think
it
makes
it's
gonna
make
sense.
We
think
you're
gonna,
look
at
this
and
add
that
same
earlier,
what's
going
on
attitude,
so
what
do
we
know?
What
we're
gonna
do?
Yes,.
A
That's
the
second
thing
so
there's
the
other
problem
we
have
is.
We
still
have
to
explain
the
difference
between
a
senator
net
core.
So
even
if
we
say
net
standard
and
a
core
app
version,
all
this
in
conjunction,
you
still
have
to
explain
what
the
difference
between
the
two
is,
which
we
really
don't
want
wallet
right
and
then
well.
There
is
already
in
that
five,
but
it
exists
in
a
new
get.
It
just
means
not
in
framework
five
right,
so
it
exists,
but
it
doesn't
mean
people
think
it
means.
So
that's
also
problematic.
A
A
Not
the
way
we
think
about
this
yeah,
so
the
second
thing
is:
let's
change
the
way
we
do
that,
and
so
basically
the
idea
would
be:
let's
actually
use
them
at
five,
because
we
know
we
will
never
ship
a
dotnet
framework
five.
So
we
don't
have
to
reserve
that
name.
If
you
will
so,
we
will
use
net
five
to
mean
dotnet.
You
know
five,
which
you
know
is
what
people
would
probably
think
anyway
and
then,
in
order
for
us
to
express
what
works
everywhere
versus
what
works
only
in
particular
os's.
A
We
just
have
this,
unfortunately,
very
small
naming
convention
here,
so
imagine
you
say:
net
five
and
that
five
dash
win.
If
you
just
look
at
both
of
those
names,
it
kind
of
makes
it
clear
that
net
five
means
everywhere
and
that
and
that
five
win
means
windows-only.
And
so
now,
if
you
look
at
a
new
day
package
and
look
at
those
names,
you
can
reason
about
those
names
right.
A
B
I
mean
I
think
in
the
end,
you're
gonna
look
at
this
and
go
yeah,
it's
simple:
how
could
it
be
any
other
way?
Well,
certainly
the
hope,
but,
as
you
see
us
go
through
this
massive
amount
of
thinking,
we've
been
doing
on
simplifying
it,
then
it
sounds
like
you're.
So
much
extra
information
here
right
that,
but
we
do
want
to
show
that
with
you.
That's
the
purpose
of
community
stand-up
is
so
that
you
got
some
insight
into
our
process
and
how
we
think
about
these
an
early
feedback.
So
what
do
we
have
there?
So.
A
One
question
that
was
earlier
was
isn't
that
the
standard
useful,
if
you
have
a
different
implementation
of
dotnet
and
I,
hear
this
question
quite
a
lot,
but
like
here's,
the
thing
right,
if
you
were
to
build
a
new
thing
like
a
toaster
or
something,
and
you
want
to
have
it
on
a
platform
for
that,
you
would
be
insane
to
implement
this
thing
from
scratch.
There
would
be
a
lot
of
work
right.
Nobody
does
that.
A
They
did
not
build
their
own
dotnet
flavor,
that
let's
use
dotnet
core
and
they
have
their
own
TFM,
but
basically
they
suck
in
the
code
from
content
core,
so
they're
always
up
to
date
with
respect
to
you
know
all
this
darkness
and
that
support,
and
so
in
that
sense
it
doesn't
really
matter.
But
that's
not
necessarily,
you
know,
donate
five
like
the
idea
would
be
the
base.
Layer
is
the
same
everywhere,
but
the
base
layer
is
an
actual
implementation.
That
is
the
same
everywhere.
A
So
if
there's
innovation
in
the
base
layer,
everybody
can
just
get
the
innovation
by
just
sucking
in
the
latest
version.
You
don't
have
to
wait
for
somebody
like
Samsung
to
also
implement
these
api's
again
right.
That's
just
not
how
that
makes
sense.
So
then,
the
other
question
I
think
was,
although.
B
A
Yeah,
so
wisdom
is
interesting
case,
so
wesam
you
can
think
of
wisdom
as
an
as
a
programming
model,
or
you
can
think
of
it
as
a
architecture
for
CPU
and
soon
that
sense,
you
can
say
either.
Wisdom
is
something
like
X,
64
or
x86
right,
where
it's
just
different
instructions
that
are
being
emitted
by
the
JIT.
If
you
will,
or
you
can
think
of
it
as
a
program
platform.
The
way
we
think
about
wisdom
right
now
is
that
it's
basically
like
a
CPU
architecture.
A
It's
a
it's
a
it's
a
standard
and
how
you
can
emit
code.
That
runs
in
the
browser,
and
in
that
sense
we
don't
have
frameworks
for
x86
and
x64
right.
We
just
say
that's
just
normal
portable
code
and
the
amount
of
cases
where
you
have
to
specialize
between
them.
You
just
either
do
if
devs
or
you
just
do
runtime
checks,
but
we
don't
really
have
different
frameworks
for
that,
because
you
generally
don't
want
to
have
different
api's
between
X
6
is
4
and
X
66
right.
A
C
B
A
B
B
This
is
a
very
different
situation,
but
I
have
a
stable
framework
that
your
apps
can
continue
to
run
on,
and
you
have
almost
everyone
who
has
legacy
has
a
percentage
of
their
legacy
generally,
a
very
large
percentage
that
takes
few
changes,
it's
doing
its
job,
that's
why
you
want
to
preserve
it
and
just
leave
it
on
dotnet
framework
indefinitely.
It
won't
be
cross-platform,
but
Windows
will
continue
to
give.
You
updates
you'll
continue
to
have
that
experience.
B
There's
a
lot
of
changes
in
dotnet
core
other
than
it
just
being
cross-platform,
as
you
have
something
that
makes
sense
for
your
organization
to
move
forward,
then
move
it
forward.
Maybe
initially
that's
just
new
apps
later
on.
It
might
be
some
things
that
need
some
deeper
concern.
Maybe
you
want
to
get
off
of
web
forms,
so
there
is
going
to
be
reasons
to
move
forward,
but
we
do
not
expect
the
this
great
big
legacy
world
to
move.
We
did
everything
possible
to
make
this
something
you
move
at
your
organization,
speed,
not.
A
B
Speed
and
it
just
it
really
isn't
the
same
thing
as
we
lived
through
when
we
made
the
old
systems,
not
very
usable
anymore.
In
this
case,
we've
done
we're
really.
The
stability
is
a
feature
for
those
old
legacy
applications
and
we
really
want
to
we're
really
we're
maintaining
that
it's
there
and
there's
a
huge
commitment
to
that.
Ok,.
C
A
Like
this
is
basically
what
this
table
shows
you,
so
if
you
think
of
it
from
the
left-hand
side,
this
is
these.
Are
the
new
names
we're
introducing
and
then
on
the
right
hand,
side
you
see
what
packages
can
you
install
so
effectively
when
your
net
5?
You
can
of
course
install
them
in
framework
packages
exactly
like
you
can
do
today.
If
you
are
not
at
core,
you
can
install
on
environment
packages,
you
just
get
a
warning.
A
The
only
thing
here
is
that
if
we
target
in
that
core,
app,
300
or
3-1
today
includes
WPF
WinForms
and
it's
a
bit
hard
for
me
to
explain
how
that
is
represented.
But
you
will
get
an
arrow
if
you're
on
the
next.
So
it's
not
like
you
get
weird
arrows
there,
but
like
the
you
will
get
to
get
an
arrow.
That
tells
you
that
you
can't
reference
this
thing
from
from
the
next.
A
But
the
idea
is
that
internet
5.5
will
be
like
dotnet
standard
as
and
we
will
not
have
access
to
WPF
and
WinForms
in
it.
So
you
can
reference
not
neckwear
app,
except
when
you
reference
w
pavement
forms
and
you
get
a
warning
like
you
would
expect
and
then,
of
course,
we
100%
compatible
with
net
standard
and
then
there's
some
new
names
for
introduced
net
5
win
that
you
can
think
about
this
being
compatible
of
dotnet
core
app
one,
two
or
three
one
entirely,
and
that
also
means
this
is
the
Arabic.
A
You
would
have
access
to
WPF
element
forms
and
probably
also
uwp
or
whatever
the
evolution
of
that
platform
would
look
like
and
then
same
thing.
We
would
have
a
net
fire,
there's
iOS,
which
is
basically
the
successor
of
Zimmerman
that
iOS,
so
you
would
expect
to
be
able
to
install
those
into
that
same
with
Android
and
then,
as
you
can
see
here,
we
entertained
the
idea
of
having
that
five
touch
browser
and
for
wisdom.
But
as
we
were
talking
with
the
Blazer
team,
it
was
very
clear
that
it
would
be
the
wrong
direction.
B
B
C
B
B
A
A
B
Yeah,
we
just
have
to
notice,
if
ik
to
that
we're
trying
to
make
it
simpler
than
it
used
to
be
where
you
had
to
reference
all
this
stuff
and
it
got
to
be
the
crazy,
huge
project
file.
So
that's
why
we're
we're
doing
some
special
things
that
then
msbuild
can
pick
up
and
get
the
right
test
targets
packages
all
help.
You
get
all
that
in
there
from
these
same
lines
in
the
project
file,
which
was
easy
to
get
to
as
soon
as
we
said.
A
So
yes,
I,
think
also
useful
chart
like
use
what
we
will
target
right,
so
a
spinet
Cora
entity
framework
virtually
all
of
our
auto
band.
You
get
packages
that
are
in
the
system.
Namespace
most
libraries
will
target
net
5
because
it's
basically
the
successor
like
the
way
to
think
about
net
5
is
it's
really
convert,
is
a
converged
version
of
net
senator
net
core
right.
So
that
means
these
are
the
set
of
API.
A
So
it
will
work
everywhere
and
then
the
things
that
are
West
Pacific
on
the
windows
side,
winforms
WPF
uwp-
will
be
a
net
5
min
and
then
on
the
sermons
side,
same
thing
right,
but
then
there's
also
these
things
that
are
by
building
abstractions,
but
Zemin
forms
is
not
specific
to
iOS,
but
Zemin
forms
as
an
abstraction
over
the
operating
system,
similar
to
sermon
essentials.
And
so
basically
the
idea
here
is
that
they
will
have
a
new
get
package
where
they're
basically
multi
targeting.
A
A
B
A
B
C
It's
I
mean
it's,
it's
sort
of
like
in
a
way,
almost
sort
of
like
this
self-imposed
for
a
good
reason:
okay,
confusion
because
we
be
like
Oh
dotnet.
Is
this
multitude
of
things
and
now
we're
saying?
No,
no
dotnet
is
this
thing,
but
people
are
a
lot
of
people
have
now
gotten
used
to
the
ODOT
net.
Is
now
this
multitude
of
things
I
think.
A
The
one
thing
that
comes
up,
like
you
just
said
that
don't
need
five
slices.
Successive
donut
framework
by
version
number
that's
kind
of
its
kind
of
what
we
try
to
do.
In
all
seriousness,
I
mean
we
try
to
say
it
is
bigger
than
donut
framework
for
X.
So
is
the
logical
successor
and
yes,
we
know
that
we
will
confuse
some
of
our
existing
customers,
but
sorry.
B
A
We
are
more
optimizing
for
the
person
that
our
net
new
to
this
deck,
because
today,
it's
impossible
for
somebody
to
learn
net
and
make
sense
of
all
these
names.
In
order
to
make
sense
of
these
names,
you
basically
have
to
have
15
years
of
history
on
net,
and
that
is
not
a
good
good,
good
good
way
to
begin
I'm.
B
A
A
B
A
A
A
B
A
Have
literally
different
implementations
for
operating
system
versions
for
architecture,
specific
stuff,
but
Ritz
only
today
allow
you
to
very
implementation.
They
do
not
allow
you
to
very
API
surface
the
way
new
networks,
and
so
because
of
our
multi
targeting
requirements
that
we
do
want.
An
API
service,
Ritz
wouldn't
have
worked,
and.
A
A
A
So
Ritz
are
still
in
existence
and
you
can
still
use
them
and
you
still
have
to
use
them.
In
fact,
when
you
have
to
deploy
native
assets
right,
because
the
only
way
you
can
deploy
native
assets
because
there
are
clearly
operating
system
and
architecture-specific,
you
have
to
use
Ritz
for
that.
But
that's
a
very,
not
a
mainstream
scenario.
So.
B
B
It's
saying
we're
going
for
saying
beautiful
as
good.
We
like
that,
but
we
know
that
we
have
asked
a
lot
of
people
in
terms
of
what
they
understood
in
order
to
come
for
genetic
or
and.net
five-hour
art,
all
the
teams.
We
have
a
real.
We
have
a
commitment
to
simplifying
that
where
we
can
there's
some
new
complex
things
coming
and
I
think
next
month
we're
going
to
talk
about
optional
components
and
what
that's
going
to
mean,
and
so
we're
working
to
keep
the
complexity
out
of
that.
B
B
A
B
Yeah,
so
I
don't
have
a
demo,
but
I
do
want
to
talk
about
something,
because
we
do
see
this
as
an
opportunity
to
show
you
all
our
process
and
to
give
you
super
early
conversations
about
things
and
so
I'm
to
get
it
admit.
I
got
called
out
a
little
bit
on
Twitter
last
week
and
I
think
it's
really
good
when
almost
all
of
it
stayed
like
I'm,
not
always
gonna,
say
kind,
but
it
didn't.
It
didn't
get
obnoxious
which
I
really
appreciate,
but
it's
all
about
done.
B
It
config
and
it
came
from
a
particular
set
of
customers
that
are
hurt
most
by
the
fact.
We
don't
have
configuration
for
the.net
CLI
right
now,
and
the
specific
problem
is
that
F,
sharp
customers
Phillip
was
in
this
conversation.
F,
sharp
customers
have
to
type
lang.
Equal
F
sharp
in
templates
a
lot
because
the
CLI
doesn't
remember
what
language
you're
working
in.
So
you
say
you
know
dotnet
new
blah
and
then
you
have
to
say
Lang
or
Lang
I'm.
B
Is
we
don't
know
what
your
repo
group
is
and
so
there's
a
couple
of
things
that
that
we've
thought
about
on
that.
Obviously,
if
you
can
get,
we
know
where
your
repo,
yes,
unfortunately
or
fortunately,
because
it
keeps
a
varied
ecosystem,
not
everybody's
on
get
and
not
everybody
uses
the
solution.
File
and
a
solution
file
isn't
a
good
marker,
because
you
might
want
this
to
be
above
your
solution,
and
so
we
basically
have
been
having
conversations
now
that
we
are
going
to
ignore
that
problem.
Say
it's
in
your
hierarchy.
B
Now
that
global
debt
Jason
supports
that
or
even
a
preview
strategy,
which
is
also
in
global
debt
Jason
when
you
just
put
in
that,
you
didn't
want
previews
or
you
wanted
to
roll
forward
across
all
majors.
As
soon
as
you
put
that
global
that
Jason
in
we
wouldn't
see
your
f
sharp
statement,
we
wouldn't
know
it
was
there
so
a
dotnet
config,
you
know,
assuming
that
we
get
it
in
this
is
just
early
thinking.
Would
it
will
it
will
collect
all
the
information
up?
B
The
stack,
it'll
smash
them
all
together
closest
to
the
project
for
a
particular
item
will
be,
will
win,
but
you'll
be
able
to
will
be
able
to
combine
things
from
multiple
files.
We
expect
them
to
exist
at
two
levels:
your
development
route,
for
your
language
of
choice
for
those
people
that
have
a
language
of
choice
and
your
solution
for
things
or
you
sell
your
repo
for
things
are
associated
with
that.
The
reason
I'm
asking
is
because
I
really
love
feedback
on
anything.
B
B
You
other
thing
is
that
right
now
for
consistency
with
some
backward
stuff,
if
you
do
a
publish
our
default
for
publishes
debug
in
I'm
kind
of
sorry,
but
we
are
having
trouble
changing
that
from
a
backwards
compatible,
and
so
you
could.
We
will
have
something
that
says
your
release
configuration
and
so
you
can
say
not
debug,
please
and
set
that
so
there's
going
to
be
a
couple
of
things.
B
But
if
you
have
any
ideas,
then
let
me
know
we
won't
put
it
in
the
solution
file
that
came
in
on
the
chat
for
two
reasons,
one
of
which
is
not
everyone
uses
solution
files
and
the
other
is
that
that's
a
very
visual
studio
thing
and
particularly
off
of
windows.
People
don't
use
them
and
the
other
thing
is
it's.
It's
kind
of
a
format
that
we
would
like
to
not
get
involved
with.
B
There's
a
lot
of
history
with
that
format,
and
it's
going
to
be
very
painful
to
ever
change
it,
and
we
don't
really
want
to
use
that
format.
It's
not
a
good
format
for
you
to
edit,
and
this
would
be
something
we'd
expect
you
to
edit,
and
is
there
anything
else
on
that
on
the
question
stream?
You
can
help
me
scroll
back
and
get
all
these
questions.
B
B
B
C
B
C
A
C
To
the
studio,
no,
this
is
not.
This
is
Jupiter
notebooks
anybody
who's
done
any
kind
of
data.
Science
is
probably
familiar
with
this.
At
some
point,
Jupiter
notebooks
were
also
used
outside
of
data
science.
What's
really
great,
is
they?
Are
there
a
way
to
do
interactive
programming,
but
also
produce
a
shareable
artifact
afterwards?
C
That
can
become
a
document,
so
this
is
actually
something
that
I
shared
in
a
an
f-sharp
meet-up
that
I
did
in
South
Korea
a
couple
of
weeks
back
demoing
some
of
the
very
first
pieces
of
F
sharp
5.0,
and
it
actually
just
produces
a
document
that
you
can
render
as
markdown
effectively
on
github.
So
you
can
so
you
can
see
it,
but
it's
also
executable
in
a
Jupiter
environment.
C
B
C
The
link
to
other
different
things,
and
so
there's
a
few
things
that
you
have
to
install,
but
everything
is
ultimately
just
a
global
tool
and
then
you
can
install
Jupiter
from
there
and
then
you
can
invoke
Jupiter
lab
from
the
command
line,
which
is
what
I
did
here
and
so
that
will
spin
up
a
Jupiter
lab
environment.
This
is
a
Jupiter
notebook
thing,
and
so,
when
you
create
a
new
notebook,
you
can
pick
between
Python
C,
sharp
F,
sharp
I
have
a
Julia
Colonel
installed.
C
A
new
version
of
it
will
also
have
a
PowerShell,
and
in
the
case
of
the
dotnet
kernel,
you
can
actually
mix
and
match
C
sharp
and
F
sharp.
But
an
interesting
thing
here
is
because
this
is
sort
of
more
like
an
interactive
ad
hoc
thing,
like
you
know,
you're,
not
producing
notebooks.
That
are
like
these
deplorable
thing.
You
know
this
isn't,
like
you
know,
a
binary
that
you
produce
that
you
deploy
to
a
web
app,
it's
something
that
you
want
to
play
around
with.
You
want
to
learn
from.
C
You
want
to
learn
more
about
dotnet,
so
we
have
the
preview
versions
of
languages
actually
distributed
with
these
kernels.
So
in
this
case
the
F
sharp
5
preview,
if
you
want
to
interactively
play
around
with,
what's
gonna,
be
coming
for
f-sharp,
5.0
and
kind
of
see
how
it
looks.
This
is
a
really
really
great
way
to
do
it,
and
you
can
also
share
the
results
of
that
with
people.
C
So,
speaking
of
f-sharp
5,
there
are
quite
a
few
things
that
are
going
to
be
in
the
first
preview
of
that
which
is
going
to
coming
with
net
5
preview.
1
I'm
not
going
to
go
over
all
of
it
today,
because
that's
too
much
to
do
with
not
a
whole
lot
of
time,
but
I
am
going
to
cover
some
of
the
things.
So
the
first
is
slices
and
indexes
in
F
sharp,
so
slicing
and
indexing
has
already
existed
in
the
language
right.
C
I
can
execute
a
cell
I
can
create
a
list,
I
can
create
an
array,
I
can
create
a
string,
and
these
are
considered
indexable
and
sliceable.
In
fact,
you
know
I
could
just
do
this.
I
go
L
dot.
You
know
zero
and
that's
one
if
I
go.
You
know
the
zeroeth
index
of
s,
that's
H
the
0th
index
of
a
that's
one,
that's
pretty
straightforward,
but
where
things
could
get
a
little
bit,
weird
was
if
you
started,
throwing
negative
in
negative
indexes
and
ranges
there.
C
So
in
the
past,
lists
behaved
one
way,
but
then
arrays
and
strings
behaved
a
different
way,
and
that
was
just
bizarre.
So
what
I
executed
here
is
I
actually
just
did
sort
of
this
nonsensical
range
expression
in
the
past.
The
string
and
the
array
versions
would
throw
an
exception,
but
the
list
one
would
not,
and
so
then
we
thought
about
it.
C
Well,
it's
actually
pretty
common
at
F,
sharp
to
compose
sub
lists
and
sub
strings
and
sub
arrays
together
and,
if
you
have
say
an
empty
list,
while
an
empty
list
composes
with
any
other
list,
write
empty
lists.
Plus
some
list
is
just
that
list.
Empty
array,
plus
that
you
know
the
empty
string
appended
to
another
string,
is
just
that
same
string
effectively
like
they're
equivalent
in
that
in
that
sense,
so
because
one
of
our
collection
types
was
already
not
throwing
an
exception,
it
was
already
composable
that
way.
C
We
said:
okay,
let's
just
go
ahead
and
make
arrays
and
strings
do
that
as
well,
so
it's
a
consistent
and
what
we're
calling
tolerant,
behavior
for
slicing.
So
that
way,
like
you
know,
slicing
with
literals,
it's
pretty
obvious
that
this
is
kind
of
a
silly
thing
to
do,
but
if
you
could
imagine
instead
of
negative
two
that
said,
X
you're
gonna
have
to
write
a
lot
of
code
all
the
time
you
know
performing
these
checks
every
single
time.
C
You
do
one
of
these
things
and
we
didn't
think
that
there
were
too
many
drawbacks
to
just
returning
an
empty
list
in
this
case,
because
that
was
already
happening
and
then
we
said
okay.
Well,
if
it's
an
array
or
a
string,
that's
probably
gonna
make
sense
to
so.
We
should
at
least
be
consistent
across
our
own
intrinsic
collection
types
that
we
have
there.
So
speaking,
more
slicing
and
indexing,
we
have
three
dimensional
and
four
dimensional
arrays
in
the
F,
sharp
core
library
and
they
were
indexable
and
they
were
sliceable.
C
However,
they
weren't
quite
sliceable
and
indexable,
and
the
way
that
people
necessarily
wanted
so
I
have
actually
a
three
dimensional
array
here:
I'm
representing
it
as
two
two-dimensional
arrays
sort
of
sliced
by
the
Z
index.
It
just
goes
from
zero
one,
two,
three
four
five,
six
seven,
but
then
there's
this
question
of
saying,
say:
I
wanted
to
get
an
array
slice
of
four
and
five
out
of
this
three
dimensional
array.
How
do
I
do
that?
C
Well,
first
I'm
just
going
to
construct
one
of
those
three
dimensional
arrays,
and
then
this
is
code
that
you
would
write.
You
would
say:
I
want
to
I'm
going
to
go.
You
know
that
matrix
M
I
don't
care
what
the
X
index
is,
but
then
I
want
to
get
the
zeroeth
and
the
first
from
the
Y
and
the
Z
right.
So
I
want
to
be
on
the
zero
with
Y
right
here.
I
want
to
get
the
full
X.
That's
four
and
five
and
I
want
to
be
on
the
Z
index
prior
to
F
sharp
5.0.
C
B
C
C
Basically,
so
this
is
good
if
you're
doing
numeric
programming,
because
you're
probably
going
to
be
working
with
three
dimensional
arrays,
and
so,
if
you
have
your
own
collection
types
that
are
n,
dimensional,
arrays
or
you
know
other,
you
know,
you're
working
with
more
than
three
or
four
dimensions.
There's
a
technique
that
we
do
to
implement
this
on
our
own
three
and
four
dimensional
arrays
that
could
be
applied
to
those
collection
types
if
you're
interested,
but
at
least
in
terms
of
what
exists
in
the
F
sharp
core
library.
C
You
can
now
be
fixed
index
slicing,
which
is
nice.
So
then
we
also
have
from
the
end
slicing
in
indexes,
which
is
pretty
neat
so
say:
I
have
a
list
from
one
to
ten
and
then
I
want
to
get
the
element.
That's
one
from
the
end
in
the
past.
You
would
have
to
go
X's
yeah,
X's,
dot,
length,
minus
one
I'm,
pretty
sure.
Oh
no,
sorry
sue!
You
would
have
to
do
that
because
the
end
index
is
inclusive
in
f-sharp
ranges.
Today
this
is
kind
of
terrible
code.
C
You
just
want
to
go
run
from
the
end
right.
So
then
you
get
the
the
value
9
out
of
that
list,
1
through
10,
and
so
this
just
sort
of
demonstrates.
You
know
slicing
right.
This
say:
I
want
to
I
want
to
take
a
slice,
that's
one
from
the
end.
Until
the
end,
I
would
have
to
go
X's
dot,
length,
minus
2,
dot
dot,
but
now
I
just
go
one
from
the
end,
dot,
dot
right
and
that's
just
pretty
straightforward.
There
somebody
says
remind
similar
methods.
C
C
Code
that
looks
like
this:
you
can
just
trivially,
reduce
it
to
and
from
the
end
index
right,
but
F
sharp
also
supports
providing
indexes
and
ranges
on
custom
types
or
perhaps
types
that
you
don't
own.
So
in
this
case
the
span
of
T
type,
we
can
actually
use
F,
sharp,
slicing
and
reverse
index
syntax
on
it,
even
though
we
don't
implement
the
the
range
and
index
types
and
the
framework,
and
that's
just
the
way
that
it
works.
When
you
want
to
create
your
own,
you
want
you,
your
own
slices,
your
own
indexes.
C
That
sort
of
thing
is
all
you
do.
Is
you
just
you
just
implement
a
specific
member?
In
this
case
we
have
a
member
called
get
slice
and
a
member
called
get
reverse
index
and
so
dimension
believe
that
should
work.
Ok,
so
in
this
case,
get
reverse
index
takes
a
dimension
and
an
offset,
and
the
reason.
Why
is
because
you
want
to
be
able
to
get
the
reverse
index
of
an
N
dimensional
thing,
and
so
we
have
that
as
a
parameter.
C
You
can,
in
this
case,
I'm
ignoring
it
because
span
is
not
multi-dimensional
and
then
get
slice
is
just
extracting
a
specific
piece
of
the
this
pan
and
so
I'm.
Just
calling
span
api's
directly
on
this
and
then
I
have
a
function
that
prints
out
a
given
span
of
int
and
then
prior
to
F
sharp
5.
You
could
actually
write
this
code
where
you
could
say
I
want
to
slice
it.
C
You
know
from
zero
to
the
end
from
the
beginning,
up
until
3
from
1
to
3,
but
I
can
actually
write
that
equivalent
code,
using
only
from
the
end
indexes,
if
I
truly
wanted
to
so
from
the
beginning,
up
until
0
from
the
F
from
the
beginning,
up
until
2
from
the
end
and
from
4
from
the
end
to
2
from
the
end.
That
sort
of
so
this
is
kind
of
nonsense
code.
C
So,
if
you're
working
with
a
package,
that
is
an
N
dimensional
array-
and
you
want
to
have
a
reverse
index
on
that
n
dimensional
array-
you
can
implement
it
exactly
like
this
and
you
just
index
into
the
specific
dimension
for
that
array
and
then
what
whatever
you
want,
the
offset
rule
to
be
like
how
many
from
the
end
of
its
1
from
the
end
two
from
the
end.
Hopefully
it's
gonna
be
consistent
with
how
you
do
it
within
the
rails
and
then
it
all
just
kind
of
works.
Oh
this
is
gonna,
be
an
f-sharp
5.
C
C
C
Yeah,
since
this
is
a
preview,
it's
my
okay
there,
we
go
so
like,
for
example,
so
I
type
dot
and
then
I
hit
tab.
So
this
is
because
a
Jupiter
environment
to
invoke
completion,
you
hit
tab
after
you
hit
a
dot,
and
so,
in
this
case,
I
have
access
to
some
of
the
things
that
are
on
the
f-sharp
list
type.
So
that's
what's
coming
there,
however,
there's
no,
you
know
automatic
intelligence
that
you
get
from
type
I
stuff.
That
may
that's
something
that
we're
looking
into.
C
B
B
C
They
have
their
own
ways
of
doing
things
and
we
want
to
make
sure
we
play
nice
in
that
environment.
Similarly,
there's
another
environment
called
interact
and
they
have
their
own
way
of
doing
things.
We
want
to
make
sure
we
plug
into
that.
Basically,
the
gist
of
it
is
that
if
there
is
an
environment
that
supports
LSP
and
like
Monaco
editing,
then
we
will
provide
you
know
completions
for
that,
so
you
know
getting
the
kind
of
completion
environment
that
you
might
expect
say
in
Visual
Studio
code.
That's
certainly
something
that
we
want
to
enable.
B
C
C
B
B
C
Then
that's
just
a
package
that
was
just
downloaded
I'm,
opening
that
the
namespace
there
I
created
an
anonymous
f-sharp
record
and
then
I'm
just
serializing
that
record
and
then
it
emits
it
as
JSON.
So
in
this
case,
I
can
just
download
and
install
a
package
via
f-sharp
interactive
in
the
in
Jupiter
notebooks,
environment
right
now
and
just
interactively
start
playing
around
with
package,
whereas
before
you
would
have
to
separately
download
the
package
yourself
or
create
a
your
own
project.
C
C
D
B
Gonna
keep
that
around
so
I
can't
even
reach
it.
Alright,
oh
so
much
fun,
alright!
So
at
any
rate,
it's
been
great
spending
time
with
you
folks.
Today
we
look
forward
to
seeing
you
next
time,
I
hoping
we'll
have
some
early
stuff
on
the
some
of
the
dotnet
5
construction
stuff
and
what
that's
gonna
look
like,
maybe
some
more
in
c-sharp
cuz
we
didn't
get
much
C
sharp
in
today,
always
more
F,
sharp,
always
more
BC
yeah
so
would
be
great,
always
great
fun.
Alright,.