►
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
And
we
are
now
live,
so
welcome
to
our
first
story:
community
stand
up
for
the
focus
on
languages
and
runtimes.
You
might
have
followed.
The
Internet
community
stand
up,
it's
going
on
for
at
least
a
take
a
year,
if
not
longer,
and
so
we
very
recently
expanded
this
to
the
rest
of
dotnet.
So
last
week
James
started
the
first
show
where
we
talked
about
the
mobile
stuff
and
today
we're
focusing
on
language
and
runtime
stuff
and
so
a
bunch
of
friends
here
from
all
over
the
place.
So,
let's
start
with
you,
John
John.
A
D
A
So
since
we're
live,
I
encourage
everybody
who
is
following
on
on
YouTube
and
twitch,
to
ask
questions,
and
so
goodwill
and
I'm
not
screwing
this
I'm
trying
to
follow
what
questions
they
are.
They
make
sure
we
will
answer
them
as
we
go
along
for
the
ride.
As
I
said,
you
can
follow
us
on
both
YouTube
and
twitch
I.
Don't
know
whether
you
where
you
are
right
now,
but
we
will
support
both
platforms
and
you
should
feel
free
to
comment
in
either
one
of
them,
and
so
it
should
just
work.
Fine,
ideally.
F
So
it's
going
pretty
well,
although
there's
still
quite
a
lot
of
work
left
to
do
and
some
of
what
we're
gonna
be
talking
about.
I.
Think
on
this
call
and
subsequent
calls
are
features
that
I
think
maybe
deserve
a
little
more
attention
or
where
we
have
some
specific
design,
questions
that
could
use
some
more
community
feedback.
So
I
don't
know
if
anyone
before
we
want
any
other
topic.
If
anyone
wants
to
add
anything
in
this
room
on
the
release
itself,
I
think.
A
The
biggest
one
you
said
is
WinForms
and
WPF
there's.
The
one
thing
I
would
like
to
reiterate
is
because,
when
we
shipped
and
core
b1
there
was
this
very
big
push
from
us
to
say
this
is
a
cross-platform
runtime
and
so
with
WPF
in
phones.
The
number
one
question
I
think
I've
gotten
was
so
does
it
mean
we
make
WPF
in
films
cross-platform
and
the
answer
is
no
they're,
both
windows
in
the
name,
and
we
intend
to
also
support
Windows
only
as
moving
forward,
hopefully
also
mega
only
and
Linux
only
technologies
on
top
of
donek.
A
You
are
right,
but
the
but
the
platform
itself
a
remain
cross-platform,
but
that
doesn't
mean
that
we
cannot
have
operating
system
specific
extensions
on
top
of
it
to
make
it
easier
for
people
to
write
applications
that
feel
really
native
on
whatever
particular
platform.
They
are
on.
That's
the
same
thing
we
do
for
iOS
and
Android
will
be.
You
know,
provided
with
the
ability
to
write
native
applications
for
those
as
well.
That
seems
to
be
something
worth
pointing
out
in.
F
So
in
the
past
we
were,
you
know,
trying
to
make
done:
Network
dotnet,
you
know
Dinah
framework
and
Dinah
core
works
super
well
on
really
big
machines.
So
you
know,
if
you
had
this
business,
that
was
doing
super
well
and
all
of
a
sudden.
You
know
you
start
with
a
thousand
users,
then
you
end
up
with
a
million
users
and
then,
like
ten
billion
users,
your
dotnet
site
could
kind
of
scale
along
with
your
business
and
I.
Think
we
did
well
with
that.
F
Now
we
actually
see
devices
coming
out
that
are
extremely
small,
so
raspberry
pi
is
a
good
example
of
that.
It's
like
one
gigahertz
and
like
half
a
half,
a
gig
of
ram.
Actually,
that
part
I
can't
quite
remember,
and
so
we
need
to
make
dotnet
work
well
in
those
devices.
This
is
for,
like
industrial
applications
we're
actually
talking
with
car
companies.
Volkswagen
is
an
example
and
where
we're
trying
to
make
our
products
work
better
for
them
in
these
small
small
use
cases,
and
the
other
thing
is
like
these
raspberry
pies.
F
If
you
look
at
them,
they
have
all
these
little
all
these
little
pins
on
them
and
you
can
actually
program
them,
and
so
now
we
have
libraries
if
I
had
if
I
had
thought
about.
This
I'd
actually
have
a
Raspberry
Pi
right
here,
but
you
can
actually
program
those
pins
to
like
read:
data
from
sensors
and
like
make
lights,
blink
and
you
know,
put
scrolling
text
across
LED
panels.
F
Those
are
those
are
the
sorts
of
things
we're
working
on
and
we
expect
a
whole
new
class
of
applications
to
be
written
with
net
on
devices
like
that.
So
we
shipped
a
preview
at
the
same
time
as
done
Court
preview
1,
we
actually
didn't
ship
the
library
on
nugatory.
It
was
only
on
my
get
still
I
thought
at
that
point
and
at
at
this
point,
and
we
intend
to
ship
the
library
on
nougat
org
with
preview
to
we
were
still
like
refactoring
the
library.
Quite
a
bit.
F
There's
now
in
the
repository
is
now
open,
its
at
dotnet,
slash
IOT,
and
we
have
samples
there
and
the
idea
is
that
yeah,
the
community,
it's
easy
for
them
to
adopt
IOT
and
can
work.
Alongside
with
us.
A
F
F
The
first
one
is:
we've
been
spending
a
lot
of
time
talking
about
targeting
c-sharp
eight
recently.
So,
as
you
could
imagine,
a
bunch
of
us
dog
food,
the
product,
you
know
where
we're
installing
these
previews
on
our
machine
every
day
and
trying
to
use
them,
and
a
few
of
us
observed
that
there's
this
inconsistency
in
the
product
among
many.
But
this
key
inconsistency,
which
is
when
you
start
writing
a
dotnet
core
3
Oprah
project.
F
You
know
you
get
a
preview,
runtime
preview,
CLI
and
all
that
kind
of
makes
sense,
but
you're
still
using
C
sharp
seven
dot.
Is
it
700
or
72
I'm,
actually
not
or
73
I'm,
not
sure,
but
definitely
not
c-sharp,
eight
by
default,
and
that
makes
note
that
personally
makes
no
sense
to
me
people
when
they
opt
into
installing
dotnet
core
3
builds.
They
should
get
preview
everything
and
it
should
be
super
easy
to
try
all
the
new
features.
F
That
was
not
the
case
and
we're
talking
about
how
to
make
it
so
that
c-sharp
language
versions
fit
in
to
that.
So
no,
so
that's
one
thing!
So
that's
that's
our
our
direction.
It
is
when
you
install
previews
that
you
should
get
preview
everything,
including
languages,
so
I'd
love
to
get
feedback
on
that
the
other
one
is
we've
kind
of
had
this
story
with
roll
forward,
both
with.net
framework
and
under
core
just
talking
about
dotnet
core.
That's
a
very
start.
We
only
rolled
forward
on
patch
versions.
F
So
this
is,
you
know
we
have
these
three
part
version
numbers
with
Donna
core.
It's
like
you
know,
10.6
or
you
know
two
dot,
one
dot
dot
one,
and
we
would
only
roll
forward
on
the
very
last
version
number
and
then,
when
we
shipped
dotnet
core
2.1,
we
decided
you
know
we
really
do
need
to
roll
forward
on
this
minor
version,
because
you
know
the
minor
versions
are
quite
compatible.
F
There'll
be
plenty
of
cases
where
people
will
have
a
dotnet
core,
2
app
and
nature
2.0
app
and
try
running
on
dotnet,
core
2,
1
and
people
will
be
super
unhappy
if
they're
forced
to
install.net
core
2.1,
and
so
we
made
that
roll
forward
work
as
well
and
I
actually
think
I've
heard
zero
negative
feedback
on
that
choice.
Now
that
I
think
about
it,
I
think
people
think
that's.
F
That's
rational
and
obviously
I
think
we
did
good
work
to
make
sure
that
dotnet
court
2.1
is
pretty
compatible
with
Donna
core
2.0
such
that
that's
a
reasonable
choice.
Now
this
actually
started
with
something
Kathleen
sent
out
which
was
like.
Oh,
how
do
you
make
dotnet
core
2
directs
global
tools,
work
on
Donna,
core
3.0,
which
is
an
awesome
question
and
an
awesome
scenario,
and
so
the
initial
suggestion
Kathleen
made,
which
made
a
ton
of
sense,
given
the
the
mechanisms
that
we
have
in
the
product,
is
to
multi-target
your
global
tool.
So
that
made
sense.
F
But
then
a
couple
of
us,
including
me,
said
I,
wonder
if
we
need
more
mechanism
in
the
product.
Maybe
we
need
at
least
some
scenarios
to
a
roll
forward
across
a
major
versions,
so
that
would
be
like
a
dotnet
core
2.1,
a
poor
tool
being
allowed
to
run
on
donna
core
3,
oh
by
default,
in
the
case
that
a.net
cortex
isn't
installed
on
the
machine.
So
that's
something
we're
looking
at
right
now.
We
actually
have
not
closed
down
that
discussion.
F
F
Tough
questions,
so
the
basic
idea
is,
if
you
build
an
application
for
a
given
runtime
the
best
answer.
The
best
choice
is
to
run
it.
So
you
you
built
it
targeted
for
the
specific
runtime
version
2
to
2.
The
best
choice
is
to
run
it
on
that
runtime
because
that's
what
the
developer
presumably
tested
with,
and
so
that
has
the
best
chance
of
giving
them
the
best
experience.
Now.
F
F
Now,
in
the
case
of
servicing
releases
that
we
actually
think
the
later
servicing
release
is
a
better
choice
than
what
the
developer
intended,
because
there's
a
bunch
of
security
patches
in
there,
the
other
ones
that
I
mentioned
minor
and
major
releases
rolling
forward
to
those
are
more
based
on
the
fact
that
the
the
machine
is
not
configured
in
the
way
that
the
developer
intended.
But
we
shouldn't
make
things
as
easy
as
possible
for
the
users
and
not
force
them
to
install
200
different
runtimes
on
their
machines.
E
F
F
The
only
place
where
that's
not
true
is
in
the
case
of
security
patches.
We
we
aggressively
move
forward
to
the
latest,
even
if
the
one
you
asked
or
built
against
is
on
the
machine.
That's
the
in
other
cases.
What
you
said
is
exactly
true:
we
only
roll
forward
in
the
case
that
you're
missing
the
version
that
you
you
asked
for.
F
A
E
People
want
feedback
to
give
us
feedback
on
that.
The
question
is:
2.2
does
not
exist
on
the
machine,
it's
in
your
production
environment.
Would
you
rather
see
that
system
crash,
or
would
you
rather
see
that
system
try
to
run
on
3
dot
on
the
runtime
of
3
dot?
Oh,
that's.
Really.
The
question
we're
talking
about
yeah.
F
A
Your
thoughts
on
this
because
a
movie
do
you,
have
I,
think
I
wrote
a
blog
post
a
while
ago.
I
think
it
was
might
have
been
the
introducing
don't
like
blog
post,
where
it's
all
talking
about
our
competitors.
If
you
haven't
on
a
framework
where,
because
we
have
rules
for
but
on
dotnet
framework,
and
because
this
is
machine
but
install,
we
have
the
super
high
compact
bar.
A
So
can
you
explain
how,
like
the
context
naively
it
sounds
like
we
are
going
down
the
same
path
of
dotnet
court
now
when
we
end
up
with
the
ball
baby
kinda
low,
more
evolved
on
the
court
like
when
you
do
it
today
because
know
everything?
Well,
it's
forward
all
the
time
and
all
we
have
an
incredibly
party
yeah.
F
This
is
emo
saying
he
wants
to
make
as
many
breaking
changes
as
possible
in
the
product.
It's
it's
similar
to
Donna
framework,
but
but
different
and
very,
very
important
key
ways.
So
the
problem
we've
done
a
framework,
especially
in
the
the
Forex
series
which
we've
been
in
for
almost
10
years.
Actually
next
year
will
be
10
years
of
the
foredeck
series,
because
I
think
we
yeah,
we
shipped
that
in
2010
right
some
of
us
are
starting
at
a
bit
old
for
some
of
the
dotnet
releases.
F
F
F
The
app
runs,
and
it
does
indeed
crash
as
Kathleen
mentioned,
because
you
know
emo
removed
an
API
or
the
the
API
changed
and
in
a
in
a
really
bad
way
and
so
the
app
crashes.
Then
you
have
the
opportunity
to
put
say
2.2
on
the
machine
and
then
the
app
will
run
so
it's
it's
not
this
super
systemic
disaster
type
situation
app
might
crash
once
and
then
you
have
not
even
an
escape
valve.
You
have
a
formal
opportunity
to
fix
the
situation
so
I'm.
Okay,
with
that
that.
A
Make
sense
I
mean
like
that's
generally,
what
we,
what
we
tell
other
Belapur
us
on
the
team,
as
far
as
yesterday
had
a
conversation
with
Jared,
where
he
was
asking
what
about
braking,
braking
change
policies
moving
forward,
so
the
one
thing
I
would
like
to
talk
about
for
a
brief
moment,
because
that's
I
think
also
a
topic
that
always
causes
some
controversy,
and
we
talked
about
breaking
changes
like
in
principle.
Any
change
is
breaking
that's.
A
Why,
like
people
have
this
definition
and
say
a
break
and
change
is
a
change
where
and
abused
to
work
with
the
old
version
it
stops
working
with
the
new
version,
and
while
it's
true
in
principle,
that's
not
a
very
useful
definition
of
a
breaking
change
because
pretty
much
any
change
you
can
make
to
a
Potter,
making
it
faster,
making
it
slower.
Adding
new
features
can
be
breaking.
You
can
always
write
code
that
used
to
work
without
this
and
stops
working
with
it.
A
If
you
go
to
koreff
exes
an
extra
document
and
a
mark
don't
file
that
we
try
to
keep
up
to
date
that
we
talk
about
here.
The
kind
of
changes
that
we
know
are
breaking
and
we
do
it
anyway.
So,
for
example,
adding
new
API
can
be
a
breaking
change
and
we
said
sorry
like
if
you
want
to
evolve
the
platform
we
have
to
be
able
to
add
new
API
is
right
and
in
the
same
way
we
said,
like
you
know,
performance
improvements
can
be
breaking
there's
this.
A
You
know,
example
that
I
think
was
around
and
the
dotnet
to
all
time
frame
where
we
improved
the
speed
of
threat.
Dot
start
where
previously
an
app
would
start
a
threat
and
then
immediately
after
call
inspector
start
would
initialize
data
structures.
That
would
be
read
the
basically
read
by
the
threat
that
just
started,
but
don't
net.
A
The
one
was
slow
enough
that
by
the
time
the
thread
actually
ran,
the
instructions
were
already
initialized,
but
knowing
to
all
we
made
it
faster,
so
they
basically
crashed
the
threat
that
just
started,
because
the
instructions
were
not
quite
initialized
yet
and
so
I
think
this
code
was
actually
in
an
out
dog
and
in
that
almost
all
the
executives
had
installed.
That
showed
the
the
picture
of
the
person
or
something,
and
so
we
took
out
look
down
effectively
with
that
change,
and
but
but
this
is
a
good
example
of
something
where
it's
like
well.
A
Performance
fixes
can
totally
break
your
application,
and-
and
so
this
is
another
kind
of
you
know-
class
if
we
say
yep
in
order
for
us
to
evolve,
Department,
to
be
able
to
make
things
faster
as
well
and
and
developers
have
to
absorb
this.
What
I
very
often
hear
from
in
from
typical
people
when
we
talk
on
Twitter
about
me,
talk
about
why
we
didn't
do
certain
changes,
it's
like!
Why?
Don't
you
just
do
it
like?
It's
all
stupid
people
that
write
bad
code
and
it's
not
two
people
writing
bad
code.
It's
more!
A
Like
the
you
know,
the
assumptions
you
are
making
the
best
thing
a
developer
can
do
is
write
an
app
test,
the
app
and
then
deploy
the
app
right.
Nobody
is
literally
reviewing
every
single
line
of
code
and
and
ask
the
question
of
like.
Can
this
possibly
break
right
and
the
problem
of
Donette
framework
is
that
we
basically
update
the
framework
underneath
your
application
right,
so
you
don't
get
to
test
again.
A
The
general
idea
was
on
it
frame
rate
on
a
course
well
they're
side
by
side
who
leads,
so
you
have
to
do
something
to
your
application
normally
to
to
update
it
into
the
to
the
new
version
and
will
forward
changes
dissipate.
But
the
general
expectation
here
is
if
this
new
version
should
break
your
existing
applications.
The
fix
is
always
you
just
download
the
older
version
and
install
it
side
by
side
and
don't
never
the
real
problem.
Is
you
can't
do
that?
A
And
on
top
of
that,
you
have
the
option
to
say
you
know,
let's
say:
you're
a
TurboTax
or
you're
a
visual
studio
where
you
effectively
don't
control
the
environment.
You
can
always
go
self-contained
and
bring
your
own
copy
of
the
framework
where
you
know
exactly
what
it
is
that
you're
tested
and
what
you're
deploying.
So
that's
the
that's
the
thing
that
the
general
direction
that
why
I
think
we
believe
that
we
can
be
a
bit
more
say
optimistic
with
changes
right.
A
We
generally
don't
do
breaking
changes
and
at
a
very
large
scale
like
we
need
mean
in
spaces
or
something
we
try
to
avoid.
But
we
have
not
done
certain
performance
improvements
on
talking
environment
because
we
know
it
will
break
the
world
if
you
do
that.
So
of
course,
I
hope
is,
if
you
can
get
there
eventually
right
spans
an
example
of
that
right,
yes,
fans
are
a
good
example
of
that,
and
span
is
also
an
example
where
you
know
once
you
plump
it
through
the
course
stack,
there's
plenty
of
stuff
where
applications
might
fail.
D
Interestingly
enough,
from
the
f-chart
perspective,
there
are
some
f-sharp
programmers
and
that
who
rely
on
type
inference
when
use
calling
botnet
methods
that
have
overloads
and
that
can
work
like
usually
the
first
time
for
like
sort
of
a
short-lived
application.
If
you
call
the
write
overload,
but
especially
with
span
where
span
overloads,
have
kind
of
an
edit
everywhere,
pretty
much
anywhere
that
takes
a
string
now,
there's
like
a
read-only
span
of
care
or
something
well,
that's
actually
a
compiler
ambiguity.
D
Now
right
because
it's
like,
oh
well,
you
just
defined
this
thing
called
X
or
s
or
whatever,
but
you
didn't
say
what
the
type
was
and
you're
calling
it
into
an
overloaded
method,
but
it
could
work
for
either
of
these,
and
so
the
addition
of
those
overloads
can
actually
mean
a
breaking
dreams
for
certain
kinds
of
enteric-coated.
So
that's
not
to
say
that
you're,
a
bad
F
sharp
programmer
if
you
rely
on
type
inference
in
that
way,
but
that's
just
sort
of
like
another
way.
D
A
Sauce
breaking
trainers
are
like
an
interesting
technique
at
Agora
in
themselves,
because
they
we
usually
think
of
sauce
breaking
trainers,
is
something
that
happens
during
development
time
right
where
you
did
something
to
your
project.
You
upgrade
the
target
fabric
or
something
where
we
believe
you
are
generally
in
the
ghost
position
to
make
changes
if
necessary
right.
We
still
don't
want
to
make
sauce
breaking
changes
where
you
know.
A
You're
three
million
lines
of
code
now
generate
10,000
compiler
errors,
because
that
would
be
pretty
daunting,
but
there
are
also
cases
where
this
can
be
runtime
arrows,
depending
on
what
you
do
with
dotnet
right.
There's
plenty
of
people
that
write
you
know
web
services
or
other
things
where
they
had
to
run
from
source
kind
of
story
in
production,
where
the
machine
now
gets
upgraded
and
the
SWAT
still
gets
compiled
on
the
fly
and
all
stops
working
and
that's
another
area.
Maybe
try
hard
to
make
that
better
posed
on
your
course.
E
We
think
about
it.
That's
I'm!
If
there's
not
an
issue,
please
make
one,
because
this
is
something
that
it's
out
there,
but
we
don't
have
that
today
and
we
had
yeah
the
question
around
the
SDK
and
the
runtime
and
I'm
kind
of
taking
that
around
the
SDK
and
maybe
rich
has
a
perspective
on
it
that
he
wants
to
add
either
on
the
SDK
or
the
one
time
I.
F
F
You
always
have
one
version
of
node
on
the
path,
and
so
what
MDM
allows
you
to
do
is
the
very
easily
switch
which
one
of
them
is
on
the
path
and
which
one
you're
targeting
but
you're,
fundamentally
only
ever
using
one
and
then
the
project
is
is
subservient
to
that
choice,
but
John
net
core.
We
went
a
different
direction,
which
is
we
inverted
that
which
is
all
all
SDK
and
runtime
versions
are
always
available.
Well,
not
really
SDK.
Let's,
let's
ignore
that.
F
For
a
moment,
all
runtime
versions
are
always
available
and
the
project
each
project
gets
to
make
a
different
choice
and
then
the
SDK
honors
that
so
there's
kind
of
no
need
for
a
version
manager.
In
that
sense,
now
the
place
where
we
do
where
we
do
have
more
of
a
problem,
and
we
kind
of
get
closer
to
the
MDM
thing.
Is
we
have
this
global
JSON
file
that
is,
in
effect
our
MVM?
F
We
are
not
actually
super
happy
with.
With
that
we've
talked
about
it,
I
think
six
million
times
I
would
personally
like
something
that
was
yeah
different
I
liked
I
liked
yeah
I'm
not
going
to
go
into
all
this
all
the
options
but
I
think
global
dot.
Json
is
is
not
good
enough,
but
we
only
need
it
the
key
pieces.
We
only
need
it
for
SDK
selection.
We
don't
need
it
for
runtime
selection
nvm
is
at
least
I
think
it
is
closer
to
the
runtime
selection
thing
that
we
already
have
solved.
So
that's
my
answer
so.
E
Makes
it
more
of
a
real-time
situation
instead
of
a
here's,
my
project,
this
project,
expects
this
SDK
in
order
to
do
its
thing
and
that's
why
the
global
dot
JSON
actually
dropping
into
a
project
or
into
a
solution.
But
there
are
problems,
including
the
fact
that
it
can
put
it
the
project
and
stay
the
solution
you
can
run
into
problems
at
different
projects
have
different
SDKs
and
they're
trying
to
build
together.
So
we
have.
We
have
a
long
list
of
things
about
global
about
JSON.
That
we
are
aware
of.
E
Well
thought-out,
deep,
deep
thinking
on
the
set
of
problems,
because
there's
other
configuration
problems
and
there's
the
fact
that
we
don't
recognize,
what's
basically
the
repo
level
or
your
world
for
this
project,
we
recognize
individual
projects
at
the
CLI
level
and
so
there's
there's
a
whole
set
of
inner
inner
locking
problems
that
we
look
at
when
we
think
about
the
the
global
about
JSON
problem,
and
generally,
we
just
so
far
have
said
we
have
more
important
things.
You
spend
that
much
time
on
and
we'll
tweak
it
and
we
have
tweaked
it.
E
F
Want
to
register
what
my
number
one
scenario
is
that
causes
me
grief
on
this,
which
is
I
installed
on
a
core
3,
o
preview
or
really
any
kind
of
preview
on
the
machine.
It
then
takes
over
my
whole
machine.
I'd
love
it
to
be
the
case
that
there
was
a
setting
and
I've
written
this
up
on
github,
where
I
could
say
by
default.
F
When
for
a
lot
of
lot
of
the
time,
I
actually
want
to
to
like
I'm
talking
about
today,
I
want
to
to
RT
M
projects
and
I'd
even
be
happy.
If
I
could
just
type
F
for
framework,
you
know
neck
core
app
that
would
I
would
that
would
satisfy
my
needs.
I've
asked
for
this,
but
it
hasn't
been
delivered.
I'd
be
I'd,
be
curious.
If
folks,
on
the
call
have
this
same
level
of
kind
of
unhappiness.
With
this
very
specific
user
experience,
you.
F
E
One
of
those
interlocking
problems
is
the
relationship
between
templates
and
the
SDK,
and
so
there's
a
there's.
A
whole
bunch
of
problems
woven
together
on
this
one
and
I
would
I
would
love
to
break
that.
We're
we're
that
wasn't
a
problem
when
I
say
tweaks,
we
might
do
a
tweak
around
previews
for
three,
oh,
it's
not
in
yet,
but
that
has
not
been
completely
removed
from
the
table.
E
A
So
I
would
suggest
be
moving
a
bit
off
of
runtime
and
and
tooling.
There's
only
few
questions
that
I
think
would
be
good
of
caffeine
or
which
could
quickly
answer
this.
So
are
they
any
plans
to
have
as
a
DevOps
agents,
pervious
2019
previous
available
to
making
both
or
experimental
dotnet
core
your
projects?
Anybody
know
I.
F
A
A
F
E
Let's
throw
in
there
that
that's
actually
not!
We
have
work
to
do.
That's
not
really
a
preview
to
feature,
that's
something
you
can
look
forward
to
as
we
get
closer
to
our
TM,
we're
very
excited
to
get
thinking
out
there,
because
we
do
think
that
the
self-contained
application
scenario
is
a
good
one
and
the
linker
really
helps
that
scenario
not
be
insanely
large.
So
we're
super
excited
about
getting
that
out,
but
it's
not
quite
there
for
preview,
it's
pretty
much
where
it
was
before
for
preview,
which
is
it's
available
on.
E
A
Cause
well
then,
let's
shift
the
focus
a
little
bit.
That's
was
languages,
so
there
were
those
one
question
was
for
F
show
what
I
think
the
same
can
be
answered
and
said
for
c-sharp
is
what
are
the
timelines
for
f-sharp
4.6?
So
what
are
you
most
excited
about?
So
first
question
is
like
how
does
dotnet
core
300
on
language
versions
on?
Does
that
work
like?
Would
you
guys
ship
within
that
culture,
people
think
about
that.
D
That
is
anonymous
records
which
are
sort
of
a
slight
variance
on
the
existing
record
type
except
they're
anonymous
and
the
compiler
internals.
It
actually
just
compute
a
sha-1
hash
and
says
that's
the
name,
but
there's
a
few
benefits
that
you
get
from
not
having
a
name
and
a
few
things
that
are
not
quite
as
good.
It's
it's
sort
of
a
different
trade-off,
but
it
makes
things
a
lot
easier
whenever
you
interact
with
certain
components
like
or
M's.
D
That
kind
of
always
assume
you
have
an
anonymous
type
and
those
things
are
really
annoying
to
use
in
F
sharp
sometime,
but
with
anonymous
records,
it's
significantly
easier.
They
they're
really
nice.
For,
like
say
in
your
organization,
you
have
a
bunch
of
micro
services
that
just
serialize
and
deserialize,
like
a
very
small
amount
of
data
and
like
they're
just
responsible
for
just
like
a
tiny
amount
of
information
and
sending
that
tiny
amount
of
information
you
have
another
micro
service.
That's
only
responsible
for
reading
that
tiny
amount
of
information
and
doing
something
with
it.
D
It's
kind
of
annoying
to
have
to
like
model
your
data
types
for,
like
you
know,
maybe
five
or
six
fields
that
are
just
in
this
single
container,
and
you
can
just
do
that
all
in
line
with
anonymous
records.
That
makes
it
very,
very
succinct
and
you
don't
need
to
have
like
a
project
to
project
reference
between
the
two
to
see
it
like.
If
you,
if
you
say,
you're
deserializing
something
into
this
form
that
you
have
specified
kind
of
just
the
way
the
serialization
works.
It
just
plain
works.
D
So
it's
really
good
for
that
scenario
and
then
also
for
working
with
data.
It's
it's
very
nice
because
the
copy
and
update
syntax
or
withers
as
they
are
called
in
various
designs
that
are
happening
around
c-sharp
for
the
idea
of
records
with
anonymous
ones.
You
can
take
an
existing
record
and
you
can
actually
put
more
data
into
it.
So
say
you
have
your
own
record
definition
that
contains
an
X
of
Y
and
a
Z
field.
You
can
say:
oh
I,
want
to
create
a
new
anonymous
record.
D
That
is
an
instance
of
this
record,
but
with
a
W
field
added
to
it
and
that
W
field
could
be
something
completely
different.
So
that's
really
helpful
for,
like
you,
know,
you're
working
with
data,
that's
sort
of
just
in
this
compact
record,
like
format,
and
you
want
to
transform
it,
but
you
don't
want
to
model
all
the
types
needed
for
those
transformations,
because
the
transformations
are
kind
of
more
of
a
means
to
an
end
and
they're
really
really
nice
for
that,
and
you
can
actually
do
some
pretty
clever
stuff
with
them
so
yeah.
D
A
F
B
D
We
take
this
approach
of
like
when
things
are
ready
like
from
from
the
design
feels
baked,
and
we
feel
as
though
it
has
been
enough
time-
and
you
know
the
the
compiler
is
in
a
good
enough
state
to
rev
a
major
language
version.
Then
we
will
take
a
look
at
what
we
have
and
see
if
it
makes
sense
to
ship
something.
D
We
said,
okay,
what
release
can
this
fit
into
and
we
sort
of
went
from
there?
However,
there
is
much
more
of
a
long-term
thing
going
on
with
f-sharp
5.0,
because
we
want
to
also
do
know
ability
for
reference
types
that
aligns
with
the
notability
work
going
on
in
c-sharp,
and
that
is,
you
know,
all
aligned
with
donek
or
3,
and
so
we're
trying
to
position
everything
that
could
fit
into
that
bucket
yeah
much
more
in
advance.
D
D
That
that's
that's
sort
of
the
world
that
we're
trying
to
get
to
and
so
because
that's
such
a
big
shift
I
think
it
warrants
a
big
major
version
change
so
yeah.
That's
that's
sort
of
how
that
all
is,
however,
we're
not
shipping
a
preview
of
that
in
the
upcoming
visual
studio,
because
it's
just
not
at
a
state
where
we
could
really
say
that
it's
usable
by
people
so
we're
not
going
to
ship
a
totally
broken
preview
compiler
and
in
Visual,
Studio,
side-by-side
and
I'd,
say:
yeah.
Try
it
out.
It's
all
work
in
progress,
keep.
C
So
we
in
there
is
in
various
ways
again
due
to
some
of
these
limitations
with
dotnet
framework
and
and
the
classic
done
at
runtime.
We
haven't
been
able
to
evolve
their
semantics
of
the
underlying
VM,
the
runtime
itself
for
a
long
time.
So
this
is
sort
of
our
first
like
step
in
that
direction.
It's
really
exciting
and
I
hope
that
it
doesn't
crash
and
burn,
because
I
really
want
to
do
more
of
it
after
I.
Don't
want
it
to
I,
don't
want
to
that
house
to
burn
down,
but
but
so
for
those
reasons
we
fight.
C
C
We
depend
on
both
previews
of
tonic,
core
and
also
previews
of
vs,
where
we
ship
the
actual
compiler
and
and
and
and
ID
experience
previews
and
we've
already
messed
up
several
little
things
where
they
didn't
line
up
because
I
don't
even
ship
on
the
same
dates
necessarily
and
they
you
know,
they're,
not
entirely
coordinated,
so
they're
little
things
where
whoops
the
compiler
targeted
a
type
that
had
ditched
this
shape,
but
we
changed
the
shape
in
there.
You
know
we've
had
a
few
of
those.
A
That's
generally
like
furnace
that
dotnet
has
an
influx
of
version,
numbers
and
product
names.
That
I
think.
That's
you
know
partially
like
naming
his
heart
and
versioning
is
even
harder.
I
remember
they
kept
like
joins
the
team
and
she
said:
I
want
to
fix
versioning
and
I
just
laughed
and
said
like
that's
it
bossing
yeah.
A
Here
but
I
think
I
think
the
question
in
general
is
like
what.
Why
is
that
and
I
think
part
of
the
problem
that
we
have,
that
other
people
don't
have
is
that
you
know
maybe
talk
about
DevOps
all
the
time,
but
you
basically
can
just
when
things
are
ready,
you
ship
them
and
already
you
don't
ship
them.
When
you
have
a
service
when
you
control
the
deployment
environment,
it's
much
easier
to
do
these
kind
of
things,
but
you
can
roll
out
things
for
a
small
set
of
users
like
in
facebook.
A
They
can
just
say
you
know
they're
for
certain
panel.
That
shows
them
for
certain
users,
but
I.
Think,
first
for
software
that
you
install
on
your
device
that
you
that
you
depend
on
that.
You
declare
dependencies
on.
You
need
some
way
to
identify
what
it
is
that
you're,
depending
on
whether
in
version
numbers
and
product
names,
are
the
best
mechanism
that
we
that
we
have
for
that
right.
A
And
that
means
what
we
have
to
decide
which
vehicle
things
go
in
and
that
it
is,
as
you
said,
it's
an
ongoing
challenge
to
find
what
is
the
right
vehicle
for
a
given
feature
and
what
people
often
also
don't
understand.
The
thing
is
or
not
fully
I.
Think
you
know
grasp
from
a
language
standpoint
is
that
it's
not
just
the
language,
but
very
often
you
want
ID
features
that
correspond
with
the
language
features.
A
So
in
Topol
you
want
an,
for
example,
an
ID,
a
feature
that
can
tell
you
that
you're
missing
the
tupple
type
in
you
should
add
a
reference
to
that
or
you
have
you
know.
Maybe
two
leaing,
like
you
know,
actual
menu
items
or
commands
in
viesta
that
go
with
that,
and
the
same
buddy
needs
like
a
framework
update
to
to
have
those
types
right
and
yeah
I.
Think
getting
all
these
things
aligned
or
not
on
a
schedule
is
the
languages
is
really
like
shipping.
B
D
I,
don't
want
to
hear
about
warnings
from
this
thing.
I
want
some
sort
of
context
menu
for
whatever
this
thing
is
some
some
node
in
the
IDE,
where
I
could
write
and
say
just
turn
it
off
or
have
something
where
I
could
say,
like
oh
I'm,
pointing
to
this
thing,
I
want
to
ignore
what's
coming
from
there,
and
so
that's
one
of
those
things,
that's
interesting
to
think
about
from
a
tooling
standpoint
and
incredibly
difficult
to
get
right,
which
is
why
you
know
a
million
little
tooling
features.
D
You
know
a
long
side,
visual
studio,
even
though,
even
though
that
that
see
sure
people
when
I
was
not
going
to
RT
M
for
that
given
version
matters,
because
that
allows
us
to
try
things
and
get
feedback
on
it.
Rather
than
think
we
got
it
right
and
then
ship
it
yes
and
then
have
customers
tell
us
oh
yeah.
No,
that
wasn't
quite
right
and
then
we
go
oh
darn
it
well.
It's.
C
D
C
Elderly
feature
is
really
not
novel
reference
types.
It's
really
proven
to
be
a
different
language
feature
in
so
many
ways
than
any
we
have
ever
done
before.
Like
first
of
all,
we
talked
about
breaking
changes
before
this
is
the
language
feature.
That's
designed
to
break
your
code
right.
The
whole
point
of
this
language
feature
is
to
warn
you
about
things.
C
We
didn't
warn
you
about
before,
so
you
can
feel
more
confident
that
you
don't
have
these
nulls
that
blow
up
in
somebody
else's
face
three
years
later,
when
they
call
your
code
right,
and
so
it's
so
we've
spent
all
these
years
being
very
careful
not
to
blow
anything
up
and
and
tread
very
lightly
with
new
features.
So
we
don't
miss
existing
features
up
and
here's
one
with
sole
purpose
is
to
do
that.
So
so
the
whole
game
changes
right.
C
Now
we
need
to
all
we
need
to
think
about
how
you
opt
in
there's
a
whole
experience
outside
of
the
language
feature
of
how
do
they
use
it?
How
do
you
activate
it
and
a
lot
of
the
way
like
the
primary
way
you'll
interact
with
it?
Is
that
you
get
warnings
and
you'll
fix
your
code
right
and
then
it's
not
primarily
like
a
new
expressiveness
that
will
generate
new
behaviors
and
it's
not
a
shorthand
for
anything.
It
doesn't
actually
make
you
a
coach,
shorter
right.
It
makes
it
a
little
longer.
C
I
think
question
marks
it's
one
more
character:
okay,
in
a
generic
type,
you
might
add
that
character,
multiple
times,
I
think,
but
that
that
actually
goes
to.
It
goes
to
part
of
the
motivation
for
the
syntax,
which
is
that
the
nullable
types
should
be
a
little
harder
to
write
than
and
unknowable
the
default
should
be
not
nullable,
because
then
you
only
ask
for
null
ability
when
you
need
it.
Okay
I
actually
need
this
time.
You
don't
just
fall
into
it,
and
now
everybody
else
has
to
check
around
you.
C
E
I
want
to
throw
in
an
update
for
VB
in
here
too.
So
people
know
that
it's
it's
out
there.
It's
gonna
be
in
dotnet
core
three
and
it's
numbers
happen
to
correspond
to
visual
studio
16,
which,
for
the
next
six
months,
will
be
unfortunate,
so
visuals
digital
basic
16
will
not
ship
in
visual
studio,
16
dot.
Oh,
it
will
ship
with
dotnet
core
3
in
the
version
of
Visual
Studio.
That's
C
sharp
8
ships
in
so
16
2.
Whatever.
E
Whenever
comes
it
will
ship
with
dotnet
core
3
and
the
major
feature
for
VB
of
dotnet
core
three
is
that
it
runs.
It
doesn't
work
very
well
on
and
we're
fixing
that
so
the
Visual
Basic
runtime
will
be
there
in
dotnet,
core
3
and
Visual.
Basic
should
run
well
and
dotnet
court
very
excited
about
that.
Visual
basicnet
is
moving
forward
in
16.1
and
16.2.
We
have
things
on
the
table.
Both
were
some
features
that
allow
us
to
stay
up
with
Interop
with
c-sharp.
E
C
C
E
Mates
people
asked
about
the
questions
about
about
me
vb.net
now
that
I'm
running
the
this
part
of
things,
so
no
as
nothing
to
do
with
that,
but
the
chubby
index
is
one
interesting
measure.
People
are
definitely
acted
in
beauty
net.
We
have
other
measures
that
definitely
people
are
doing
it
they're
a
portion
of
our
customer
base
that
we
care
about
and
we'll
keep
doing
the
right
thing
for
vb.net,
which
is
not
going
to
be
the
same
thing
as
ensure
going
forward
and
we've
got
a
strategy
announcement
on
that
people
can
reach
out
to
me.
E
A
So
if
you
want
to
engage
with
us
on
on
design
questions
slightly
higher
level
ones,
I
think
those
reports
on
particular
are
very
interesting
because
they
allow
you
to
talk
about
cross-cutting
features,
but
you
don't
necessarily
have
to
worry
about
which
repo
things
are
living
in
and
you
can
actually,
you
know
talk
a
little
bit
more
meaningfully.
I
guess
right.
C
I
think
I
mean
we
realized
at
some
point
couple
years
ago.
I
guess
that
having
being
open
source
is
great
in
sharing
the
source
code
for
the
product
and
working
on
that
together
across
community
and
Microsoft,
but
then
that
it
turns
out
that
there
are
many
more
artifacts
and
many
more
things
that
are
produced
during
the
development
of
dotnet
and
the
languages
that
aren't
code
and
that
don't
share
well
inside
of
a
code,
oriented
repository
and
so
we've
specifically
for
the
languages.
C
We
make
these
c-sharp
Lang
and
VB
Lang
repos
as
the
place
where
we
keep
all
those
artifacts
that
are
part
of
them.
I
mean
it's
not
like
a
publishing
venue.
It
is
a
repo
we.
This
is
where
the
work
happens
is
where
the
the
design
notes
and
the
specs
and
everything
lived
right.
So
that
has
been
as
being
super
great
for
for
making
a
language,
evolution
and
community.
A
Activity
like
I
mean
like
I
in
general,
like
a
thing
to
it
in
Texas,
so
much
more
powerful
than
basically
anything
else
that
you
can
do
with
normal
PRS.
We
talked
about
code
right
because
the
thing
is,
if
we
have
two
paragraphs
in
a
document,
it's
so
much
easier
to
change
the
wording
or
like
changes
slightly
early
rather
than
changing.
You
know
large
swoops
of
code
later
on,
and
the
nice
thing
with
github
is
that
documents
on
two
different
from
code.
You
can
still
talk
about
pull,
requests
and
documents.
A
You
can
still
engage
on
design
questions
at
a
fairly
high
level
about
necessarily
talking
about
code
and
having
them
in
dedicated
repos
is
actually
helpful
because
it
removes
the
noise
little
bit
right.
Wasn't
is
ginormously
large
as
a
repository
right
and
the
language
design
nodes
in
the
you
know,
suggestions
would
just
basically
be
dwarfed
by
all
the
small
bug
fixes
and
test
breaks
and
all
the
other
stuff
that
you
have
to
do
day
to
day
so
yeah
everybody
to
check
that
out.
A
So
the
one
thing
that
we
you
have
to
get
for
our
end
so
join
us
already
getting
getting
psyched
up.
I
hope
is.
We
have
a
small
thing
that
you
know
Catholics
lots
of
what
we
talk
about,
which
is
a
community
driven
project
that
Kathleen
started
to
party
on
I,
wouldn't
as
this
pitch
it
as
it's,
something
that
everybody
has
ever
written,
probably
at
least
four
times
over.
E
E
We're
doing
this
because
we
constantly
feel
like,
like
it's
an
important
problem
to
solve,
and
we
think
we
have
the
traction
to
do
it
and
with
that
I'm
gonna
have
John
talk
about
system
command
line
and
what
it
does
and
you'll
have
to
tell
us
Emma
how
much
time
he's
got
because
we're
coming
up
on
the
hour.
Can
we
run
over
yeah.
A
B
B
You
know
if
I
want
this
particular
syntax
that
this
library
provides.
Then
I
end
up
having
to
take
the
opinions
that
it
also
comes
with
with
regard
to
syntax,
and
then
that
may
have
implications
for
the
way
that
I
structure,
my
application
and
each
reattempt
of
a
command-line
parser
has
kind
of
stopped
at
that
level
and
not
gone
down
to
some
some
more
things
that
might
be
considered
the
harder
problems
maybe
or
the
problems
that
people
actually
don't
like
people,
don't
actually
want
to
write
a
parser
right.
B
They
want
an
application
framework,
they
want
a
way
to
handle
arguments,
and
so
over
and
over
people
reinvent
the
same
pieces,
and
we
said
well
in
the
CLI.
We
had
a
couple
of
problems
that
we
wanted
to
solve.
One
of
them
was
our
own
testability
invocation
was
invariably
coupled
to
the
way
that
we
were
parsing
and
there
wasn't
an
abstraction
that
allowed
you
to
say
what
is
my
parse
result.
This
is
an
ast
basically
for
your
parse
result.
B
It
lets
you
then
potentially
test
and
make
sure
that
your
parser
still
works
the
way
you
expect
it
before
you
even
get
down
into
the
implication
layer
and
then
invocation
as
well.
We
said.
Well,
you
know
there's
once
we
have
that
I
guess
he
we
can
do
some
kind
of
fun
stuff.
Once
we
get
down
into
the
into
the
lower
layers,
there
was
infrastructure
there
that
ideally
would
have
allow
Interop
between
parsers
alright.
So,
even
if
you
have
different
parsers
with
different
API
opinions,
they
might
be
able
to
share
implementations
of
specific
things.
B
How
do
I?
How
do
I
provide
help?
How
do
I
format
help?
How
do
I
provide
a
version?
You
know
these
are
things
like
you
kind
of
want
all
applications
that
have
similar,
look
and
feel
and
I
feel
like
one
of
the
things
that
we
recognized
was
that
the
end
users
of
command
line
applications
end
up
in
this
very
fragmented
user
experience,
because
all
of
these
libraries
are
doing
different
things.
You
know
so
I,
don't
know
what
what
is
the
correct
syntax
for
you
know
an
option.
Is
it
a?
B
B
What
I
have
up
here
is
you
know
the
way
that
at
the
entry
point
for
a
console,
application
has
looked
for
ever
and
dotnet
and
you
get
some
string
args
right
and
that
the
one
of
the
things
that
we
thought
about
was
you
know.
Typically
I
would
have
to
go
in
parse.
These
args
I
might
look
into
them.
Positionally
naively,
say.
Oh
someone
asked
for
help.
I'm
gonna
check
that
they
ask
for
helping
him
to
return
earlier.
You
know
write
something
out
to
the
console.
B
We
said
well
that
kind
of
control
flow
is
kind
of
annoying
to
have
to
write
over
and
over
again.
So
what
an
invocation
pipeline
as
well,
and
then
we
thought
at
the
end
of
the
day
what
what
I
really
want
is
strong
type
arguments.
What
is
the
simplest
thing
we
can
do
now?
What
this
led
us
to
is
this?
It's
an
experiment
that
we
call
track
dragonfruit.
B
This
is
a
strongly
typed
entry
point
and
what
this
does
is
it
effectively
configures
a
parser
for
you,
based
on
the
types
that
you'll
see
there
and
then
gives
them
back
to
you.
It
provides
help
and
based
on
the
XML
comments,
and
it
provides
default
values
based
on
just
you
know,
sort
of
idiomatic
c-sharp.
B
Now,
there's
a
I'll
show
another.
What
later
I'll
get
maybe
a
little
bit
more
into
what
the
underlying
syntax
is.
This
is
this
is
an
application
layer
that
has
sort
of
a
specific
API
opinion
and
sits
on
top
of
this
core
that
we're
saying
should
be
kind
of
fungible
across
different
Aptos
I
want
to
show
a
couple
of
the
things
that
that
we
can
do
here,
because
what
you'll
notice
is
in
this
application?
There
isn't
I'm,
actually
demoing
something
slightly
different
here,
but
I
want
to
show,
but.
B
This
rendering
playground
is
an
application
that
uses
the
dragonfruit
model,
so
it
also
has
a
strongly
typed
entry
point
and
I'm
just
going
to
show
what
help
looks
like
first.
So
this
is
help
for
this
application.
I'll
get
into
a
little
bit
of
what
the
rendering
is
doing,
but
you'll
see
that
this
is
you
know
this
is
the
entry
point
for
the
program,
so
it
has
the
same
XML
for
help
output
and
a
bunch
of
strongly
typed
arguments
with
defaults.
Okay,
so
there's
no
early
return
here
for
help.
B
A
B
The
user
doesn't
have
to
write
any
code
to
deal
with
help
at
all
right.
What
they
write
is
they
just
write
the
signature
for
their
entry
point
now.
This
is
not
the
only
way
to
write
an
application
on
top
of
system
command
line.
This
is
the
dragonfruit
layer
that
goes
under
and
it
configures
your
your
parser
for
you
and
it
configures
your
invocation
pipeline
for
you
and
it
comes
with
a
bunch
of
freebies
and
help
as
one
of
them.
Another
one
is
the
ability
to
understand
your
parse
operation.
B
So
we
have
this
concept
that
we
added
him
as
well,
and
this
was
to
try
to
provide
certain
functionality
that
would
cut
across
any
application
that
uses
system
command-line.
So
if
I
parse,
for
example,
something
like
this,
you
know,
I
can
get
a
description
of
the
parse
tree
back
right
and
what
this
is
showing
me
that
the
the
bang
is
showing
me
that
sample
was
invalid
right
if
I
run
this
without
parse,
and
these
are
other
things
you'll
get.
You
know,
you'll
get
things
like
this.
B
If
I
say
I
have
a
miss,
you
know,
I
have
an
argument
missing
or
if
I
try
to
parse
something
to
the
wrong
type.
Things
like
this
I
get
error
messages
for
free
that
kind
of
describe
what
I
did
wrong.
We
support
custom
binding
two
different
types
directory
info
type
and
file
info
are
provided
for
you
and
things
like
fairly
sensible.
We
also
have
support
again.
These
are
things
that
we
can
do
with
the
abstract,
syntax
syntax
tree.
B
B
Typically,
you
would
need
to
write
a
shell
script
that
understands
the
semantics
of
your
specific
application,
so
Posh
get
or
bash
get
provide.
Completions
forget
right
right
here.
What
we're
saying
is
that
your
application
itself,
written
in
dotnet
c-sharp,
is
the
canonical
source
of
information,
and
these
these
are
extensible
as
well.
B
I
can
change
the
parser
result
before
it
passes
into
the
invocation
pipeline
and
I
can
do
all
kinds
of
things
with
that.
The
suggestions
are
actually
driven
by
one
of
these,
as
well
as
a
global
tool
called
dotnet
suggests.
We
provide
one
shim
scriptum
than
anything.
That's
using
system
command-line
redirect
through
that.
That
dotnet
suggests
global
tool
into
your
application
itself,
but
you
can
call
your
application
directly
and
you
can
see
you
know
what
of
it.
What
are
the
valid
completions
for
this,
and
it
is
contextual
I,
don't
have
it?
B
I
don't
have
an
example
right
here
that
has
sub
commands,
but
it's
context-sensitive
another
thing
that
you'll
see
that
I
can
give
a
quick
demo
of
that.
Actually,
we
do
support
sensible
completions
for
things
like
for
things
like
enums,
so
here's
an
enum,
okay
I'm
just
going
to
rebuild
this
really
quickly.
B
I'll
get
back
to
the
rendering
thing,
there's
a
reason
why
I
took
that
the
enum
out,
but
just
to
show
that
how
this
works.
You
know
if
I
say
done,
I'd
suggest
one
of
the
things
that's
interesting
to
note
here,
we'll
come
back
to
that
we
do
substring
matching.
This
is
intended
to
kind
of
write,
so
the
types
of
the
enum
are
returned
here.
B
If
we
find
a
bool,
you
know
it'll
complete
the
true
and
false,
but
if
it
since
it's
a
bullet
to
flag,
so
you
don't
actually
have
to
specify
an
argument,
in
fact,
so
those
are
some
of
some
of
the
high-level
features
of
it.
We
have.
We
just
got
a
PR
for
for
suggesting
typo
Corrections,
which
is
really
nice,
and
it
builds
on
top
of
the
same
invocation
pipeline
and
and
then
the
other
thing
that
we're
trying
to
tackle
again.
You
know
thinking
about
problems
that
are
sort
of
new
cross-platform
problems,
some
of
which
are
old.
B
Cross-Platform
problems
is
one
of
the
is
rendering
is
actually
kind
of
an
interesting
thing
and
I
think
the
Windows
10
anniversary
update
they
introduced
a
introduced
support
for
vt100
codes
to
be
correctly
interpreted
by
the
terminal,
and
this
applies
to
all
windows
console
applications
retro
actively.
So
in
Windows,
10
and
higher
you
can
using
win
3-2
API.
You
can
elevate
the
console
into
a
into
a
state
where
vt100
codes
are
interpreted
as
colors
and
cursor
movements
and
things-
and
this
is
an
in
this
in
process.
B
D
A
B
So
we
also
wanted
to
introduce
some
abstractions
to
make
that
easier
right
so
and
especially
for
me
know
if
you
have
process
called
another
process
and
redirects
output
in
that
other
process
emitted
vt100,
then
suddenly,
you've
got
all
this
goop
in
your
in
your
console
out,
but
you
don't
really
understand
how
to
read
it.
Wasn't
what
you
wanted
to
look
at
so
again
with
you
know.
B
B
There's
a
bunch
of
different
samples
in
here
that
you
can.
You
can
play
with
this
this
outputs
kind
of
it's
not
totally
obvious
that
this
is
vt100,
vt100,
enabled
terminal,
but
things
that
you
can
note
here
that
the
the
windows
console
doesn't
normally.
Let
you
do
is
that
kind
of
hot
pink
color
and
the
underlines
okay.
B
So
this
is
just
a
little
implementation
of
der
that
I
wrote
just
a
kind
of
demonstrate
this
now
there's
another
thing
that
we
can
do
and
I'm
gonna
I'm
gonna
run
the
same
command,
but
I'm
gonna
use
one
of
these
little
directives
and
I'm
gonna
set
the
output
mode
to
well
I
want
to
tell
it
not
to
enable
bTW,
okay
right,
okay,
so
this
is
what
you
would
get
this
is.
This
is
the
same
output
with
with
system
at
console,
or
you
know.
B
So
if
you,
if
you
were
to
run
this
program
and
we're
detecting
this
on
the
fly
by
default,
so
that
what
what
the
directive
is
doing
is
letting
you
override
that
behavior,
but
we're
detecting
it
on
the
fly
so
that
when
things
like
this
happen,
right
now,
obviously
setting
colors.
If
I'm
going
to
redirect
the
output
right.
B
Exactly
now
now,
the
default
behavior
that
you
saw
before
was
that
when
I,
when
I
ran
this
was
that
I
got
a
bunch
of
18100
codes,
but
the
output
here
is
still
correctly
formatted
and
so
to
see
what
that
would
have
looked
like
you
know.
I
can
I
can
also
tell
it.
I
can
redirect
the
output,
but
with
the
output
to
see,
and
then
here's
the
vt100
code,
and
that
can
be
useful
cuz.
You
might
want
to
tell
another
application:
hey
I'm
in
a
mask
I'm,
in
a
context
where
I'm
willing
to
accept
vt100.
A
B
So
we
so
the
this
there's
been
in
the
works
as
a
side
project
now
for
about
a
year
and
we
we
had
external
contributors
that
were
that
we
invited
to
because
they
were
interested
and
we
started
pulling
people
in
gradually
and
kind
of
moving
the
design
in
the
right
direction,
and
so
it's
open
now,
so
it's
dot
dot,
slash
command,
dash
line,
API,
there's
a
few
different
things
in
here.
There's
the
system,
command-line
library,
which
is
currently
it's
not
on
new
getnet
org.
B
Yet
we're
still
in
the
process
of
setting
up
a
package
signing
the
binaries
are
signed.
It
is
on
my
gut
and
we
can
share
a
link
to
the
my
gut
and
there
is
a
link
here
on
the
on
the
github
page
to
my
get
to
get
the
latest
packages
there's.
Also
the
dotnet
suggest
tool.
Is
there
that
I
not
suggest
tool
is
published
on
nougat
or
right
now,
and
then
there's
also
system
command-line,
rendering,
which
is
a
little
bit
more
immature
at
the
stage.
B
D
A
Some
more
people
excited
about
a
nine-person
so
excited
about
it,
because
I
wanted
these
to
commend
my
person
I.
Think
and
my
team
has
a
thing
at
least
three
or
four
copies
floating
around
of
command-line
parsers,
and
so
it's
cool
that
we
can
finally
get
to
the
point
where
Maine
doesn't
give
you
just
a
string
array
of
arts,
but
you
can
actually
do
something
meaningful
with
that.
A
So
you
can
actually
do
this
on
the
application,
rather
than
parsing
individual
characters
out
of
a
string
and
then
messing
up
the
quotes
and
all
the
other
things
that
you
have
to
get
right.
Yeah.
That
is
super
awesome,
so
then
I
would
say
we
wrap
it
up
for
today,
like
hopefully
the
thing
you're
on
in
four
weeks
from
now,
I
believe,
okay,
if
I
schedule
my
head,
so
we
will
have
one
community
stand
up
every
week,
but
different
teams
rotate.