►
Description
Get the latest scoop from the people who build .NET! See what's new with .NET Core, ASP.NET Core, Xamarin, C#, Azure, AI/ML and where we're taking .NET into the future!
A
A
A
Then,
let's
roll
into
this
thing,
okay,
so
net,
one
of
the
mantras
we've
had
the
last
couple
of
years
is
you
can
build
any
type
of
application
net,
whether
it's
a
desktop
application
and
a
web
application.
A
cloud
application
mobile
gaming-
we
just
recently
earlier
this
year
at
it
IOT
support
for
dotnet,
core
and
AI
support
for
the.net
platform.
So
we
think
that,
no
matter
what
you
want
to
build,
you
can
build
it
with
dotnet
really
excited
about
the
growth
of
Nets
people.
Always
ask
me:
hey:
should
I
invest
in
net?
A
Is
it
still
growing
1
million
new
developers
in
the
last
year,
and
so
dotnet
is
a
super-healthy
platform
and
super
growing?
The
other
one
is
dotnet
core.
You
know
we
ship
this
a
couple
years
ago,
it's
starting
to
mature
in
the.net,
Core,
2,
Oh
wave
and
we've
got
over
half
a
million
developers
every
day,
writing
code
and
dotnet
core.
A
So
we're
super
happy
about
that.
The
last
time
I
spoke
to
everybody
was
around
the
build
conference
and
we
were
showing
some
previews
of
dotnet
core
2.1.
We
shipped
this
at
the
end
of
May
and
you
can
get
it
today.
I
wanted
to
quickly
highlight
some
of
the
big
things
that
happened
in
dotnet,
core
2.1
and
you'll.
See
here.
We've
always
cared
about
performance
and
net,
and
we
want
to
prove
to
our
customers
that
dotnet
is
a
super-fast
platform.
So
there's
a
public
benchmark,
which
means
we
don't.
You
know
we
don't
run
the
run.
A
The
benchmark
and
we've
been
working
to
continue
to
make
dotnet
work
better
in
all
phases
of
that
benchmarking.
So
you
can
see
here
on
the
slides
plain
text.
Were
up,
15%
Jason
were
up
18%
data
access,
we're
up
a
hundred
and
forty
seven
percent
and
and
the
last
one
probably
matters
the
most,
because
most
applications
actually
are
some
form
of
rendering
and
some
form
of
data
access,
and
you
can
see
these
huge
improvements
in
all
of
these.
A
A
If
I
scroll
down
here,
you
can
see
that
we
have
a
a
spinet
core
at
around
number
11
in
this,
but
you're
going
to
notice
that
the
top
players
here
are
all
roughly
at
the
exact
same
percentile
we're
at
99
percentile
compared
to
100
percentile,
the
Delta
between
a
espenak
core
and
the
top
item
is
roughly
less
than
a
hundred
and
fifty
thousand
requests
per
second,
so
everybody
at
the
top
is
super
fast
and
we're
at
the
top
of
that.
Now.
A
What
I
said
before
is
great
plain
text,
who
writes
a
plain
text:
application,
not
not
many
people
if
I
go
to
fortunes.
This
is
the
craziest
form
of
the
demo.
Where
are
the
benchmark?
It's
got
web
rendering
it's
got.
Data
access,
it's
calling
endpoints
and
you're
gonna
see.
Asp.Net
is
once
again
in
roughly
the
top
ten
in
this,
and
this
is
where
you
saw
that
data
growth
that
making
our
data
performance
grow
is
what
helped
us
catapult
dotnet
in
here.
A
What
were
the
major
features
and
I'm
just
going
to
quickly
go
through
those?
We
added
a
bunch
of
cool
features
in
dotnet,
core
2.1.
One
was
global
tools.
This
is
the
ability
to
actually
install
command
line
tools
right
from
new
get
you
can.
If
you're
familiar
with
NPM,
you
could
do
NPM,
install
gee
that
wouldn't
globally
install
a
tool.
Now
we
have
a
dotnet
version
that
same
thing,
so
you
can
right,
cross-platform,
dot,
net
core
console
application
and
install
it
with
a
one-line
command
on
any
device.
A
We
rewrote
the
socket
layer
in
net,
which
is
why
you
saw
some
of
those
performance
numbers
you
saw
in
those
benchmarks,
but
we
didn't
focus
on
the
server
we
also
focused
on
the
client.
We
rewrote
the
HP
client
to
be
way
faster.
It's
about
ten
times
faster
and
dotnet
core
2.1.
Well,
we
continue
to
make
dotnet
core
2.1
more
compatible
with
existing
net.
So
there's
a
windows
compatibility
nougat
package,
if
you're
an
EF
e
of
core
customer,
my
favourite
feature
here
is
we
added
lazy
loading.
A
It's
one
of
the
most
popular
features
in
EF
that
our
customers
are
using.
It
wasn't
in
core
once
again
we're
feedback
driven.
We
took
that
feedback
added
it
to
EF
core
2.1.
Then
an
asp.net
core.
There's
been
this
huge
push
this
this
year
and
making
all
websites
HTTP,
and
so
a
espenak
core
is
HTTP
by
default.
A
For
the
first
time
ever,
we've
allowed
you
to
take
web
UI
and
actually
put
it
into
a
library
and
NuGet
package,
so
you
can
share
it
across
multiple
applications
and
we
have
this
really
cool
feature
called
HTTP
client
Factory,
which
I'll
do
a
demo
in
a
second,
and
we
also
brought
one
of
our
beloved
frameworks
from
the
dotnet
framework
world
signal.
R
is
now
available
in
core
as
well.
So,
let's
jump
here
and
I'll
talk
about
one
more
thing:
real,
quick
signal,
R
as
it
as
it
RT
m4
core
in
2.1.
A
We
also
know
that
signal
R.
We
always
have
customers,
call
us
and
say
how
do
I
build
a
really
highly
scalable
signal.
R.
We
have
an
azure
service
that
you
can
run
your
signal,
our
back-end
in
inside
of
azure,
and
you
can
dress,
drag
sliders
to
auto
scale
that
application
and
we
do
the
hell
you
lifting
for
you
and
what
I'm
super
excited
to
announce
today
is
on
September
24th
at
ignite,
we're
going
to
GA
this
service.
So,
let's
move
on
and
let's
do
a
quick
demo
of
dotnet
core
2.1.
A
So
I
mentioned
this
thing
called
HTTP
client
factory,
and
we
always
talk
about
it
and
it's
sometime
sometimes
I
think
confuses
people
because
it's
it's
kind
of
a
hard
to
hard
to
see,
feature
and
I'm
gonna
try
to
dumb
it
down
today
and
make
it
really
simple
for
everybody
to
see
so
got
a
an
application
here,
and
it's
got
an
API
and
I'm
just
using
the
typical
values
controller
that
we
gave
you
in
a
default
in
a
default
application.
So
it's
not
got
it's
not
doing
anything.
Crazy.
A
I've
got
a
get
method
that
just
returns
a
value.
So
it's
not
very
usable,
but
it's
gonna
highlight
the
point.
So
let's
take
this
API
and
let's,
let's
start
it
so
I
will
just
go
over
here
and
we'll
say
start
without
debugging
and
the
API
is
going
to
boot
up
and
run
now.
I've
got
a
simple,
app
and
I'm
sure
this
app
is
is
very
simple,
similar
to
what
you
the
customer
is
probably
doing,
and
it's
got
this
index.html
HTML
and
inside
of
it
it
makes
an
API
call.
A
Let
me
just
take
that
away.
It
makes
an
API
call.
So
it's
not
not
anything
crazy
and
you've
all
probably
done
this,
and
this
is
great.
I
can
run
this
application
and
so
basically,
whenever
the
index
page
is
hit,
it
makes
an
API
call
to
that
API
and
I'm
sure
your
applications
do
something
like
this,
whether
it's
a
desktop
app
a
web
app-
and
you
see
this-
this
works
great
now,
I'm
gonna
change
things
a
little
bit.
Let
me
go
back
to
my
API
and
I
wrote
this
cool
piece
of
code.
A
Here
it's
called
a
random
failure,
middleware
and
so
what
it's
gonna
do
it's
gonna
make
my
app
fail.
Randomly
and
I
want
to
do
that,
because
we
know,
networks
go
up
and
down
connections
go
up
and
down,
and
you
should
make
apps
resilient
to
this
so
I'm.
Just
gonna,
add
this
middleware
random
failure,
middleware
and
if
I
scroll
here
you'll
see
that
all
it
does
is
looks
to
see
if
a
random
value
is
there
and
it
throws
an
exception
sometimes,
and
sometimes
it
doesn't
throw
an
exception.
A
So,
let's
restart
this
Apple
oops,
we'll
restart
the
app
with
that
middleware
enabled
and
now,
if
I
go
back
to
my
client
app,
you
know,
I
assume
everybody
can
expect.
What's
gonna
happen
is
if
I'm
back
to
my
client
app
it's
going
to
start
failing.
Occasionally
there
you
go
and
I
refresh
the
page,
it
fails.
So
what
would
you
do
as
a
customer
in
the
past?
What
you
would
do
is
you
would
go
into
your
index
page
and
you
would
probably
write
some
retry
logic
around
this.
Now.
A
That's
great
you'd
write
this
retry
logic
everywhere
you
call
an
API
or
maybe
you
only
harden
one
API
or
another
API
or
maybe
you
write
a
wrapper
around
HP
client.
That
does
this
for
you,
and
so
what
we've
done
in
2.1
is
we've
added
the
ability
for
you
to
set
policies.
So
I
can
say.
Add:
let's
go
down
here.
Http
client.
A
And
I
can
now,
with
with
the.
What
I
can
do
here
is
I
can
create
a
HP
client
factory,
and
what
this
means
is
I
can
create
a
an
HP
client
and
give
it
a
bunch
of
rules
and
with
those
rules,
I
can
define
a
bunch
of
stuff
that
you
can
do
so.
Look
here,
add
HTTP,
client,
API
and
then
I
say,
add,
transit,
error
policy,
so
I'm
saying
hey,
I
want
to
have
at
Rand
air
policy
and
what
I
do
say
is
I
here
as
I
say:
policy
retry,
async
six,
which
basically
means.
A
If
you
fail
try
again
six
times
now
you
can.
You
can
set
multiples
of
these
there's
a
whole
bunch
of
these
that
are
available,
but
by
setting
that
that
line
there
I've
now
got
a
set
of
rules
that
are
applied
and
then
it
might
in
my
code
instead
of
creating
a
HP
client.
This
way
I
can
go
and
ask
the
factory
to
do
that.
For
me,.
A
I'm
going
to
give
it
that
name
that
you
saw
earlier
API,
so
it
will
look
that
up
and
then
so
everywhere.
In
my
code,
instead
of
just
mooing
up
an
HTTP
client,
now
I
say
factory,
give
me
one
called
this
and
those
rules
are
applied
to
it.
So
I
can
now
run
this
code
again
and
now,
even
with
that
API
throwing
exceptions,
this
app
is
not
going
to
crash
because.
A
There
we
go
now
we're
going
to
run
it
again
here
and
I
can
refresh
this
as
many
times
as
I
want
it'll,
never
crash,
because
I've
set
that
policy,
and
so
this
is
a
great
feature
you
should
be
using
in
your
apps
today.
Set
your
policies,
don't
write
code
around
all
these
api's
and
it's
part
of
our
work
to
make
micro
services
better
in
net.
So,
let's
move
on
and
let's
talk
about
2.2.
So
just
this
morning
we
shipped
preview
to
of
dotnet
core
2.2
it's
available.
A
Today
you
can
grab
it
right
now
and
let's
talk
about
some
of
the
big
highlights
or
the
themes
that
we
have
in
the
2-2
wave.
One
of
these
things
is,
we
want
to
make
Web
API
is
easier
to
build
every
app,
whether
it's
a
web
app
or
a
mobile
app
or
a
desktop
app
is
probably
calling
some
api's.
We
know
this
is
an
important
area,
so
we
want
to
make
it
easier
for
you
to
build
api's
and
to
build
clients
that
can
call
those
api's.
A
You
just
saw
with
the
HTTP
client
work
we
did
in
2.1.
We
make
it
easier
to
call
api's
micro
services,
we
hear
micro
services
all
the
time
and
so
there's
a
bunch
of
work,
we're
doing
to
make
micro
service
better
in
net
and
we're
always
continuing
to
continuing
performance,
whether
it's
building
your
applications
or
running
your
applications,
those
the
big
themes.
So,
let's
go
over
some
of
the
the
major
features:
multi-tiered
JIT
compilation.
This
is
the
ability
for
us
to
quickly
get
your
application,
get
it
running
and
then
to
notice.
A
If
it's,
if
it's
actually
hitting
the
same
method
a
lot
of
times,
maybe
we
should
get
it
again
and
make
a
faster
version
of
it
sequel
connection
with
token
auth.
This
is
a
support
for
the
first
time
to
actually
grab
a
token
to
talk
to
your
sequel,
server
from
Active
Directory,
so
you
don't
ever
have
to
have
any
client
could
credentials
that
are
put
in
configuration
files
or
anything
like
that.
Ef
core.
One
of
my
first
two
features
are
my
favorites
cosmos
DB.
A
We
know
that
there's
non-relational
databases
out
there
and
you
might
want
to
use
the
same
EF
programming
model
to
talk
to
a
relational
database
or
a
non
relational
database.
So
you
can
use
Azure
cosmos
right
from
EF
core
today
with
two
two
spatial
extensions.
This
has
been
one
of
the
most
requested
features
for
EF,
which
is
spatial
in
this
cases,
types
for
geographic
locations-
if
you
want
to
have
a
longitude
latitude,
because
maybe
when
you
want
to
look
at
somebody's
GPS,
coordinates
and
figure
out
where
they
are
and
run
queries
in
a
database.
A
We've
not
had
those
in
see
in
EF
or
dotnet
core,
and
so
those
are
both
there.
We
have
a
feature
in
the
app
where
you
can
actually
point
it
at
an
existing
database
and
we'll
make
you
a
model
now
it
has
the
ability
to
actually
take
views
in
that
database
and
expose
them
and
the
model
for
you
as
well.
So
those
are
some
pretty
awesome
features
in
EF,
cool
or
AAS
kinetochore.
A
We've
updated
all
our
templates
with
the
latest
versions
of
web
frameworks,
whether
it's
bootstrap
or
angular,
Web
API
is
one
of
my
favorites
one
of
the
common
things
that
I
get
when
I
go
talk
to.
Customers
is
how
do
I
secure
an
API
and
so
for
the
first
time
ever
with
I.
Think
it'll
be
in
preview.
3
we're
gonna
have
the
ability
for
you
to
actually
secure
your
API
endpoints
in
the
box.
We've
got
support
for
HTTP.
That's
been
a
long
request.
Health
checks,
Glenn
Condren,
is
gonna.
Do
some
demos
later
in
nakhon
around
this?
A
This
is
the
ability,
if
you're,
building
micro
services,
to
have
checks
in
your
apps
or
in
your
micro
service
work
to
actually
report
whether
it's
healthy
or
not,
especially
for
running
in
a
container
infrastructure.
That's
really
important.
I've
got
a
signal,
our
Java
client.
So
if
you
want
to
use
signal,
art
from
Java
I've
got
support
for
that.
So
that's
some
of
the
major
features:
let's
do
a
quick
demo
of
dotnet
core
2.1.
A
So
what
I've
got
here
for
that
is
there's
a
demo.
I
showed
it
build
where
we
were
showing
how
you
actually
can
do
Diagnostics
on
AP
eyes,
and
so
let
me
do
that
here.
So,
as
we
think
about
microservices
things
that
we
think
about
in
the
team
is
we?
How
do
we
make?
Api
is
better
one
of
those
things
we
want
to
do.
A
This
is
an
API
app,
and
so,
if
I
just
run
it
in
Visual
Studio,
you
get
this
great
experience
of
404
because
there's
no
there's
no
web
in
there,
and
so
we
really
want
to
fix
this
debugger
experience
that
we
have
so
we
actually
have
a
global
tool
that
will
ship
at
some
point
in
the
Tootoo
wave
and
I'm
gonna
switch
my
browser
to
be
that
global
tool.
That's
a
you
know
as
I've
saying
before,
net
2.0
brought
these
global
tools,
and
now
you
can
actually
we're
using
them
ourselves.
A
So
now,
when
I
run
this
application
and
let's
go
look
at
the
app
real,
quick
I've
got
a
controller
here
with
a
bunch
of
people
in
it.
These
people
are
obviously
ranked
in
order
me
Hanselman
and
Guthrie,
and
it
just
returns
returns
people.
How
would
I
test
this
API?
Well
now
that
I've
changed
my
browser
to
the
repple.
A
Here
we
are
in
a
command
prompt
and
I
can
just
do
an
LS
and
that's
going
to
show
me
the
the
controllers
I.
Have
you
can
see
people
and
values
if
I
want
to
get
the
people?
I
can
just
say,
get
people,
and-
and
if
you
look
here
and
makes
that
request,
you
can
see
it
brings,
you
know
hunter
handsome
and
Guthrie.
I
can
do
things
like
CD
into
people
and
then
I
could
just
do
a
get.
A
So
we
let
you
move
around
I
like
you
like
you,
like
you,
might
want
to
great
for
testing
you
I,
our
API
is
I.
Can
I
can
make
changes?
Just
come
back
here?
Rerun
those
api's,
maybe
you
like
UI
I,
can
jump
right
in
here.
Go
into
the
UI
to
add
another
person
here,
just
type
in
dotnet,
Kampf
I
can
basically
say:
try
it
out.
A
A
A
A
So,
let's,
let's
briefly
recap:
what
happened
to
build
I
talked
about
so
adding
support
for
wind
forms
in
WPF,
the
dotnet
core.
So
for
the
first
time
ever,
you
can
build
desktop
applications
on
dotnet
core.
We
support
a
bunch
of
the
the
other
features
that
Windows
talked
about
zamel
islands.
This
allows
your
apps
to
host
any
of
the
newer
controls
of
the
uwp
controls
in
your
wind
former
WPF
apps.
We
talked
about
zamel
controls.
This
is
taking
some
of
the
most
common
uwp
controls
and
rapid,
go
up
into
wind
form
and
WPF
controls.
A
You
can
just
drag
in.
So
if
you
want
a
a
modern
browser
or
modern
media
player
in
high
DPI
fixes,
we've
talked
about
adding
support
for
all
the
windows,
10
api's
into
tonic
or
three
and
finally,
one
of
the
bigger
things
we
talked
about.
That
I'm
really
excited
about
is
being
able
to
do
what
we
call
the
app
bundler.
This
is
build
a
standalone,
dotnet
executable
that
doesn't
require
anything
on
the
machine
at
all,
simple
self-contained
XE.
They
can
run
your
applications
so
really
cool
feature.
A
lot
of
people
ask
why.
Why
do
you?
A
Why
do
you?
Why
did
you
move
these
old
frameworks
on
to.net
core?
First
off
they're
awesome
frameworks?
The
big
thing
is
you
get
all
the
dotnet
core
benefits
side
by
side?
You
can
run
multiple
versions
and
WinForms
of
WPF
on
the
machine
and
it
won't.
They
won't
break
your
applications.
If
you
install
a
new
version
and
wind
forms,
it
won't
break
any
of
the
other
applications
that
use
using
wind
forms.
You
can
have
a
machine
global
or
an
app
local
version
of
those
frameworks.
A
If
you
want
to
copy
wind
forms
into
your
app
it'll
use
the
one
in
your
app.
If
you
want
to
use
a
global
one,
you
can
use
a
global
one.
You
get
some
of
the
core
runtime
and
API
improvements.
This
is
because
dotnet
core
is
side
by
side.
We
can
make
API
fixes
that
we
couldn't
make
and
dotnet
framework,
and
so
you
get
those
and
you
get
our
really
cool
new
version
of
CS
proj
that
you
can
edit
by
hand.
So
you
get
a
bunch
of
these
features.
A
Now,
let's
talk
about
what's
happened
since
build
wind
forms
is
now
available
in
our
nightly
builds
I,
don't
recommend
running
our
nightly
pills,
but
if
you
go
to
get
ComNet
cor
SDK
you
can
download
the
latest
SDK
from
there,
and
once
you
do,
you
can
actually
just
type
dotnet
new
WinForms
Visual
Studio,
the
new,
the
new
latest
versions
of
Visual
Studio.
Now
support
building
and
debugging.
These
winform
desktop
applications
directly
in
the
IDE.
A
We
don't
have
support
for
the
designers,
yet
that'll
be
coming
soon,
but
this
is
the
next
step
and
then
finally,
we
plan
to
publish
a
preview,
a
public
preview
later
this
year
in
non
nightly
builds.
So
you
can
start
trying
to
move
your
applications
to
dotnet
core
for
the
desktop,
and
so
let's
do
a
quick
demo
of
that.
A
A
A
A
A
So
I've
got
a
WinForms
dotnet
core
project.
My
debugger
works
I
get
full
intellisense
in
the
project,
so
we're
making
a
lot
of
progress
in
this
and
if,
as
I
said,
if
you
want
it
is
available
in
the
nightly
builds,
you
can
just
run
run
over
here
and
install
the
three
O
installer
from
the
github
page
and
try
this
yourself
if
you
want,
but
full
winform
support,
while
we're
sitting
here
talking
about
wind
forms,
I
want
to
I
want
to
show
one
more
thing
about
wind
forms.
At
Build,
I
showed
that
we
had.
A
In
tynacorp,
so
let's
look
at
that
real
quick!
This
is
the
sample
that
I
ran
at
the
build
conference.
At
this
point,
when
we
built
this,
you
kind
of
had
to
hand
build
projects,
you
didn't
have
that
supported.
It
showed
before
you
could
dotnet
knew
and
all
that
kind
of
stuff,
but
I
just
want
to
want
to
reshow
this,
to
highlights
one
of
the
things
that
was
really
cool
about
that
demo,
and
this
is
a
simple
app
that
we
ran.
A
You
and
run
that
again,
282
milliseconds
I'll
bring
these
together,
so
you
can
see
and
there's
the
the
big
thing
here
is.
The
core
version
of
this
ran
about
three
times
faster,
two
to
three
times
faster
than
the
the.net
framework
version
of
this,
and
this
is
but
it's
because
of
as
I
said
before,
we've
had
it.
We've
had
time
to
go
through
and
take
some
of
the
api's
and
improve
them
and
with
dotnet
core,
because
it's
completely
side
by
side
can
we
can.
We
can
not
worry
about
compatibility
the
same
way.
A
We
have
to
do
with
dotnet
framework.
We've
done
in
the
framework,
we're
afraid
to
touch
those
api
is
because
it's
installed
on
billions
and
machines
and
we
can't
break
anybody's
applications
with
dotnet
core.
The
customer
makes
the
choice.
The
developer
makes
the
choice
which
version
about
nick
or
they
want
to
use
and
windows,
updates
and
updates.
The
machine
won't
break
those
applications,
but
you
can
see
we
made
a
bunch
of
progress
since
build.
I
can
now
build
these
things
from
the
command
line.
A
I
can
open
edit
debug
inside
a
visual
studio,
and
you
see
that
I
get
a
big
performance
boost
in
these
applications,
because
they're
running
on
core,
as
I
said
before,
we
hope
to
have
a
public
preview
later
this
year,
where
you
can
try
these
bits
without
running
a
nightly
and
hopefully
we'll
get
designer
support
in
that
time
frame
as
well.
I,
don't
know,
but
we're
working
on
it
and
that's
an
update
on
dotnet
core
three.
A
So
let's
talk
about
blazer
blazer
is
a
cool
project
that
we
started
showing
it
seems
like
about
a
year
ago
and
it's
the
version
we
showed
a
year
ago
was
we
called
it
an
experimental
project
and
what
it
does
is
it
allows
you
to
build
client-side
web
UI
and
dotnet.
So
you
know
we
have
lots
of
customers
that
might
feel
more
familiar
with
c-sharp
than
they
are
with
JavaScript.
They
might
not
want
to
to
learn
the
JavaScript
framework
of
the
year.
A
Angular
react
view
and
they
want
to
take
advantage
of
the
stability
and
consistency
of
net.
So
this
what
Blazer
was
was
built
about.
Blazer
used
a
technology
called
web
assembly
to
basically
load
dotnet
into
the
the
browser,
so
we
can
actually
run
a
version.
Of.Net
live
in
the
browser,
and
so
you
have
dotnet
running
both
in
the
browser
on
the
client
and
on
the
server
and
there's
some
cool
benefits
you
because
you're
running
net
you're
gonna
get
native
performance.
A
What
we've
done
is,
as
you
show,
Blazer
and
I'm
gonna
do
a
demo
in
a
second.
The
most
popular
part
about
blazer
is
the
programming
model
is
just
amazing:
I
can
be
in
some
HTML
and
I
can
just
call
c-sharp
I
can
use
the
skills
that
I
already
have,
so
we
we've
decided
that
we're
going
to
take
that
programming
model
and
we're
gonna
move
it
into
asp
net
core
3,
but
it's
a
little
different
than
the
experimental
version
in
that
the
experiment.
Experimental
version
we're
running
net
core
in
the
browser.
A
The
the
version
that
we're
gonna
first
start
with
that
will
be
in
a
spec
for
three
is
going
to
run
that
same
code
on
the
server.
The
programming
model
is
exactly
the
same,
so
you
have
to
change
any
code.
I'll
actually
build
a
blazer
up
in
a
second
and
it
doesn't
matter
whether
it
runs
on
the
client
to
the
server
you
get.
This
awesome
programming
model,
and
so
the
cool
thing
is
as
we
do.
A
This
you're
gonna
be
able
to
take
advantage
of
this
and
then
in
the
future,
when
we
have
a
version
of.net
that
we're
really
happy
with
running
in
webassembly
you'll
be
able
to
just
change
a
few
lines
of
code
and
your
app
will
then
start
running
with
that
net
in
the
client
and
you'll
give
them
more
performance.
So
super
happy
to
announce
this,
and
let's
do
a
quick
demo
of
this,
because
this
is
cool
tech.
A
About
what
what
what's
a
great
way
to
show
this
tech,
and
so
I-
wanted
to
take
a
common
application
programming
thing
that
somebody
might
do
today
with
some
JavaScript
and
show
you
how
you
would
rewrite
that
in
c-sharp
and
get
the
same
benefit.
So
this
is
a
web
page,
and
you
can
see
here
in
my
web
page
I
have
an
image
of
a
bot.
I've
got
a
button
here
and
on
the
on
click.
It
calls
change
image
and
let's
go
look
at
change
image
change.
Image
is
JavaScript,
that's
right
here.
A
It
goes
and
grabs
that
bot
element,
so
it
goes
and
finds
the
the
the
bot
here
the
image
tag,
and
it
then
goes
and
grabs
the
source
attribute
for
that,
and
it
says
hey
if
that's
got
a
1
in
it,
replace
it
with
a
2
if
it's
got
a
2
in
it,
replace
it
with
a
1,
and
so
let's
run
this
and
see
what
this
does
oops,
let
my
API
client
they're
running.
So
let's
turn
this
off
back
to
my
browser.
A
A
What
we'll
do
is
we'll
go
back
to
that
index,
and
first
thing
I
want
to
do
is
need
to
write
some
c-sharp
in
this
web
page,
so
I'll
create
a
functions
block
and
inside
of
this
block,
I
can
write
whatever
c-sharp
that
I
want
to
write
so
first
off
we
need
to.
We
need
to.
We
need
a
URL,
so
let's
do
string
image
URL
equals
and
let's
just
grab
this
image.
We
already
have
here.
That's
great.
A
A
If
image
URL
contains
a
1
and
what
I
would
do
is
I
would
set
image,
URL
equals
image,
URL,
dot,
replace
and
I'll,
replace
the
one
with
2
and
else
image
URL
equals
image,
URL,
not
replace
and
we'll
just
replace
the
two
with
a
1,
so
I'm,
basically
every
time
the
URL.
We
call
this
method.
We
look
to
see
what
URL
we
have
if
it's
got
a
1
in,
we
change
it
to
a
2.
A
A
Now
what
I
would
do
is
come
up
here
and
and
where
I
have
this,
this
is
here
I'd
erase
this
and
we'll
just
say
at
image.
Url
typical
razor,
see,
sharp
syntax
and
where
it
gets
kind
of
cool
here
is
on
this.
On
click,
where
I'm
calling
this
JavaScript
function,
I
will
now
add
an
@
sign
here
to
call
the
c-sharp
function,
remove
those
two
and
now
I've,
actually
rewritten
the
same
app
that
would
normally
use
JavaScript
to
change
the
two
images
to
now
use
Blazer
to
change
those
two
images.
So
let's
run
this
again.
C
A
A
You
can
see
it
doing
its
stuff
and
now
that
same
app
that
I
just
showed
before
using
a
JavaScript
function.
Now
does
the
exact
same
thing
all
written
in
C,
sharp,
so
I
think
this
programming
model
is
amazing
if
your
web
developer
building
razor
based
asp
net
core
application
today,
you're
gonna
love
this.
A
A
A
great
example
this
one
of
the
demos
we
showed
it
build
is
our
github
repo
has
tons
of
issues
filed
in
it
and
we
look
to
see
if
we
can
go
build
a
bot
that
would
actually
go
and
and
take
those
in
those
those
issues
and
automatically
classify
them
to
the
right
areas,
and
in
our
case
we
had
plenty
of
data.
So
we
took
all
the
data
that
our
team
has
done
by
manually.
Moving
those
things
over
the
years
ran
it
through
something.
A
So
we
took
that
data
and
we
then
push
it
into
ml
net
to
build
a
model,
and
then
we
ran
that
model
and
so
I
want
to
announce.
Today
we
have
ml
net
0.5.
You
can
get
it
right
here.
It's
the
latest
preview
of
those
ml
dotnet
bits
that
we
shipped
it
build
continuing
to
improve
this,
make
it
better
make
it
easier
for
you
to
use.
A
Please
go
out
and
try
this
today.
You
can
see
that
that
we've
shipped
for
previews
there's
a
whole
bunch
of
areas
that
f-sharp
support.
You
can
see
here.
We've
got
a
bunch
of
samples,
including
that
sample
that
get
a
placer
fire
is
now
up
there
and
we're
continuing
to
embrace
this
technology.
A
big
thing
about
ml
dotnet
that
I'd
like
to
tell
customers
as
well
is
this
tech
is
built
on
tried
and
true
to
AI
that
we
use
inside
of
Microsoft.
A
So
if
you're,
using
Office
or
Bing
you're
likely
using
some
of
the
same
tech
that
ml
dotnet
is
based
on,
and
so
tomorrow
we're
gonna
kick
off
with
a
session
on
machine
learning
and
artificial
intelligence,
I
think
with
akut
and
Caeser.
So
you
should
be
excited
about
that,
and
next
I
want
to
bring
in
Mads
to
come
talk
about
the
new
enhancements
we
have
coming
in
c-sharp.
A
C
B
C
Again
now
I
gave
away
my
little
unicorn
there.
So
essentially,
this
idea,
with
the
with
the
point
releases,
was
to
get
better
at
giving
you
value
right
away,
rather
than
bulk
everything
up
for
releases
that
are
further
between,
but
we
also
had
some
concrete
value
around
span
of
T
and
efficiency
at
the
low
level
that
we
wanted
to
get
in
quicker,
and
so
there
are
three
sort
of
loose
themes
and
these
point
releases.
C
That's
the
safe,
efficient
code,
which
underlies
some
of
the
improvements
we
got
on
Tekken
power,
for
instance,
and
then
there's
just
general
more
freedom,
allowing
you
to
do
more
things
that
were
forbidden
before
various
ways
of
abbreviating
things.
The
usual
like
little
juicy
features
and
we're
going
to
talk
a
little
bit
more
about
the
safe
efficient
code
in
a
minute.
But
of
course
we
also
want
to
talk
about
G
sharp
eight.
The
main
theme
here
is
it's
going
to
be
magical
I
will.
If
the
demo
gods
prevail.
C
I
will
show
a
little
of
that
as
well
in
in
this
in
this
keynote.
So
but
let's
start
out
with
the
with
the
dotnet,
with
the
C
sharp
seven
one
72
and
73,
and
this
theme
about
safe
and
efficient.
So
if
you're
writing
sort
of
low-level
coder
you're
trying
to
get
performance,
you
essentially
have
to
narrate
navigate
between
the
Scylla
and
Charybdis.
C
That
is
garbage
collection
can
be.
You
know,
provide
an
overhead
and
unpredictability
of
your
performance
at
the
low
level.
But
if
you
try
to
avoid
garbage
collection-
and
you
start
using
struts
and
things
that
aren't
allocated,
then
you
run
the
risk
of
copying
too
much.
And
so
essentially
we
ratcheted
up
our
toolbox
for
dealing
with
navigating
these
waters
and
so
Odysseus.
C
Here
it's
going
to
use
span
of
T
to
navigate
between
the
between
the
two
dangers
that
lurk
on
either
side
of
the
strait
here,
and
there
are
several
language
features
that
are
there
to
enhance
the
span
of
T
experience
and
help
out
with
these
with
how
you
can
write,
struck
based
and
array
based
code
without
getting
too
much
copying.
So,
let's
go
and
have
a
look
at
span
of
T.
C
The
way
that
you
might
want
so
here
I
have
a
simple
program
that
creates
an
array
initializes
it
and
writes
it
out
and
to
show
what
span
is
about.
Let's
just
quickly
look
at
array,
and
we
see
that
there
are
some
new
extension
methods
here
related
to
the
to
the
span
features
in
them
dotnet
framework.
So
this
s
span,
for
instance
here
so
I
can
take
the
array
and
somehow
get
it
as
a
span.
So
it
should
not
like
our
percent
of
you,
sorry
guys.
C
A
C
In
the
meantime,
I
can
talk
a
little
bit
about
span
of
tea
without
visuals,
so
the
idea
is
that
you
can
essentially
a
span
is
essentially
a
view
onto
an
array
or
a
contiguous
expanse
of
memory,
and
so
when
you
have
a
span,
it's
just
like
an
array,
but
it
lets
you
view
the
the
bits
of
maybe
some
other
array
or
well.
Here
we
go
again
of
other
memory
that
may
be
allocated
in
other
ways:
okay,
so
there
we
are
so
I,
don't
know
how
much
you
caught
here,
but
I
haven't.
C
Let's
just
start
from
scratch.
With
the
demo.
I
have
an
array,
I'm
initializing
it
I'm
writing
out
the
elements
now
I
want
to
do
some
fun
with
spans.
So
let's
take
the
array
and
look
at
the
new
extension
methods
around
there.
I
can
say
s
span.
What
I
get
back
is
a
new
type
that
is
called
span
of
T
in
this
case,
I
have
a
span
of
int.
So
let's
write
that
out
just
so.
C
It's
clear,
though
I'm
normally
a
VAR
lover
so
now
have
span
here
what
you
can
do
it
with
the
span
now
over.
The
array
is
well
obviously,
if
I
initialize
the
array,
let's
have
a
look
at
what
the
in
the
span,
our
let's
try
to
run
the
program,
see
what
the
demigods
say
to
that.
Oh
there
we
go
so
you
can
see
that,
even
though
I,
even
though
I
created
the
array,
the
span
from
the
array
before
I
initialize
the
array,
the
modifications
to
the
array
down
here
are
visible
through
the
span.
C
So
it's
really
like
a
window
onto
the
same
memory,
and
why
is
it
interesting
to
see
the
same
memory?
Well,
maybe
I
don't
want
to
see
all
of
it.
Maybe
I
want
to
just,
for
instance,
take
a
slice
of
it
and
rather
than
copying
all
the
elements
that
are
in
a
given
slice,
let's
say
from
element
3
and
5
elements,
maybe,
instead
of
doing
that,
I
want
to
just
get
a
window
onto
it
and
not
actually
modify
or
create
a
new
array
which
is
an
expensive
thing.
C
If
I
go
into
the
into
the
slice
and
say
assign
to
the
second
element,
let's
assign
100
in
there
and
we
write
out
the
elements
of
the
original
span
say
then
you
can
see
that
the
fifth
or
whatever
is
a
sixth
element
of
the
span
has
been
modified
as
well,
because
we're
again
we're
still
modifying
the
same
memory.
So
that's
a
very
useful
feature.
C
There
are.
There
may
be
concerns
about
this
whole.
Oh
I
can
modify
memory
through
other
objects.
If
you
don't
like
people
modifying
it,
but
you
just
want
them
watching
it
long.
You
can
use
a
read-only
span,
which
is
just
a
version
of
the
type
that
does
not
allow
assignment.
So
you
can
see
my
modifications
through
the
slice
here
is
now
disallowed.
So
I
can
pass
these
out
to
others.
They
can
observe
my
changes,
but
they
can't
affect
changes
of
their
own.
So
that's
it
for
span.
C
Objecting
so
and
talk
about
black
holes,
or
rather
you
know
the
scourge
that
has
been
writing
object
or
under
programming
for
many
years,
which
is
null
reference
exceptions.
You
can
probably
come
up
with
others,
but
I
think
this
is
the
big
one
and
we
decided
in
C
sharp
8
as
part
of
the
magic
unicorn
thing
to
help
you
avoid
null
reference
exceptions.
So
this
is
where
do?
C
Let's?
Actually,
let's
skip
the
slides
and
see
if
the
demo
works?
This
is
where
things
currently
they
came
together
last
minute
here.
So
we'll
have
a
look,
we'll
have
a
look
and
see
if
this
this
works
out.
So
first
of
all,
I
have
a
program
here.
I
have
a
good
friend
Miguel
de
Icaza,
who
has
no
middle
name.
He
assures
me
and
now
I'm
trying
to
get
the
length
of
his
middle
name
by
calling
the
gate
length
of
middle
name
here
and
simply
returning
the
length
of
his
middle
name.
C
Well,
this
is
looks
like
innocuous
code,
but
it's
going
to
throw
a
null
reference
exception
in
because
I'm
I'm
getting
his
middling,
he
doesn't
have
a
middle
name,
so
it's
probably
gonna
be
null
when
I
access
the
length
off
of
it.
That's
going
to
give
us
a
null
reference
exception.
Well,
who's
really
to
blame.
Here.
C
Let's
go
look
at
the
person
class
that
that
we
created
here.
We
can
see
that
we
have
first
name
and
middle
name
and
a
last
name,
but
in
the
constructor
that
I
use
for
Miguel
I'm
only
initializing
the
first
and
the
last
name.
If
only
I
had
a
feature
that
could
tell
me
whoa,
they
either
tell
me
well
you're,
not
initializing
the
middle
name.
C
It
could
be
null
or
a
feature
that
I
could
tell
well
I
want
it
to
be
null
well,
that's
what
the
knowable
feature
is
about
and
the
way
I
turn
it
on
is
to
use
an
attribute
called
none,
no
types,
and
when
I
put
that
on
the
module,
you
can
see
that
I
get
a
warning
on
the
on
the
person
class.
Here
wanting
saying
you
did
not
that's
sorry,
let's
see
if
we
can
hover
over
the
warning.
A
C
It's
saying
you
did
not
initialize
a
nun,
no,
a
nun,
no
field,
so
I
can
either
you
know,
go
initialize,
it
middle
name
equals
null
I
want
it
to
be
null
and
then
that
warning
goes
away,
but
I
get
another
warning
saying
you're
putting
null
into
middle
name.
So,
what's
going
on
here,
why
can't
I
put
null
into
a
reference
type?
Well
I,
can't
because,
with
the
new
feature
turned
on
reference,
types
are
no
longer
able
to
be
null
with
that
warning.
You
get
a
warning
whenever
you
put
it
all
in
there.
C
If
you
want
to
have
a
null,
you
have
to
explicitly
ask
for
it.
So
I
can
go
here
and
explicitly
ask
for
middle
name
to
be
nullable.
I
put
a
question
mark
on
a
string
just
like
you
can
today
on
an
INT
or
whatever
I'm
saying
I
want
a
nullable
string
here
might
be.
No,
you
see,
the
warning
goes
away.
Everything's
hunky-dory
with
my
person
class.
C
But
now,
when
I
go
back
to
my
program
and
I
have
rightly
specified
that
middle
names
might
be
null,
then
I
get
a
warning
here,
saying:
hey,
you
may
be
the
referencing
and
all,
and
so
now
the
feature
is
helping
me
push
around.
Where
can
there
be
null
swear?
Can't
there
be
a
nulls
and
making
me
correct
my
code?
So
what?
What
are
ways
I
could
correct
this?
C
Well,
maybe
you
know
I,
maybe
I
have
an
if
statement
just
think
about
how
you
were
how
you
would
solve
this
bug,
if
you,
if
you
got
it
from
like,
say
a
bug
report
from
a
customer
where
you
had
to
no
reference
exception
and
in
production,
so
we
can
say
if
Peter
middle
name
is
null.
This
is
how
you
should
always
check
for
nulls.
Now
that
you
have
pattern
matching,
because
it
does
not
unlike
using
double
equals,
it
does
not
use
overloaded
equals
operators,
it
always
checked.
C
Just
checks
for
null
speed
on
middle
name
is
no
well,
then,
let's
return
zero,
for
instance.
Now
look
at
what
happens
with
the
warning.
The
warning
down
here
goes
away
because
the
compiler
does
a
flow
analysis,
and
it
knows
that
by
the
time
it
gets
to
this
line
code,
peanut
middle
name
is
no
longer
null,
so
it
it's
kind
of
like
definite
assignment
that
it
tracks
the
possible
values
of
variables
throughout
the
body
of
the
method
and
make
sure
that
you
that,
when
you
dereference
things
null
is
not
one
of
the
possible
features.
C
B
Miguel,
thank
you
Matz.
Well,
this
is
one
of
my
favorite
features
in
c-sharp.
It's
a
it's
a
it's
a
gift
of
the
gods,
in
this
case
really
a
gift
of
mads
uh-huh,
so
anyways
well,
Madden
the
team,
of
course,
so
I
yeah,
so
I'm
gonna
talk
today
about
mobile
development
and
what
we're
doing
there
for
you,
while
we're
here
to
give
you
so
here's
a
little
of
an
agenda.
I
want
to
talk
a
little
bit
about
our
community.
What
we're
doing
to
improve
our
community.
B
Our
open
source
contributions
will
talk
about
the
Android
platform,
the
Apple
platforms,
some
reforms
and
a
couple
of
interesting
things
that
are
happening
coming
up
so
the
so
first
off.
We
really
I
really
want
to
thank
everybody
that
has
been
that
has
been
engaging
with
us
in
our
open
source
effort.
As
you
can
see,
it
has
been
an
incredible
year
for
open
source
contributions
to
the
project.
B
We
only
open-source
these
three
pieces,
the
Android
support,
iOS
informed
support
when
Microsoft
acquired
xamarin
two
years
ago.
So
so
these
numbers
actually
reflect
that
all
time
is
just
the
last
two
years
when
we
open
sourced.
But
as
you
can
see,
it's
a
you
know,
there's
a
tremendous
amount
of
energy
and
people
con
trading
to
the
effort
and
in
Manos
case
you
have
to
give
you
mind
that
this
only
counts
changes
to
mano.
But
we
are
now
pulling
about
about
35
percent
of
the
code.
Now
it
comes
directly
from
effects
and
core
CLR.
B
So
so
it's
even
a
larger
effort.
Now
up
until
this
point,
you
have
to
realize
that
when
you
work
with
these
systems,
you
know
we
came
from.
You
know
we
came
from
from
the
UNIX
universe
and
we're
very
comfortable
using
Emacs
and
VI
make
files
and
every
you
know
thing
that
we
do
in
the
UNIX
world,
but
it
wasn't
particularly
easy
for
newcomers
to
come
in
it's
it's
an
organic
system,
something
that
we've
grown
over
the
years
and
and
it's
easy,
if
you
were
part
of
the
community,
but
if
you're
a
newcomer
it
was
difficult.
B
So
over
the
years
we've
tried
different
things.
In
fact,
this
effort
and
an
effort
to
improve
the
way
and
the
easiness
of
building
mono
started.
Many
years
ago,
my
friend
Jonathan
chambers,
who
now
works
at
unity,
I
found
the
first
commit
in
2007.
He
contributed
this
change
that
allowed
wanted
to
be
built
with
Visual
Studio,
as
opposed
to
this
Linux
tool
chain
that
that
was
ported
to
Windows,
that
had
an
emulation
layer
for
Windows
and
so
on.
B
It's
a
it
generates
a
a
native,
a
native
Exodus
x86,
64
binary,
and
then
the
second
line
builds
all
of
the
class
libraries.
So
everything
that
you
need,
ms
core
lip
system,
system,
XML
and
so
on.
You
see
a
little
flag.
There
called
net
4x,
and
that
means
that
in
this
particular
scenario
you
are
requesting
to
build
the
dotnet
for
point
X
compatible
set
of
api's
there's
a
lot
more
there's.
The
Android
API
is
a
monitor,
JP,
isin
and
so
on.
B
But
what
is
really
interesting
about
this
is
that
every
assembly,
now
that
is
part
of
mono,
can
be
built.
It
comes
with
at
CS
proj,
which
means
that
you
can
open
Visual
Studio,
you
can
build
it,
we
do
the
dependency
tracking,
so
so
what
is
really
nice
about?
That
is.
That
is
that
you
don't
need
to
worry
about
about
the
chain
of
compilation
right.
We
will
get
all
the
dependencies
for
you,
and
these
are
just
some
of
the
other
targets
that
you
can
use,
and
you
know
we
support
everything
under
the
earth
now.
B
We
really
hope
that
this
is
gonna,
make
it
a
lot
easier
for
people
to
come
in
and
contribute
fixes
and
improvements
in
tuning
to
the
all
the
mobile
as
the
case,
so
just
a
refresher
of
what
we're
doing
right.
We
are
big
into
the
native
into
delivering
a
native
experience
for
users,
so
that
means
native
user
interfaces.
B
So
when
you
create
a
bottom,
we
want
again
a
native
button
so
that
it
behaves
the
way
that
user
expects
it
has
a
proper
animations,
proper
colors,
proper,
behavior,
starches
and
so
on,
integrates
with
accessibility
and
so
on
and
every
other
feature
in
the
US.
We
want
to
give
you
the
all
the
API
that
the
platform
offers
so
on
Android
everything
that
Google
offers
on
the
Apple
platforms,
everything
there
Apple
offers
so
from
dotnet.
B
You
can
use
everything
in
there
and,
of
course
we
want
to
give
you
the
best
performance
possible
and
the
last
thing
that
we
do
is
we
try
very
hard.
We
we
work
very
hard.
We
don't
write.
We
work
very
hard
to
deliver
to
you
same-day
support
for
these
platforms.
This
past
summer,
we
just
shipped
or
Android
support
for
Android
Pi.
So
so
we
have
a
blog
post.
We
have
samples,
we
had
everything
to
get.
You
started
with
Android
Pi,
and-
and
you
know
you
can
always
count
on
that.
B
In
fact,
today's
a
special
day
and
we'll
get
to
that
in
a
second
now
I'd
built
this
year,
I
announced
the
support
for
accelerated
Android
emulation
on
Windows
that
work
with
hyper-v
right.
So
some
of
you
had
to
choose
between
hexam
and
hyper-v,
and
this
year
we
work
with
Google
and
we
got
the
support
for
hyper-v
integrated
into
the
Google
emulator
I
close
by
I
close
my
session
with
this
beautiful
artwork.
That
said,
you
know,
if
you
get
the
windows,
API
update,
you're
gonna
be
super
happy.
B
Today
is
just
the
regular
windows
update
that
you
can
use,
and
you
should
be
happy
and
I
say
you
should,
because,
because
Spector
and
in
some
of
the
mitigations
that
were
rolled
out
for
Spectre
slow
down
slow
down
the
Android
emulation
now,
the
good
news
is
that
if
you're
trying
some
of
the
Alpha,
you
know
the
previews
of
Windows.
This
is
addressed
and,
and
we're
gonna
have
this.
You
know
for
those
of
you
affected
by
the
specter
things.
We're
gonna
address
that
later
this
year.
B
Now
so
now
we
wanted
to
not
only
improve
the
Android
experience
right,
the
the
emulator
experience,
but
we
wanted
to
improve
your
life
when
you're
building
applications
and
and
we've
essentially
looked
at
the
problem
from
two
perspective.
First,
how
can
we
improve
the
the
build
times
for
you
when
you're
building
a
new
project,
then
you
have
to
rebuild
everything
from
scratch.
B
You
do
I
get
check
out,
then
you
get
a
build,
a
whole
thing,
so
we've
spent
a
lot
of
time,
optimizing
every
step
in
the
pipeline
and
we're
looking
at
every
step
in
the
pipeline
of
how
we
can
fix
this.
Some
of
these
are
fixes
some
of
those
are
optimizations
some
of
their
profiling.
Some
of
those
are
being
smarter
about
the
things
that
we
do
and
some
of
those
are
upgrading
some
of
the
tooling
capabilities.
Some
of
them
are
skipping
steps.
B
B
Now
just
so,
you
get
a
feeling
for
how
this
works.
This
is
not
even
a
complete
picture,
but
it
gives
you
an
idea
when
you
build
an
Android
application,
you
you
you
need
to
package
at
the
end,
a
zip
file
that
contains
everything
here
that
is
blue
right.
All
the
blue
balls
there.
Those
need
to
be
shipped
into
the
into
the
apk.
Now
when
you
and
your
sources
write
essentially
the
user
c-sharp
code
or
there
are
your
zamel
sources,
they
need
to
be
compiled
into
your
c-sharp
executable.
Then
we
need
to
inspect
it.
B
We
need
to
extract
some
Java
Java
data.
Then
we
need
to
compile
that
data.
Then
we
need
to
compile
it
to
the
native
Android
format
and
so
on.
So
this
is
a
series
of
step
that
some
of
them
are
serialized
and
cannot
be
paralyzed
and-
and
they
can
take
a
long
time
so
so
we've
been
tuning
this
pipeline
right.
So
if
you
make
a
change
here,
we
can
have
run
everything
if
you
have
native
libraries,
Java
native
libraries.
Well,
we
gotta
extract
those
things.
B
If
you
have,
if
you
have
native
C
libraries
well,
we
also
gotta
extract
those
things
and
we
gotta
get
them
out.
So
what
is
that
thing
doing
at
the
bottom
of
the
screen?
All
right?
So
we
need
to
get
all
of
those
pieces
in
place
and
we've
been
tuning
this.
So
let
me
share
with
you
some
of
the
improvements
that
we're
doing
right
now.
So
this
is
we're
comparing
the
current
stable
release
against
the
current
master
release
of
a
fairly
large
application.
B
This
is
called
the
smart
hotel,
360
app
smart
hotel
360
is
a
sample
app
that
we
showed
at
Connect
last
year
and
it's
a
relatively
large
application.
Twenty
five
thousand
lines
of
c-sharp-
that's
really
not
the
large
part,
is,
is
for
the
sake
of
expedience
and
getting
this
quickly
and
having
a
lot
of
capabilities.
These
application
actually
consumes
99
NuGet
packages,
and
this
has
everything.
B
Under
the
Sun
dodd
net
standard
libraries
support
libraries
from
Google
Google,
Play
services,
other
services
skia
for
for
rendering
images
native
code,
everything
really
and
32
sam'l
screens,
and
we
cut
down
the
build
times
from
2
minutes
and
15
seconds
to
57
seconds,
so
I'm
very
excited
about
what
we're
doing
in
terms
of
improving
the
build
times
and
all
of
these
happens
at
the
SDK
level.
So
there's
really
no
changes
necessary
on
the
visual
studio,
all
happening
at
the
MS
build
level.
So
with
all
this,
all
of
these
improvements
will
continue
to
trickle
out
now.
B
Oh
okay,
if
you're
using
a
dozen
it's
time
for
your
share
business
logic,
you
don't
need
to
run
this
process
the
whole
time
right.
You
don't
need
to
run
the
whole
thing
and
repackage
everything,
so
we've
added
a
mode
called
fast
development
mode,
and
now
we
have
a
prototype,
a
proof
of
concept
and
and
this
proof
of
concept
that
today
exists
in
a
separate
form,
we're
gonna
we're
gonna,
integrate
all
of
that
work
directly
into
our
build
system,
and
let
me
share
with
you
what
it
is.
B
The
proof
of
contest
is
an
Android
light
and
it
gives
you
the
ability
of
rebuilding
your
forms,
application
and
deploy
and
run
right.
So
you
make
a
change
at
five
and
it's
showing
a
device
three
seconds.
It's
two
point:
five,
you
know
2.9
seconds,
but
I
want
it
to
be
a
you
know:
I
wanted
to
run
it
up.
B
So
it's
about
three
seconds
to
from
a
change
to
visualizing
it
directly
on
your
device,
so
I,
where
I'm
looking
for
delivering
all
of
these
to
you
folks
later
this
year
now,
as
you
know,
today
is
an
exciting
day.
Ios
12
is
very
likely
going
to
be
announced.
We
suspect
that
will
be
coming
soon.
So
good
news,
we
have
your
iOS
12
support,
ready,
ready
in
store
and
when
I
say
I
use
12.
B
You
know,
I
really
mean
the
entire
set
of
Apple
updates
that
are
coming
today,
which
we
suspect
this
iOS
TV
OS
Mac
OS
and
watch
OS.
So
that's
what
we
internally
call
it
Xcode
10,
because
it's
the
whole
platform,
but
most
people
think
of
this,
as
is
12,
so
we're
ready
for
you.
You
should
usually
go
and
download
our
packages
today
and
start
spicing
up
your
apps
if
you
haven't
started
yet
there's
a
couple
of
really
interesting
things.
So
probably
the
one
that
my
favorite
feature
in
my
opinion
is
a
support
for
shortcuts.
B
This
is
a
way
that
your
application
can
participate
in
in
scripting
in
the
system.
So
what
is
interesting
is
that
now
your
apps
can
essentially
describe
an
action
of
something
that
the
user
did
and
you
can
you
in
this
action.
You
need
to
provide
it
to
the
operating
system.
It's
called
you
donate
the
action,
the
intent
and
when
you
donate
this
thing,
this
becomes
searchable
in
Siri.
B
There,
then
on
also
air
Kid
2
is
coming
out.
We
have
some
good
samples
for
you
and,
and
what
is
very
nice
about
our
kid-
is
that
now
I
can
detect
physical
objects
and
remember
those
those
objects.
It
can
remember
spaces
and
you
can
have
a
shared
virtual
spaces.
That
is
also
very
interesting.
We
have
great
samples
for
you
to
try
out
or
IDE,
has
been
updated
to
support
these
new
capabilities.
A
orchid
also
supports
detection
of
existing
objects.
B
B
There's
a
new
networking
stack.
This
is
an
amazing
networking
stack
that
was
introduced
if
you're
trying
to
do
networking
today,
it's
incredibly
painful
because
you
have
to
know
too
much
about
how
the
mobile
world
works,
these
connections,
changing
networks,
changing
paths
and
so
on.
This
is
a
callback
based
system,
here's
a
little
bit
taste
of
what
it
looks
like,
but
it's
very
interesting
because
not
only
does
it
handle
connections,
it
also
handles
TLS
security
for
you,
it
handles
Bonjour
and-
and
you
also
get
state
transitions
right.
B
So
if
you're
kind
of
your
phone
drops,
if
there's
a
connection
change,
if
the
way
you
connect
the
new
network,
you'll
handle
it
there
there's
a
lot
more
to
try
an
iOS
12
today,
so
you
should
check
it
out
now.
Let
me
talk
about
perhaps
one
of
the
most
exciting
things
that
we've
been
working
in
the
past.
For
you,
it's
called
the
forms.
Shell,
the
xamarin
forms
is
that
right
once
run
anywhere
framework,
and
we
give
you
a
lot
of
tools.
B
We
give
you
every
control
that
you
can
imagine
layout
function
and
the
problem
sometimes
is
that
as
a
new
developer,
trying
to
create
an
app,
it
feels
like
opening
out
a
bag
of
Lego
and
with
no
instructions
right
and
now
you
get
a
build
a
universe.
So
it
is
not
unusual,
for
you
know
you
have
a
goal.
You
have
an
objective.
B
You
want
to
build
an
app
for
your
particular
problem
and
before
you
can
get
there,
you
need
to
figure
out
navigation
top
menus
nesting
how
to
handle
the
back
button,
how
to
do
searches,
deep
linking
there's
all
these
things
and
and
all
we've.
Given
you,
we
gave
you
the
pieces,
we
give
you
all
the
pieces,
but
we
didn't
really
give
you
any
guidance
or
how
to
stitch
these
things
up
and-
and
even
if
you
do
sometimes
people
make
mistakes,
it
becomes
bug
reports
and
things
that
you
need
to
fix
and
so
on
or
you
create.
B
So
you
end
up
creating
user
interfaces
that
look
like
this
right,
beautiful
you
wise
with
tall
lakes,
where
they
really
don't
belong.
There's
these
ideas
for,
for
you
eyes
that
make
no
sense.
Imagine
this
is
how
I
envisioned
my
first
email
program.
It
obviously
makes
no
sense,
I,
don't
know
what
there's
a
slighter
there
I,
don't
know
what
there's
an
arrow.
Maybe
they
maybe
it's
something
that
you
felt.
B
You
know
look
good
on
the
screen
or
you
saw
it
somewhere
or
an
emoji,
and
then
these
other
control
to
the
that
you
misuse
the
control
right
instead
of
having
Butlins.
You
use
this
thing
and
it's
like
in
books
and
trash,
it's
a
selector,
it's
not
a
button,
there's
no
action
and
then
at
some
point
in
a
dream.
You
had
this
dream
where
you
thought
you
know
whatever
we
call
if
you
could
control
the
number
of
lines
in
the
preview
and
you
make
it
12,
nothing
makes
any
sense.
B
Your
users
look
at
this,
and
and
and
actually
just
move
on.
You
go
back
to
something
a
lot
simpler,
like
you
know,
being
a
physics,
nuclear
researcher.
So
we
wanted
to
address
this
and
what
we
did
is
we
build.
This
thing
called
the
shell
and
the
shell.
It's
an
opinionated
type
that
sets
up
a
gives.
You
a
skeleton,
a
foundation
where
you
plug
in
the
pieces
of
your
application.
You
fill
in
the
content
that
we
take
care
of
the
layout,
then
of
everything
else.
We
give
you
a
consistent,
look
and
feel
you
can
style
it.
B
You
can
sell
it
either.
You
know
the
hard
way
with
zamel
or
you
can
style
it
with
CSS
and
we
take
care
of
the
rest,
but
we
also
take
care
of
the
blinking,
so
every
page
in
the
shell
has
a
URL
assigned
to
it
and
we
can
launch
the
application
directly
into
one
of
these
pages
so
by
building
all
of
these
functionality
in
there
we're
taking
a
lot
of
the
pain
away
from
you
and
and
we're
handling
it
their
selves.
B
We
also
handle
material
if
you
want
to
get
a
material
look
and
feel
an
Android
which
usually
involves
a
lot
of
moving
pieces
and
things
that
you
have
to
do
so
I'm
just
going
to
give
you
a
quick
taste
of
shell.
This
is
what
it
looks
like.
This
is
a
standard.
This
is
a
very
simple
application
where
we're
trying
to
emulate
which
shell,
the
Google
Play
Store.
So
you
can
see
here
that
the
different
elements
of
this
app
and
if
you
look
at
the
source
code,
it's
actually
trivial.
It's
very,
very
simple.
B
B
To
give
it
a
look,
consistent,
look
to
your
app,
we
have
the
same
thing
for
iOS,
so
this
is,
you
know,
oddly
it's
at
the
Android
Play
Store
running
on
iOS,
but
you
get
the
idea,
and
this
is
what
it
looks
like
on
zamel
right.
This
is
what
it
looks
like
on
zamo.
As
you
can
see,
you
have
a
new
top-level
container
shell,
and
then
you
have
to
fill
in
some
of
the
details.
B
You
can
see
some
pieces
there,
like
the
flyout
header,
that's
what
would
come
up
if
you
press
that
hamburger
button,
then
there,
then
you
have
your
content
for
the
top
for
the
bottom
menu
bar
and
the
items
that
go
inside
the
most
basic
app
that
you
can
build.
Is
this
one
right?
This
is
the
simplest
version
of
something
that
you
can
have.
It
has
just
one
homepage
and-
and
in
this
particular
example,
local
colon
homepage
is
actually
a
type
in
your
app
and
this
what's
being
rendered
inside.
B
If
you
want
to
add
tabs,
all
you
have
to
do
is
add
two
sections
right,
very
simple,
the
icon,
the
sections
and
and
what
you
wanted
them
to
be
called.
If
you
wanted
to
add
these
nested
tabs,
you
can
add
them
very
easily
just
by
adding
the
shell
content
there.
And
finally,
you
know
these
are
all
the
idioms
are
already
baked
into
the
system
right,
but
that
you
can
build
with
which
shell
today
now
the
other
thing
that
we're
adding
two
forms
are
two
things
that
have
been
highly
requested.
B
The
first
one
is
the
collection
view,
so
we
know
that
you
wanted
to
have
a
collection
view
that
goes
beyond
just
lists,
but
we
took
this
opportunity
with
collection
v2
to
actually
make
something
general-purpose,
so
these
can
actually
replace
the
usage
of
ListView
and
it
has
some
much
better
performance
characteristics
than
the
old
ListView,
and
that
is
because
we
no
longer
use
cells.
Sales
were
a
great
concept,
were
a
great
concept,
but
they
didn't
really
map
well
to
the
way
that
it
worked.
It
was
very
expensive.
B
So
now
you
just
use
regular
views
and
data
templates.
So
some
of
the
view
that
had
concerns
about
the
performance
of
ListView
were
addressing
those
problems,
would
collection
view
by
essentially
eliminating
the
concepts
of
cells
and
going
with
views
and
data
templates.
Let
me
give
you
a
little
bit
of
a
taste
of
collection
view
on
this.
Video
that
I
have
here,
I
hope
I
can
I
can
get
it
to
play
yep
there
he
goes.
So
this
is
a
new
UI
that
previously
was
not
possible
to
build
with
the
base
with
the
built-in
capabilities.
B
Oh,
it
would
have
been
very
difficult
to
get
this
sort
of
UI.
You
can
have
custom
layouts,
which
I'm
sure
a
lot
of
you
would
be
very
excited
to
do
use
and
the
other
element
is
the
other
thing
is
many
of
you
want
to
have
a
carousel
view,
and
it
turns
out
that
a
carousel
view
is
just
a
collection
view
with
some
good
defaults
in
place.
So
so
this
is
a
sample.
B
Just
of
the
carousel
view,
which
again
it's
just
a
collection
view,
but
it
has
been
customized
to
have
this
particular
behavior
I,
want
to
close
with
two
last
pieces.
I
didn't
want
to
get
to
every
single
feature
of
forms,
there's
just
too
many.
This
year
at
the
beginning,
we
launched
the
project
f-100,
which
was
a
hundred
paper
cards,
and
a
hundred
small
features
that
that
our
community
wanted.
We
work
with
the
community
and
and
we've
gotten.
B
We've
got
a
lot
of
those.
It's
a
very,
very
long
list
of
every
single
little
piece
keep
those
things
coming,
hopefully
we'll
get
that
to
project
F,
200
and
so
on,
and
finally,
we're
about
to
launch
or
xamarin
essentials.
Szymon
essentials
is
the
companion
to
forms
that
allows
you
to
abstract.
If
you
don't
want
to
use
the
native
API
sand,
you
just
want
to
have
a
nice
cross-platform
abstractions.
It
is
our
cross-platform
abstraction
for
the
non
UI
pieces,
so
you
should
give
it
a
shot
and
and
that's
it
for
the
mobile
segment.
A
So
I
think,
well,
you
know
kind
of
in
closing
we
have.
You
know
this
is
just
the
start
of
dotnet
conf
2018,
there's
a
bunch
of
awesome
sessions
coming
up
over
the
next
couple
of
days.
We
were
just
looking
at
the
schedule
over
there
a
second
ago
and
James
on
your.
Your
team
has
got
a
mobile
session
coming
up.
Dan
Roth's
got
an
asp
net
core
update
coming
as
well
he's
got
a
blazer
update,
coming
Diego
on
the
teams,
got
a
EF
update
coming
as
well
so,
and
then
we
already
talked
about
tomorrow.
A
We're
gonna
kick
off
with
some
AI
with
akut
and
Caesars
got
a
section
on
that
as
well.
So
there's
tons
of
us
and
I'm
skipping
more
plenty.
People
as
well
kyndra's
got
an
update
on
you
know
what
productivity
features
we
have
in
Visual
Studio,
so
there's
tons
of
great
content
coming
the
next
day
or
two
or
three.
So
please
watch
that
content
and
enjoy
being
a
dotnet
developer
and.