►
From YouTube: Languages & Runtime: .NET Community Standup - August 13 2020 - IOT, API Analyzers, Bin Log Reader
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
Hello
and
welcome
to
the
dotnet
language
and
runtime
community
stand
up.
Hopefully
we
are
now
live
unless
I
messed
up
something
spectacularly
again,
so
we're
using
different
software
today.
So
it's
going
to
be
a
fun
exercise
for
all
of
us,
but
hopefully
it's
much
easier
for
us
and
we
can
actually
focus
on
the
broadcast
for
once
and
I'm
pretty
sure
philip
will
ask
me
two
minutes
whether
we
are
live.
So
let's
do
some
quick
round
of
introductions
so
that
people
know
who
we
are.
C
D
I'm
phillip
carter,
I
work
on
our
languages
and
tooling,
focusing
on
f
sharp
a
little
bit
of
c
sharp,
and
I
like
to
pester
mo
by
asking
him
if
we're
live
every
single
time.
We
do
this
yeah
and
then
that's
because
actually
like
I
needed
to
ask
that
a
couple
of
times,
because
he
didn't
quite
press
the
button
and
like
we
would
start
talking
and
and
that
stuff.
So
it's
just
a
habit
now.
A
A
A
Yeah
well
yeah,
that's
totally
true!
So
speaking
of
confusion,
so
what's
our
agenda
for
today,
so
I
have
a
few
things
I
want
to
talk
about.
I
think
rich
had
a
few
things
to
talk
about.
Philip
gave
me
a
list
which
I
no
longer
remember,
because
it
was
something
with
f
sharp
and
I
think
kathleen
also
had
maybe
one
or
two
things
you
want
to
talk
about.
C
B
B
So
I've
been
one
of
the
things
I
work
on
is
iot.
I
said
I
work
on
the
runtime,
but
I
work
on
lots
of
other
things
too.
So
one
of
the
things
that
I've
been
working
on
is
iot,
raspberry,
pi
type
stuff,
so
I've
been
working
on
a
few
pull
requests
and,
let's
see
if
I
can
switch
to
okay,
this
isn't
gonna
work,
quite
as
I'm
gonna
have
to
share
my
my
whole
browser.
B
A
C
B
Okay,
you
think
basically
the
same
thing
you
saw
before
yeah,
but
now
we
see
the
whole
browser.
Okay,
that's
cool!
That's
that's
totally!
Fine!
Okay!
So
I've
been
working
on
a
couple
of
prs
and
then
what
to
make
this
a
little
more
real.
So
this
is
the
mbi5027,
and
this
is
a
shift
register.
So
we
now
have
it's
still
in
pr
as
as
you
see
from
the
last
page,
but
so
we
now
have
apis
for
targeting
this,
this
particular
device,
and
what
this
enables
you
to
do
is
there's.
B
This
is
a
16-bit
shift
register,
so
there's
actually
16
of
those
legs
connect
to
leds
and
it
allows
you
to
control
16
leds
in
weird
and
wonderful
ways.
The
super
cool
thing
is:
it
has
open
short
circuit
detection,
which
means
that
you
can
actually
in
code,
find
out
if
all
the
leds
are
working
correctly,
and
so
that
means
like,
if
you
had
like
a
sign
on
a
highway,
you
obviously-
and
you
know
that
motorists
are
supposed
to
look
at
then
you
could
know
this
device
could
know
that
something's
gone
wrong.
B
It
could,
like
you
know,
send
that
to
a
cloud
service,
and
then
someone
could
know
that
they
should
go
and
repair
it.
This.
This
one
is
the
sn74hc595,
which
is
actually
probably
the
most
popular
shift
register
this
one's
8-bit.
So
eight
of
these
legs
can
make
leds
work
this
one
actually,
the
I
merged
the
pr
for
this
a
while
ago,
so
and
actually
I'm
making
some
changes
to
it.
B
B
Creating
these
kind
of
fake
circuits
in
software
that
do
strange
things
and
the
weird
thing
is
only
one
of
the
leds
can
be
lit
at
once,
which
would
seem
like
a
problem,
but
isn't
because
you
change,
which
led
is
on
many
times
a
second
and
then
I
mainly
can't
tell
that
that's
going
on
and
the
biggest
problem
with
these
is.
It's
got
this
like
crazy
scheme
for
laying
out
the
leds,
and
you
have
to
know
which
ones
of
the
pins
you
should
light
up
at
any
one
time.
B
So
it's
like
basically
a
network
address
type
of
problem.
So
anyway,
the
binding
takes
care
of
all
of
that,
for
you
and
the
last
thing
is
the
interface
called
I
writeable
pin
segment
and
it's
basically
an
abstraction
that
is
intended
to
enable
you
to
use
any
of
the
things
that
I
just
showed
you
with
like
really
simple
code.
So,
if
we
like,
let's
see,
is
there
a
readme
file
for
this?
I
should
know
since
I
did
this.
No
apparently
not
never,
never
got
that
far
anyway.
B
B
A
A
B
A
A
B
C
B
B
This
will
obviously
blog
post
too.
It
happens
to
be
this
link,
and
so
these
are
all
the
device
bindings
that
are
in
there.
So
you
can
see-
and
these
are
all
have
been
community
contributed,
and
so
you
can
see
there's
like
actually
a
fair
number
of
these,
so
you
basically
buy
some
part
so
we'll
just
pick
something
at
random
like
I.
B
B
Well,
the
nuget
packages
are
already
there
they're,
just
in
constant
development.
They
don't
specifically
relate
to
the
the.net
schedule,
so
I'm
I'm
working
with
a
team
right
now
that
there's
there's
just
a
few
of
us,
and
so
the
idea
is
we'll
get
those
prs
that
I've
been
working
on
merged
and
then
we'll
publish
a
new
version
of
the
package.
Then
I'll
publish
the
blog
post
because
then
everything
will
be
coherent.
I
really
dislike
telling
people
like.
Oh
you
know
you
need
to
use
this
preview
one
because
we
haven't
yet
finished
it.
A
Yeah,
that
makes
sense
there
isn't
a
highlight.
There's
one
comment
from
douglas:
he
works
at
texas
instruments
and
he
was
just
amused
that
he
saw
one
of
our
chips.
It's
cool
stuff,
I
mean
like
we
have
really
done
hardware
with
dotnet
right.
So
that's
a
that's
a
relatively
new
thing.
For
us
I
mean,
of
course
we
support
cpu
architectures,
but
like
actually
talking
to
real
hardware,
is
super
cool
yeah.
B
Yeah
like
working
at
this
level
couple
things
that
have
been
different
for
me,
one
is
is
like
the
compiler
and
the
debugger
provide
they're
they're,
not
quite
as
helpful
as
they
are
with
other
types
of
programming.
It's
actually
more
like
microservices
to
to
a
degree,
except
even
slightly
worse.
So,
for
example,
I
I
use
logging
a
ton
to
like
find
out
what
the
whole
state
of
of
my
environment
is
like
setting
a
breakpoint
at
a
given
time.
B
Isn't
necessarily
all
that
useful,
at
least
for
me,
and
then
the
other
thing
is
the
style
of
code.
You
have
to
write,
like
you
know,
in
the
shift
registers,
for
example,
there's
a
fair
bit
of
bit
shifting
at
play,
and
so
I'm
not
it's
not
that.
I
don't
know
what
that
is,
but
I'm
not
used
to
having
to
to
do
that
kind
of
thing,
and
not
just
bit
shifting,
but
also
like
creating
masks
and
anding
values
with
those
masks
and
using
binary
literals.
A
I
actually
think
it's
a
beauty
filter
the
camera
detects
that
it
needs
some
blur
to
make
you
look
less
jarring
all
right,
so,
like
I'll,
just
volunteer
myself
to
go
next,
because
I
only
have
some,
you
know
a
few
things
as
well,
so
a
few
things
first.
So
we
have
this
api
review
process
where
we
review
apis
from
the
community,
and
so
I
brought
a
website
here
that
you
can
go
to
api
review.net,
which
basically
have
some
helpful
links
to
go
to.
A
You
know:
what's
our
review
process,
you
know
what
are
the
guidelines
that
we
are
using
and
we
also
have
you
know
all
the
design
reviews
that
we
do
are
uploaded
to
youtube.
So
there's
like
literally
hours
and
hours
of
reviews,
you
can
watch
where
we
pontificate
over
api
design
if
you're
into
that
sort
of
stuff.
A
We
only
added
existing
apis
and
that
kept
us
busy
for
a
while,
and
you
know
after
two
were
shipped
of
course.
We
you
know
we're
working
towards
finishing
that
backlog
and
reviewing
more
and
more
api
suggestions
that
people
had,
but
normally
we
only
meet
once
a
week
for
two
hours
and
then
we
basically
started
to
do
it
three
times
a
week
for
two
hours.
For
you
know,
I
think
three
or
four
months
now
to
actually
get
through
it
and
we
finally
finished
it.
A
So
if
you
submit
api
review
requests
like
it's,
it's
very
unlikely
that
you
get
completely
refused.
I
mean
we
review
things
that
are
not
in
the
spirit
of
the
platform,
but
by
and
large
most
issues
are
not
like
that.
Like
I
think
at
some
point
I
looked
at
the
ratio
and
it's
like
99
is
approved,
but,
as
I
said,
probably
within
the
99
percentile,
like
85
plus
percent,
is
approved
with
additional
tweaks.
A
So
it's
we
almost
never
take
the
api
suggestion,
as
is
either
so
there's
that
so
that's
basically
it
if
you're
just
curious
what
our
backlog
is.
Aproveu.Net
go
to
the
page
view
the
backlog
so
other
interesting
thing
that
I'm
working
on
is.
We
have
this
thing
called
roslin
analyzers
that
in
this
release
we
are
trying
to
extend
what
analyzers
ship
in
the
box.
A
So
today
you
can
install
a
bunch
of
nuget
packages
that
will
give
you
smartness
in
the
ide,
basically
and
analyzers,
that
tell
you
you're
using
this
api
incorrectly
or
you
know
the
way
you
use
c
sharp
is
not
quite
right.
You
know
make
these
tweaks
to
your
source
code
and
for
dot
net
five.
You
basically
said
a
bunch
of
these
analyzers
should
always
be
on
basically,
so
we
move
them
from
a
nuget
package
effectively
into
the
sdk.
A
So
good
example
here
is
all
the
file
system
echo
apis
that
we
have.
They
only
work
on
windows,
because
that's
just
how
windows
does
permissions
and
you
shouldn't
call
them
unless
you
only
intend
to
run
on
windows,
and
so
in
order
for
us
to
make
this
a
bit
more
easy
for
people,
we
decided
that
it
would
be
nice
if
you
had
an
analyzer.
A
A
You
can
imagine
this
being
the
registry
or
echo
apis,
and
this
could
be
a
platform
api
or
it
could
be
your
own
api
and
so
a
very
common
pattern
here
is
you
say:
okay,
I
have
to
p
invoke
to
something
that
does
something
in
windows
and
then
you
say:
well,
if
I'm
not
running
on
windows,
I
thought
platform
not
supported.
Otherwise
you
know
here's
the
actual
implementation
and
that's
reasonable,
except
the
person
that
calls.
You
doesn't
know
that
right
and
so
like.
Let's
pretend
right
now,
I'm
running
this
on
linux
and
I
execute
this
code.
A
I
have
to
wait
until
vs
wakes
up
there.
We
go.
You
basically
get
a
runtime
exception
right.
It
just
says
you
know:
platform,
not
supported
exception
right.
So
if
you,
for
example,
try
to
open
the
registry
on
linux,
that's
the
experience
that
you're
getting
and
so
people
rightfully
said.
Well,
that's
very
unfortunate!
A
Basically,
that's
that's
what
the
api
author
would
do,
and
we
will
do
this
for
all
the
specific
stuff
that
we
ship
inbox.
You
know
registry
eccles,
winforms
wpf,
all
these
ones
are
marked
and
then
what
ends
up
happening
is.
If
you
call
this,
you
will
get
this
this
warning
right
and
you
get
it
basically
in
the
ide
in
terms
of
you
know,
squigglies
and
tooltips,
but
you
also
get
them
when
you
actually
build.
A
So
you
literally
get
a
build
warning
that
says
well
you're
calling
an
api
that
is
marked
as
windows,
specific
and
your
project
right
now,
in
my
case,
it's
a
net
core
console
app
is
cross-platform,
so
you
know
you
should
do
something
about
that
and
basically
you
know
you
have
two
options.
You
can
either
say
I
myself,
I'm
window-specific.
So
that
means
you
mark
yourself
as
windows,
which
no
means
all
your
callers
will
get
a
warning
as
well
or
you
can
say.
Well,
you
know
I
do
some
extra
stuff
on
windows.
A
So
basically
what
you
would
do
is
you
would
let's
say
you
know:
if
operating
system
is
windows
or
we
have
a
bunch
of
short
hands
in
the
product
and
then,
as
you
can
see
now,
the
warning
automatically
disappears,
because
the
analyzer
knows
that
this
thing
only
executes
when
you're,
not
on
windows.
It
doesn't
really
matter
how
you
write
the
code
right.
You
can
also
do
things
like
this
right
return
right
and
then
you
also
don't
get
a
warning
right.
A
As
I
myself
am
marked
as
being
windows
only,
but
I'm
basically
saying
I'm
I'm
windows
7
and
now,
when
you
call
an
api
that
says
71
you
should
go
to,
you
should
get
a
warning.
Maybe
that's
not
in
this
particular
build
here.
But
basically
the
intention
here
is:
you
will
get
a
warning
that
says
well,
you
are
basically
saying
you're
running
on
7-0,
but
you're
calling
an
api
that
requires
seven
one,
and
so
similarly
you
would
get
a
squiggle
here
and
then
basically,
what
you
would
do
is
you
would
write
your
check
slightly
differently.
A
Instead
of
saying
as
windows,
you
would
say,
is
windows
and
then
you
can
say
is
windows
version
at
least,
and
then
you
can
say
well
how
about
seven
one
right
and
then
same
thing
happens
here,
and
so
the
intent
here
is
that
we
give
you
the
the
ability
to
call
native
operating
system
apis
very
easily.
But
we
also
want
to
make
sure
that
you
don't
have
landmines
in
your
source
code,
where
you
accidentally
call
apis
that
aren't
supported,
and
so
that's
kind
of
the
the
general
pattern
that
we
have.
A
You
probably
could
do
that
because,
as
far
as
we
are
concerned,
they're
basically
just
strings,
but
I
would
not
recommend
that
because
there's
implications
for
the
for
the
for
the
for
the
callers,
so
the
other
thing
that
we
can
do,
which
I
haven't
talked
about
is
you
can
also
do
the
reverse.
You
can
also
say
let's
say
I
have
an
api
here.
A
Let's
say
this
is
not
windows
specific.
Let's
say
this
is
a
generic
api
like
threading,
for
example,
and
I
can
say
well
threading.
I
can't
do
on
certain
platforms
right.
So,
for
example,
let's
imagine
for
a
second.
We
talk
about
web
assembly
right
where
blazer
runs
inside
the
browser
in
web
assembly.
You
can't
create
new
threads.
So
let's
pretend
right
now
this
is,
you
know,
thread
create,
and
then
this
is
you
know
threading.
A
A
I
don't
think
our
current
build
has
that
either
but
like
we
will
basically
know
whether
you
target
browser
or
not
yeah,
here's
a
good
example.
So
basically
it
says
like
well.
I
assume,
because
you're,
a
general
purpose,
library
or
general
purpose
application
right
now.
We
assume
you
want
to
target
everything
by
default,
and
so
that
means,
if
you
call
an
api
that
is
marked
as
unsupported
on
some
platforms
you
you
will
get
this
quickly
as
well
for
browser
in
particular.
A
We
will
tweak
this
because
by
and
large
we
don't
expect
most
people
wanting
to
run
inside
of
a
browser,
and
so
we
will
basically
say
by
default.
When
you
create
a.net
core
console,
app
or
net
core
class
library,
we
will
say:
well,
we
assume
you
want
to
target.
You
know
the
common
platforms,
like
you
know:
windows,
linux,
ios,
mac,
os
android,
but
the
some
of
the
more
constrained
environments
where
you
have
to
do
more
work.
A
And
so
we
don't
want
everybody
to
have
to
deal
with
these
quickly
for
platforms
that
you
are
very
unlikely
to
target,
and
the
idea
here
is
that
in
the
project
file
you
can
select
by
saying
okay
this
one,
I
actually
intend
to
run
on
browser.
So
you
would
just
mark
the
project
file
and
say
I
would
like
to
support
browser
and
in
which
case
you
would
get
these
quicklys.
A
A
That's
a
good
question.
I
think
the
idea
there
is
yes
so
long
I
mean
the
tricky
thing
with
aot
is
like
it
depends
on
how
portable
you
want
the
outcome
to
be
right.
So
if
you,
if
you
basically
say
like
you
know,
of
course
you
expect,
when
you
compile
for
ios
to
not
have
windows,
specific
portions
in
your
code
right
that
makes
sense
right,
but,
for
example,
in
ios,
if
you
build
for
let's
say
ios
10,
what
do
you
want
to
happen
for
code
paths
that
are
ios,
11
or
12.?
A
Generally
speaking,
you
want
to
leave
those
in
right,
so
you
so
you
can't
just
naively
say
you
know,
everything
that
is
outside
of
what
the
ot2
chain
was
building
for
is
unreachable
right.
So,
generally
speaking,
later
versions
should
be
considered
reachable
and
so
that's
kind
of
the
challenge
where
we
have
to
like
be
somewhat
conservative
as
well,
but
yeah.
I
would
generally
expect
that
other
platforms
will
be
linked
out.
B
C
B
B
B
A
A
B
B
A
So
I
would
say
in
the
grand
scheme
of
things
it's
a
mistake
in
the
sense
that
if
we
were
to
redesign
the
apis
from
scratch,
we
wouldn't
do
that
and
by
and
large
we
have
not
done
this
for
net
new
apis.
It's
not
a
mistake
in
that.
You
know
some
people
said
we
should
remove
those
apis
from
the
standard.
A
We
think
that
would
be
a
mistake,
because,
basically
it
means
everybody
who
is
targeting.
Windows
is
now
basically
penalized
by
by
having
to
rewrite
their
code
to
use
new
apis
and
that
would
effectively
break
the
library
ecosystem
and
you
know
all
the
existing
apps
that
are
already
out
there,
and
so
that's
why.
I
think
that's
more
like
a
reasonable
compromise
to
say,
like
okay,
nobody
wants
hidden
landmines
in
their
code
where
stuff
just
blows
up
at
one
time.
A
We
would
like
to
know
it
compiled
them
and
stuff
doesn't
work,
but
I
also
believe
removing
an
api
isn't
necessarily
as
helpful
as
this
quickly.
That
tells
you,
okay,
I
know
what
you
want
to
do
and
I
can
tell
you
that
it
won't
work
because
of
your
configuration
right.
That
is
much
much
more
actionable
than
just
a
compiler.
That
says
sorry,
I
can't
find
you
know
directory
get
permissions,
for
example
right,
because
then
it's
like
well
what
api
am
I
supposed
to
call
like?
C
A
Yeah
something
like
the
I
mean
the
version
number
is
basically
the
version
number
that
the
os
has
right
so
like.
In
that
sense,
it's
not
up
for
us
to
decide
right.
If
the
you
know
windows
has
you
know
ten
point,
you
know
zero
point.
You
know
four
digit
version
number
whatever
it
is
right
by
and
large,
the
one
thing
we
have
done
is
like
for
things
like
windows.
A
Usually
we
don't
put
a
version
number,
which
is
basically
to
say
you're,
basically
saying
0.0
right,
and
so
that's
technically
not
true
right.
The
windows
registry
isn't
supported
since
windows
0.0,
but
when
you
say
0.0,
it
means
if
you,
if
you
check
for
the
whether
you
can
use
the
api,
it
means
you
don't
have
to
check
for
the
version
number
right.
So
if
you
just
say,
if
operating
system
is
windows,
that's
considered
sufficient
to
check
for
the
api,
because
it's
available
since
0.0,
if
you
would
have
said
sorry,
the
registry
is
available.
A
Since
I
don't
know
windows,
you
know
four
point
something
right
which
is
probably
true.
Then
you
wouldn't
get
away
with
just
saying
it's
windows.
Now
you
would
have
to
say.
Is
windows
version
at
least
four
point
something,
and
given
that
we
don't
support
these
old
versions
of
windows
anywhere
with
dot
net
the
minimum
we
run
on
this
windows
7.
We
can
basically
say
anything
that
that
is
windows
7
or
earlier.
We
don't
put
a
version
number
because
it
means
you
don't
have
to
check
for
the
version
number
right.
A
But
if
we
add
net
new
apis,
let's
say
we
add
some
wpf
or
winforms
apis
that
only
work
on.
Let's
say:
windows,
8
or
windows,
10
right,
then
we
would
start
annotating
them
with
the
correct
version
numbers
because
you
could
run
on
windows
7,
but
the
api
isn't
right
and
then
you
would
have
to
actually
write
a
version
check
for
that.
And
so
that's
the
general
pattern
that
we
have
same
with
browser
browser
doesn't
really
have
a
version
number
either
right,
because
it
just
is
indicative
of
the
you
know,
sandbox
for
the
browser.
A
A
Yeah
so
like
I,
I
basically
showed
two
attributes
so
far.
I
I
showed
supported
and
I
shot
unsupported.
We
also
have
obsoleted
inos
platform,
which
is
kind
of
the
same
thing
as
obsolete,
except
that
it's
basically
conditioned
on
the
version
of
the
platform.
So
the
economic
example
here
is
ios,
let's
say
like
for
ios.
The
expectation
is
the
latest
version
of
the
ios
sdk
will
have
all
the
apis
that
that
ios
has
or
the
current
version
of
ios
has.
But
it
will.
A
You
will
also
be
able
to
target
older
versions
of
it
with
the
same
sdk.
That's
where
we
basically
have
to
indicate
that,
oh,
if
apple,
let's
say,
removed
an
api,
it
would
start
marking
the
apis
unsupported
to
as
platform
for
that
version
number
and
then
in
the
same
way,
usually
what
apple
does
is
they
will?
First,
you
know
obsolete
or
deprecate
the
api,
so
we
would
usually
start
with
obsoleted
in
attribute
and
then
later
on.
If
they
actually
physically
remove
the
api,
we
would
then
say
unsupported,
and
so
the
idea
is
yes.
A
If
you,
if
you
call
an
api
that
is
considered
obsoleted,
you
would
get
a
normal,
obsolete
warning
that
you
get
today,
but
it
would
be
conditioned
on
what
platform
your
your
project
configuration
says
you
are
supporting,
and
so,
if
you,
if
you
bump
the
version
number
to
something
higher,
then
you
will
get
it.
If
you
bump
it
for
something
lower,
then
you
don't
get
it
because
it
wasn't
obsoleted.
Yet.
B
B
Well,
I
think
I
think
this
is
how
I'm
interpreting
the
question.
It's
like
you
know,
included
these
apis
because
they
were
already
on
those
types
and
it
would
have,
you
know,
been
really
harmful
to
compatibility
and,
as
a
result,
we
kind
of
aren't
we're
investing
in
this
analyzer
right
to
make
the
experience
better.
So
why
not
just
deprecate
them,
and
so
my
my
expectation
tell
me
tell
me
if
I'm
wrong
is
well.
B
A
Yeah
so
that's
kind
of
the
you
may
yeah.
That's
basically
the
point
right.
If
you
look
at
the
registry,
for
example,
the
registry,
I
would
argue,
is
a
very
good
api
for
the
windows
registry
right,
there's
nothing
wrong
with
the
api
right.
The
api
is
fine,
it's
just
the
question
of
like.
Should
you
be
able
to
use
it
when
you're
building
a.net
core
app
by
default?
A
And
then,
if
you
say
no
well
then
what's
the
solution
right
then
you
would
say:
oh
you
have
to
target
net
5-windows
to
use.
You
know
the
the
registry
apis,
but
that's
not
how
the
world
previously
worked
right.
So
then
we
would
have
to
effectively
break
compact
with
net
standard
to
pull
that
off,
and
that
seems
more
harmful
than
doing
the
targeted
thing.
But
even
let's
say
we
were
to
do
that
right,
let's
say
even
we
would
be
willing
to
do
that.
A
You
don't
have
to
do
extra
work
to
pull
that
off,
and
so
I
think
the
experience
that
we
have
solves
both
things
very
neatly,
but
the
idea
that
we
can
just
remove
things
doesn't
really
scale.
If
you
have
to
support
multiple
versions
of
an
of
an
operating
system,
especially
once
you
don't
get
to
control
right,
I
mean
we
don't
get
to
tell
apple
what
to
remove
right.
They
they
just
do
whatever
they
feel
like
it
right,
and
we
just
have
to
model
that
in
our
tooling.
C
C
C
It's
in
your
browser,
not
the
cloud
but
yeah
anyway,
you
can
open
it
up.
You
can
look
at
your
at
your
bin
log.
You
can
do
the
things
that
you
could
do
previously
in
structured
log
viewer
on
your
windows
machine,
but
now
you
can
do
it
in
your
browser,
which
means
you
can
do
it
cross-platform,
and
so
anyway,
we're
super
proud
of
that
and
don't
miss
that
for
those
of
you
that
love
it
up
in
the
upper
right
corner.
C
A
couple
things
if
you're
a
system
command
line,
fan
that
we're
working
on,
I
just
want
to
mention
app
models
are
moving
along.
It
ran
into
a
problem
with
binding,
so
we've
unified
the
binding,
and
I'm
super
excited
that
that
pr
hopefully
will
go
in
this
week
and
we
also
have
a
pr
for
localization
super
excited
to
get
that
done
and
then
finally,
I'm
definitely
interested
in
folks
that
care
about
our
releases
dot
json
filing.
C
No,
you
don't
know
what
that
is
to
start
with,
but
this
is
the
way
that
we
put
out
the
what
new,
runtimes
and
sdks
we
have
available,
and
we
haven't
a
file
called
releases.json
and
there's
a
releases.index.json
as
well,
which
is
a
shortcutted
version,
and
we
are
looking
at
possibly
putting
an
api
and
maybe
a
global
tool
on
that,
and
it
would
be
super
helpful
to
understand
how
people
would
want
to
use
that.
So
our
expectation
is
that
you
could
ask
questions
like.
Is
there
a
new
update
and
that's
the
that's?
C
What
we're
thinking
in
terms
of
and
I'd
love,
any
feedback,
any
questions.
Anybody
has
anything
I
want
to
do
this
with
it
and
we'll
try
to
make
that
a
supported
scenario.
So
this
is
stuff
that
we're
doing
planning
on
right
now
and
in
a
planning
state.
Obviously,
feedback
on
how
somebody
would
use
this
new
feature
would
be
extremely
helpful.
C
So
if
you
think
that
you
would
like
to
have
an
automated
way
to
find
out
what
releases
are
available,
it
is
one
step
overall
we're
looking
at
acquisition
overall
we're
looking
at
making
your
life
easier
supposed
to
put
things
on
your
machine
and
take
them
off.
This
is
just
this
one
step
of
understanding,
what's
actually
in
our
main
feed,
and
I
don't
have
a
link
for
that,
but
I
can
get
one
in
just
a
minute
and
we
can
put
it
in
after
after
philip
starts
talking.
C
C
D
E
D
D
E
D
All
this
does
is
just
download
some
csv
files,
because
if
you
just
want
to
do
something
like
download
a
file,
powershell
is
really
really
succinct
for
that.
Next,
I'm
going
to
write
some
f
sharp
code
here.
That
extends
the
system
collections
generic
list
and
adds
this
api
called
get
reverse
index.
This
is
an
f
preview
feature.
D
D
D
It
runs
a
regex
over
it
and
then
it
writes
the
clean
data
back
into
the
file.
So
I'm
gonna
run
this
clean
function
on
these
three
csvs
that
I
just
downloaded.
So
it's
gonna
do
that
and
then
it
says
all
cleaned
up.
All
right
cool,
so
I've
stripped
out
some
bad
stuff
inside
of
those
files
we
go
like
here
now
they
kind
of
look
like
this.
I
have
a
rainbow
csv
extension
installed,
so
it
looks
all
pretty
so
now
we're
going
to
load
it
into
a
data
frame.
D
So
to
do
that,
I'm
going
to
need
to
incorporate
a
nuget
package
I'll
just
go
ahead
and
do
that
notice
that
the
syntax
was
pound,
our
nuget
colon
name
of
package,
comma
version
number.
I
actually
don't
need
to
specify
the
version.
I
can
actually
just
write
it
out
like
this,
but
I
chose
to
specify
the
version
because
you
know
whatever
and
then
I'm
just
going
to
go
ahead
and
open
that
the
main
name
space
there
data.analysis
so
now.
This
is
it.
D
This
is
actually
pretty
interesting,
because
if
you
compare
this
to
the
python
world,
let's
say
you're
doing
jupyter
notebooks
in
python.
You
cannot
write
code.
This
simple
to
incorporate
a
third-party
package.
You
actually
need
to
new
up
a.
I
think.
It's
like
a
hippie
envy
or
something
or
pie.
Env.
There's
like
multiple
these
things
called
environments
in
python
and
they're.
They
they're
kind
of
annoying,
and
if
you
don't
do
that,
then
you're
actually
not
being
safe
and
you
could
destroy
something
on
your
system.
D
We
don't
have
that
problem
in
fsharpen.net,
so
it's
really
trivial
to
incorporate
a
third
party
package
into
your
notebooks
and
get
going.
So
what
I'm
going
to
do
is
I'm
going
to
have
access
now
to
this
data
frame
type
and
I'm
just
going
to
load
those
things
up
into.
You
know
the
the
data
frames
from
there's
this
api
called
low
c
it
loads
csv
it
loads
it
into
a
data
frame.
D
So
it's
basically
going
to
be
like
a
series
of
series
that
I'm
adding
in
there
and
then,
when
I'm
done,
I'm
going
to
press
them.
So
I'm
just
going
to
execute
the
cell.
It's
processing
a
bunch
of
dates
and
it's
done
all
right
cool.
So
now
that
we
have
this
data,
we
can
decide
to
chart
this
data,
which
is
where
things
get
a
little
interesting.
D
So
I'm
going
to
be
using
a
a
plotting
api
called
plotly,
which
actually
is
a
javascript
api
that
we
have
some
dot
net
bindings
to
and
first
I'm
going
to
construct,
what's
called
a
layout.
A
layout
is
just
sort
of
like
laying
out
sort
of
general
stuff
about
the
chart
that
you
know
how
you
want
to
visualize
it
like.
What's
the
font,
what's
the
title
there,
what's
the
background
color
going
to
be
there's
an
option
called
a
geo
and
there's
some
for
like
showing
like
a
globe
in
a
chart,
and
then
you
can.
D
D
So
if
we
look
up
here,
there
were.
Oh
sorry,
I'm
just
constructing
a
a
series
of
confirmed
recoveries,
basically
that
I
have
here
because
I
like
good
news
and
so
then
I'm
going
to
be
doing
a
little
negative
indexing
here
actually
or
reverse
indexing.
I
guess
you
could
say,
and
so
I'm
going
to
be
looking
at
the
series
and
I'm
going
to
take
the
item.
D
That
is
zero
from
the
end
and
then
I'm
just
going
to
get
the
latitude
the
longitude
some
of
the
data
I'm
going
to
construct.
This
thing
called
a
marker
and
this
is
going
to
be
what's
called
a
trace
and
the
trace
represents
it's
sort
of
like
the
data
frame
that
we
had
before.
Except
it's
going
to
be
a
plotable
data
structure.
D
So
I'm
just
going
to
pipe
that
into
the
chart.plot
function
and
I'm
going
to
pipe
the
results
of
that
into
the
chart.with
layout
function
and
then
the
layout
is
going
to
take
in
whatever
the
date
is.
So
I'm
going
to
execute
that
and
we
should
be
able
to
see
an
inline
chart
right
here.
So
we
can
look
at
covet,
19
recoveries
for
8,
12
20
and
at
least
in
the
data
set
that
I
have-
and
you
know
you
can
you
can
do
some
some
fancy
stuff
right
here.
D
D
So
now,
if
you
notice
that
used
to
say
html
now
it
says
philip.
So
this
is
actually
some
cross
language
interop
that
we
have
here
where
this
f
sharp
value
in
the
notebook
is
actually
serialized
with
json.net
into
json.
And
then
we
can
then
extract
it
from
javascript,
because
it's
just
json,
which
is
pretty
neat.
So
then
we
should
also
be
able
to
do
some
basic
stuff
like
that
between
f,
sharp
and
c
sharp.
D
D
So
we
have
value
sharing
between
f,
sharp
and
c
sharp
and
there's
a
few
limitations
like,
for
example,
say
I
defined
a
data
structure
inside
of
c
sharp,
and
I
tried
to
share
the
value
of
that
data
structure
with
f.
Sharp
sharp
is
not
going
to
know
what
that
data
structure
is
and
then
vice
versa.
Right
like
if
I
have
an
f,
sharp,
specific
type
and
then
I
choose
to
share
it
with
c
sharp,
but
the
c
sharp
doesn't
have
the
definition
of
that
type.
D
It's
also
not
going
to
work,
but
you
know
for
values
like
actual
just
shareable
values.
Those
are
trivial
to
share
now,
and
so
there's
there's
it's
done
with
this
little
shebang
that
we
call
hashbang
share,
and
this
is
an
area
that
we're
working
a
lot
in
the
in
the
notebook
space.
So
it's
pretty
cool,
it's
still
all
in
preview.
D
A
D
Released
string
interpolation
for
so
I
shouldn't
say,
release
we
recently
merged
string,
interpolation
into
f
sharp,
and
so
you
can
do
some
pretty
basic
stuff.
Like
you
know,
okay,
you
know,
there's
still
like
a
few
little
rough
edges
here
and
there,
because
you
know
this
is
the
very
first
version
and
it's
the
very
first
integration
in
digital
suit,
but
it's
actually
in
pretty
good
place.
Like
you
know,
I
could
say
my
age
is,
and
I
could
say
12
and
my
age
is
12.,
so
I'm
12
years
old
isn't
that
nice.
D
D
You
know
I
can
sort
of
do
what
I
want
there,
which
is
pretty
cool.
I
shouldn't
hit,
save
I'll,
go
ahead
and
execute
that
in
fsharp
interactive
and
now
it
says
my
name
is
philip
carter
and
my
age
is
12.,
which
I
think
is
a
pretty
pretty
accurate
there.
It's
got
all
full
ide
integration
inside
these
values,
kind
of,
as
you
would
expect,
instead
of
visual
studio
tooling,
but
you
can
do
more.
D
D
D
Cool
all
right:
oh
there's,
some
little
indentation
warnings
going
on
here.
Let
me
let
me
fix
that
this
is,
but
now
we're
getting
into
bizarre
territory.
This
is
not
something
that
people
would
actually
normally
do,
but
so
I've
refined
a
series
of
functions
that
I've
then
called
with
a
value
inside
of
an
interpolated
string
in
f-sharp,
and
so
you
cannot
do
anything
reminiscent
of
this
in
c
sharp.
It's
not
really.
The
kind
of
capability
that
I
would
say
is
going
to
be
terribly
useful
for
people
they're,
mostly
just
going
to.
D
Inside
of
their
their
strings
there,
but
it's
actually
pretty
fun,
and
on
top
of
that
I
can
actually
just
go
ahead
and
reset
this
interactive
session.
I
can
set
a
breakpoint
and
then
I
can
start
debugging,
and
so
I'm
gonna
I
can.
I
can
I
I
bear
with
me.
I
have
definitely
not
tested
this
debugging
an
f-sharp
script
in
the
dog
food,
build
of
vs
with
a
program
inside
of
my
interpolated
string.
Okay,
so
it
was
able
to
pull
up
the
values
there.
This
is
pretty
good.
D
A
D
A
D
D
Yeah,
you
can't
do
you
can't
do
statements,
you
can't
embed
like
functionality
itself
like
you,
can't
define,
for
example,
a
function
inside
of
a
c
sharp
or
sorry
like
a
local
function
instead
of
a
c-sharp,
interpolated
string
context
right,
you
just
can't
do
that.
You
have
to
define
everything
outside
and
you
could
potentially
call
it
inside
of
the
the
string
context,
but
you.
D
E
D
E
D
D
A
Yeah
I
was
about
to
say
that,
because
now
there
were
some
questions
in
chat
that
I
wish
she
could
answer.
So
one
question
was:
is
there
a
git
repo
for
the
web-based
bin
lock
viewer
like
I
I
I
don't
know
the
answer
to
that.
But
there
is
a
generic
repo
for
this.
If
let
me
just
pull
up
the
url
for
the
bin
log
viewer
and
there's
probably
a
branch
would
be
my
guess.
A
A
It's
really
nice
visualizer
and
I
would
I
would
guess
that
there's
probably
either
a
discussion
there
somewhere
at
least
that's
where
you
could
ask,
and
then
there
was
this
other
file
that
kathleen
talked
about
earlier,
which
was
the
you
know,
the
index.json
file
for
the
releases
which
you
can
find
here.
It's
in
the
download.
B
A
C
B
A
what's
what's,
this
is
like
a
perennial
type
of
question
with
dot
net
and
when
I
first
started
using.net
I
was
actually
a
little
bit
or
quite
confused
about
this.
So
the
question
was:
I
have
one
question
with
direct
in
class:
is
there
a
difference
in
performance
in
c-sharp
or
net
and
security
or
can
or
you
know,
please
tell
me,
I'm
paraphrasing
yeah,
please
tell
me
the
advantages
and
disadvantages
of
using
struct
over
class
thanks.
So
I
said,
struck
versus
class
is
related.
How
do
you
want
the
included
data
used?
B
If
you
want
the
same
data
to
be
used
in
multiple
places,
then
the
class
is
better.
If
the
data
is
temporary,
then
a
struct
is
better
and
then
I
said
you
can
look
at
examples
of
where
we've
used
classes
versus
structs
recently
and
see.
If
you
can
explain
to
yourself
why
instructor
class
was
used
and
then
the
default
answer
is
always
class,
and
then
you
can
convince
yourself
that
a
struct
is
better.
That's
the
model
used
in
the
net
team
and
then
there
was
a.
B
Question,
oh
yeah:
how
did
like?
How
does
records
change
that
guidance?
That's
what
douglas
asked
and
then
I
said,
good
questions
on
records.
I
haven't
played
with
records
yet
so
I
cannot
answer
that.
I
think
records
fall
closer
to
scenarios
where
you
would
use
immutable
collections
and
friends
and
that's
where
it
ended
and
that's
where
I'm
looking
at
the
language
experts
on
the
call
to
help
continue
a
good
conversation.
A
D
A
set
of
design
concerns
around
that
that
need
a
bit
hash.
Show
I
mean,
I
think
really.
The
answer
to
this
is
records
provide
a
very
obvious
improvement
for
one
of
the
most
common
uses
of
c
sharp,
which
is
defining
just
you
know,
clap
just
data
inside
of
the
class
with
properties
and
it
sucks
it's
boilerplate
and
records
make
it.
So
it's
not
boilerplate
anymore
and
that's.
I
think
something
that
a
lot
of
c-sharp
users
are
gonna
love
beyond
that.
D
I
think
we're
really
gonna
learn
more
from
from
people
like
I
mean
that
one
feels
pretty
obvious,
you
know
there's
some
additional
stuff
you
can
do
with
incredibility,
and
you
know
with
expressions
and
like
you
know,
maybe
there's
going
to
be
some
people
who
are
going
to
take
that
and
run
with
you
know
using
it
with
other
immunes
and
that
sort
of
stuff,
but
we're
gonna
have
to
wait
and
see.
I
think
also.
D
But
what
influences
that
work
is
going
to
be
based
off
of
the
feedback
that
we
get,
and
I
think
that
was
one
of
the
goals
is.
You
know
here's
kind
of
like
a
nice
fairly
simple
core
design
for
records.
It's
shipping
in
c
sharp
nine
that
improves
some
very
obvious
use
cases.
But
then
you
know,
users
are
gonna,
be
able
to
take
that
and
do
some
interesting
stuff
with
them
and
that'll
sort
of
influence
where
we
go
from
there.
B
Is
it
fair
to
say
that
the
the
first
thing
that
it
kind
of
replaces
or
touches
before
immutable
collections
is
more
like
tuples
in
terms
of
like
you
know,
sometimes
I've
used
tuples
as
like
a
temporary.
You
know
very
you
know,
supposedly
lightweight
modeling
system,
so
that
I
don't
have
to
define
a
class.
Does
it
replace
that
use
case
scenario,
yeah
right.
C
One
goal
is
that
it's
a
smooth
next
step:
it's
got
a
few
more
features,
then
I
think
you're
gonna
get
in
some
of
the
I'm,
not
sure
the
comparisons
and
all
the
shorts
cutting
and
all
that,
I'm
not
sure
all
that
maybe
better
in
records.
But
basically,
if
you've
got
a
tuple
and
it's
getting
big,
it
should
be
a
straight
line
to
getting
records
and
similar
functionality.
There.
A
E
C
C
So
if
we
can
move
forward
on
some
extra
features,
we're
all
for
that
right
now,
the
goal
of
the
online
log
viewer
was
to
hit
the
same
basic
functionality
as
the
as
as
the
windows
one.
We
did
do
a
little
bit
of
work
around
icons
because
I
was
like
yeah
colors
aren't
good
enough,
because
we
want
to
be
a
little
bit
more
accessible
than
that,
so
we
did
get
some
icons
in,
but
overall
it's
just
a
new
version
of
that.
That
runs
runs
in
the
browser.
A
A
A
D
A
Yeah
I
mean
resharper
should
be
able
to
use
them.
So
basically,
the
follow-up
that
martin
has
is
like
social
engineers.
Do
need
something
up.
Experience,
tweaks
and
resharper
should
be
able
to
use
them
as
well.
I
mean
they
are.
I
mean
it's
just
a
you
know
it's
similar
to
an
an
analyzer.
It's
a
plugin
to
the
compiler
and,
to
my
knowledge
they
already
support,
analyzers
and
so
yeah.
Supporting
generators
is
something
that
that
you
know
they
can
do.
A
I
mean
my
understanding
right
now
is
that
we
don't
have
a
lot
of
the
experience
tweaks
in
vs,
either
they're
still
coming
in
right,
but,
like
that's,
you
know,
the
expectation
is
that
it
should
just
work
but
depending
on
how
they
populate
their
you
know
their
compilation
context
for
intellisense.
They
may
have
to
do
extra
work
to
do
that
is
similar
to
what
we
have
to
do
for
visual
studio
yeah.