►
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
A
B
Okay
ray,
we
are
in
theory,
live
because
last
week,
I
kind
of
fussed
about
while
I
was
saying,
I,
think
we
live
and
then
let's
up
and
then
when
I
watched
it
back
afterwards,
there
was
all
of
us
fussing
about
on
the
recording,
so
I
think
we're
actually
live
in
there.
There's
no
one
watching
us.
Yet
there
is
one
user
concurrently,
I.
A
B
B
B
The
last
two
that
you
said
it
matched
up
exactly
with
how
long
we'd
been
on
the
stream.
For
sorry,
it's
just
interesting.
If
I,
let
me
have
a
look
if
I
go
and
look
at
both
you're
looking
the
public
one
I
guess
yes,
so
professional
I'm!
Looking
at
the
monitors
you
do
know
you're
right!
It's
it's
42!
Well,
I!
What
are
you
gonna
do?
What
are
you
gonna
do?
This
is
delayed
for
some
reason.
Well,
hello,
everybody!
We
are
here
this
week.
It
is
still
just
John
and
I
I'm.
Sorry,
I'm!
B
B
B
But
we
had
a
different
blog
post,
we're
new
blog
post
yesterday
about
dr.
standard
2.1,
announcing
Kotnis
in
2.1,
and
some
details
around
that.
Obviously,
you
spoke
about
last
week
supposed
today.
I'll
tell
a
little
bit
about
an
early
discussion
about
the
features
that
we
have
planned
for
a
spinet
core
3
and
we
might
have
a
little
chat
about
a
tweet
I
put
out
during
the
week
regarding
some
potential
proposed
modifications
to
this
show
or
additions.
B
I
should
say
to
this
show
because
we
don't
really
plan
on
removing
anything
but
we're
looking
at
maybe
opening
up
to
more
content.
Sebastian
is
saying
the
audio
is
the
best
it
has
ever
been
right
now,
that's
quite
exciting.
Sebastian
is
a
very
critical
sort
of
individual,
so
I
am
taking
that
with
the
extra
extra
kudos,
so
Sebastian
says,
is
good.
It
must
be
amazing
to
be
amazed.
That
is
good.
A
B
A
B
A
So,
first
of
all,
starting
with
another
from
shahid
he's
been
doing.
This
series
he's
told
me
he's
running
through
the
end
of
the
year
with
these,
at
least
so
a
lot
of
good
stuff
here,
he's
talking
about
Web
Apps
secrets
in
asp
net
core.
This
is
an
important
thing.
It's
very
if
you're
used
to
throwing
stuff
in
web
config,
you
can
definitely
make
some
mistakes
with
this.
So
it's
it's.
A
To
understand,
like
the
different
places,
you
can
put
your
secrets:
don't
just
throw
all
your
stuff
in
your
in
your
connection,
strings,
like
so
understanding,
user
secrets
and
secret
manager
is
important
and
that
whole
flow
I
always
walk
people
through
this,
and
you
know
to
Damian.
We
do
this
during
the
during
the
workshops
where
we
say
you
know,
like
here's,
where
you
put
your
secrets
when
you're
developing
locally
right-
and
you
know,
use
your
user
secrets
and
then
you
know,
promote
those
up
to
environment
variable
and
you
know,
as
Huw,
deploy
or.
B
B
A
Nice
to
see
that
walkthrough
cool
here's
one
from
Andrew
so
last
week,
we're
looking
at
configure
using
configure
for
loading
in
options,
strongly
typed
options,
and
here
he
talks
through
instance,
where,
if
you
are
developing
something
that
can
read
in
strongly
typed
options
and
you
need
to
enforce
something,
then
you
need
to
know
about
this
post
configure
event,
and
it's
just
good
to
know
about
in
general.
So
here
he
walks
through.
A
So
you
know
the
idea
here
is
as
a
library
author,
and
he
has
an
example
where
he's
got
a
whatsapp
service
and
the
general
idea
here
is:
he
has
a
rule
where,
if
you
are
going
to
make
one
setting,
then
you
must
also
make
another
setting.
So
if
you're
gonna
set
default
hosted
URL,
then
you
must
be
in
the
default
hosted
region
right.
B
B
So,
what's
interesting
about
this
is
that
this
API
he's
using
was
introduced
in
2.1.
This
is
the
post
configure
step
and
we
use
this
inside
some
of
our
own
subsystems
like
identity,
to
ensure
that
if
you,
because
we
have
fairly
complex,
you
know,
sets
of
options
because
they're
flexible
and
then,
if
you
set
one
option
like
you
said,
you
may
have
to
may
have
to
set
another
one
or
you
may
make
inflict
with
a
different
one.
B
B
Of
it,
yeah
I,
don't
even
think
we've
done
a
blog
post
of
it,
but
there's
a
great
idea
for
maybe
next
week's
show
the
week
after
that
we
could
get.
Maybe
I
can
convince
how
who's
the
developer
of
this
to
come
on
and
talk
about
options,
validation
so
now
in
2.2,
rather
than
having
to
do
this,
which
is
a
custom
post,
configure
the.
B
You'll
be
able
to
instead
register
like
your
options
type,
you
can
stick
data,
annotation,
attribution,
attributes
on
them
and
we'll
find
those
and
validate
them.
Assuming
the
app
is
wired
up
that
way
or
you
can
register
custom
delegates
that
will
validate
your
options
as
well.
It's
all
built
on
top
with
the
same
stuff,
although
it
all
boils
down
to
like
we
register
a
delegate
that
that
runs
on
this
event
that
you're
showing
here,
but
it's
gonna,
be
much
easier.
B
A
Okay,
cool
well
always
nice
to
be
able
to
delete
some
code
yeah.
Absolutely
so
here
he's
showing
you
know
the
in
this
case
he's
got.
You
know
this
kind
of
not
robust
thing
where,
if
you
set
things
in
the
wrong
order
or
whatever
it
might
not
work,
and
then
he
shows
using
this
post
configure
options
in
his
library,
so
yep,
alright,
so
great
and
I.
This
was
a
great
opportunity
for
me
to
learn
about
a
feature
I
didn't
know
into
to
so.
B
A
A
By
the
developers
of
my
sequel-
or
you
know,
after
as
a
replacement
for
my
sequel,
and
so
here
he
walks
through.
I
I'm
I'm
interested
in
this
as
I'm
seeing
people
building
out
these
kind
of
full
examples.
You
know
building
out
something,
that's
more
complex,
so
decent
amount
of
code
here
he's
you
know,
building
out
this
entire
back-end,
and
let
me
roll
way
down
here.
So
it's
a
you
know,
editing,
employees
and
stuff.
So
this
is
neat
I'm.
B
A
B
A
Stuff,
okay,
continuous
integration
from
tiago
here
he's
it's
it's
a
relatively
quick
walkthrough
on
using
Azure
pipelines
with
asp
net
core.
So
this
is
something
where,
if
you're
kind
of
generally
aware
that
it's
out
there,
this
is,
you
know
I
recommend,
go
through
and
do
this.
You
can
do
this
in
a
period
of
a
few
minutes
here,
so
creating
creating
a
project
and
setting
it
up
and
setting
this
up.
So
you
have
a
build
going
against.
You
know,
including
github,
as
your
back-end
and
and
running
builds,
as
your
code
is
checked
in
all
right.
A
Two
neat
ones
from
visual
studio
magazine
on
blazer
one
is,
is
on
working
with
events
and
looking
at
you
know,
building
up
from
the
simple
events
where
you
know
you
have
like
an
on
click
and
there's
there's
no
nothing
to
pass
or
configure
with
it.
Then
building
up
to
things
like
event,
data-
and
you
know
so
here
as
a
key-
was
pressed,
and
you
know
which
exact
key
was
pressed.
A
B
A
That's
cool
here's
another
neat,
one
from
pete
Vogel
and
here's
talking
about
using
adding
blazer
to
an
existing
HTML
and
JavaScript
page.
So
it's
very
easy
to
do.
File
new
project,
blazer
and
you've
got
something
all
pre-wired
up,
but
another.
You
know
maybe
more
real-world
example
or
a
nice
example
is
a
case
where
you've
got
an
existing
site
and
you'd
like
to
take
advantage
a
blazer
there.
So
here
he
talks
about
integrating
that
in
so
you
know,
you've
got
the
the
required
includes
and
he
talks
about
here.
A
The
using
JSON
time
invoke
async
to
actually
initialize
the
page,
so
yeah,
relatively
quick
post,
but
good
to
know
about
alright
Scott
Allen
here
he's
previously
posted
seven
tips
for
troubleshooting
asp,
net
core
startup
errors,
and
here
was
an
interesting
one.
He
ran
into
where
application
wasn't
starting
up
on
on
app
as
app
service.
Sorry
brain
just
went
away
on
a
strap
service,
and
so
here
the
thing
that
he
actually
ran
into
was
debugging
using
the
cuda
console
and
it
would
start
in
some
circumstances,
but
not
in
others
and
what
he
found
out
was.
A
He
actually
had
this
hosting
startup
assemblies
and
there's
a
conflict
between
the
the
different
possible
ways
that
that
they're
loaded,
so
you
can
have
a
sure,
appian
sites
loaded
either
via
the
extension
or
if
it's
configured
via
visual
studio,
there
can
be
a
conflict,
so
so
this
is
a
pretty
specific
case
where
he
had
to
uninstall
one
or
the
other,
but
also
good.
To
know
that
you
can.
You
can
do
this,
where
you
can
go
over
to
kudu,
console
and
just
run.
You
know
from
the
command
line
and
see
what
happens
in
production.
A
There
go
all
right,
so
Johnny
here
has
a
nice
post
I'm
calling
this
out
specifically
because
he
has.
This
is
a
forty,
eight
minute
video,
where
he
walks
through
everything
and
then
a
long
vlog
post
to
go
with
it.
So
you
know
sometimes
sometimes
people
will
post
either
a
video
or
a
blog
post,
and
here
we've
got
both.
So
this
is
a
review,
pretty
an
in-depth
repeat
or
deep
dive
into
dependency
injection
I'm.
You
know
building
I'm
not
going
to
go
through
it
in
more
depth.
A
This
is
48
minutes
a
video
or
a
long
blog
post
ahead
of
you
if
you're
interested,
ok,
faster
front-ends
and
asp
net
core
from
dustin.
So
here
he's
talking
about
some
of
the
front
end
things
like
bundling
minification,
starting
with
measuring.
How
do
you
actually
measure
and
he
talks
about
mini
profiler
and
then
goes
into
fiddler?
A
So
and
then
you
know
digging
into
what
your
options
are
for
things
like
bundling
and
minification,
and-
and
you
do
have
several
right-
there's
there's
like
web
pack,
there's
a
bundler,
mid,
afire,
there's
compression,
etc.
So
there's
a
lot
of
kind
of
options
here,
right,
I've
I've,
you
know
done
some
things
like
people
have
tweeted
to
me
and
asked
about
this
or
I've
written
things
up.
It's
it
seems
like
this
is
something
where
it's
a
little
bit
a
little
bit
of
a
science
project
and
some
of
the
docs.
A
B
A
A
A
B
A
And
buried
it
earlier
too,
and
we
retweeted
it
from
the
asp
net
and
from
the
dotnet
things
to
on
twitter.
So
if
you're
following
any
of
those
you'll
see
it
and
the
last
one
you
mentioned
this
earlier,
but
asp
net
or
dotnet
standard
two
one.
So
you
know
a
nice
post
here
on.
What's
in
there
a
vanity
from
other
things,
reflection,
Amit,
I,
love,
Cindy,
so
much
I,
just
love
watching
all
the
the
you
know,
posts
and
PRS
and
stuff
that
go
in
as
we
continue
to
take
more
advantage
of
that.
A
So
that's
neat,
oh
cool
and
then
talking
about
platform
support,
and
then
this
is
really
I.
Think
important
is
this
whole
governance
model
so
mo
and
I
talked
about
this
and-
and
we
worked
on
you
know
getting
this
set
up.
This
is
something
that
we're
doing
very
much
with
the.net
foundation.
So
it's
not
it's.
You
know,
there's
a
whole
governance
model
and
a
review
board
and
everything.
So
this
is
really
the
the
standard
is
something
that's
done
in
the
open,
something
that
you
can
get
involved
with
in
review.
So
I
think
this
is
really
cool.
A
B
Okay,
all
right
well,
I
wanted
to
I.
Haven't
got
all
the
time
today.
I
have
to
leave
today.
It's
my
son's
final
for
go-karting
tonight
for
the
for
the
year,
so
I
have
to
leave
early
to
go
pick
him
up
and
take
me
that
so
I
wanted
to
start
early
today.
So
we
could
have
a
little
bit
of
a
chat
about
300
features,
so
an
actual
feature,
little
stuff
coming
in
three
Oh,
so
I'm
gonna
share
my
screen
and
I
got
a
couple
of
things
here
that
I
wanted
to
show
folks.
B
All
that
org
across
all
the
feature
areas
that
we
care
about
and
we're
focusing
on
this
release
and
then
what's
interesting?
Is
we
also
compare
that
back
to
what
we
had
done
for
the
previous
release
so
that
we
have
a
bit
of
a
Delta?
So
we
can
see
roughly
oh
we're
increasing
investment
here
in
terms
of
the
folks
we
have
involved
or
decreasing
the
investment
here
now,
just
don't
people
if
there
are
people
out
there
who
are
upset
that
I'm
treating
your
developers
like
numbers.
Trust
me
there
is.
B
There
is
personal
details
in
this
spreadsheet
which
I've
hidden.
So
we
don't
just
like
treat
yeah.
You
know,
however
many
developers
we
have
is
just
individual
P,
it's
just
like
oh
they're,
cattle
and
I
can,
just
you
know,
put
four
here
and
put
six
there.
You
know,
and
we
all
know
it
doesn't
work
that
way.
B
We
have
different
people
with
different
talents
and
different
interests,
and
we
take
that
into
consideration
when
we
do
this
as
well
like
any
like
any
good
development
team
would
I
would
argue,
but
I've
hidden,
all
their
names,
because
you
don't
need
to
know
those,
and
so
what
we
do
have
here,
though,
is
the
overall
assignment
of
how
many
developer
bodies
basically
have
we
assigned
to
each
area,
and
then
how
is
that
different?
What's
the
change
from
the
previous
release
being
that's
line
29
here
and
then
how
focused
is
that
crew?
B
So
the
crew
is
the
verticals
here.
Each
column
here
represents
like
an
area,
a
bunch
of
features
like
signal,
art
or
MVC,
and
endpoint,
routing
or
raiser,
and
then
the
last
line
here
is:
if
we
look
at
the
entire
team,
all
in
developers,
how
focused
is:
are
we
how
much
of
the
team
are
we
focusing
on
a
particular
area?
Okay,
so,
like
that's
kind
of
an
interest
interesting
place
to
start.
So
if
we
look
at
EF
and
EF
6,
so
entity
framework
core,
obviously,
will
be
part
of
EF
a
part
of
Donna
core
3.
B
You
will
have
an
indie
framework
or
three,
and
this
feature
is
coming
for
that,
but
there's
also
indie
framework
six,
which
we
have
already
announced,
is
going
to
be
ported
to
work
on
dotnet
core
to
help
customers
who
really
need
the
capabilities
they've
been
in
the
framework
six,
which
simply
won't
come
over
because
of
the
way
indie
framework
or
is
addressing
slightly
different
problems.
So
we
you
can
see
that
of
the
entire
engineering
team.
You
know,
21%
of
our
engineers
is
focused
on
indie
framework.
B
Okay,
so
that
kind
of
gives
you
an
idea
like
I'm
a
little
bit
more
than
a
fifth
of
the
entire
team
is
focused
on
any
framework.
The
next
biggest
investment
in
this
release
is
Razer,
and
so
we
we
sort
of
blow
a
blazer
post.
There.
We've
talked
a
lot
about
blazer
how
it's
an
experiment:
it's
not
real,
but
then
we
made
the
announcement
we're
going
to
take
the
component
model
from
blazer
and
we're
going
to
pull
that
into
raiser
on
the
server.
B
B
You
know,
hopefully
very
simply,
move
those
to
run
the
client,
and
so
we
have
a
large
investment
in
razor
in
3o,
and
that
is
a
combination
of
you
know
the
actual
razor
compiler,
the
parson
and
the
compiler,
the
build
chain,
the
component
models
or
all
the
API
is
that
you
use
all
the
stuff
that
you
see
in
Blazer
today
like
how
do
I
do?
How
do
I
implement
types
and
all
that
type
of
stuff?
You
know:
what's
the
replacement
for
tag
helpers?
B
A
B
So,
no,
no,
it's
point,
eight
percent
of
the
entire
team
that
is
keeping
so
from
this
team.
This
team
doesn't
own
web
assembly,
this
team
that
own
the
mono
runtime.
This
team
owns
the
blazer
framework
and
it
has
been
an
experiment.
To
date,
we've
only
had
one
engineer:
full-time
on
blazer,
that's
been
Steve
running
it
as
an
experiment.
Most
of.
B
Probably
yeah
so
like
yeah,
so
that
that's
right,
and
so
because
this
this
20
percent-
oh
this,
you
know
this-
this
0.2
people,
20
percent
of
a
developer,
is
how
do
we
ensure
that
the
blazer
experiment
continues
during
the
during
the
3o
timeframe?
Most
of
the
work
is
going
into
the
stuff
we're
going
to
ship
in
three,
oh
and
then
there's
a
little
bit
of
work
to
make
sure
that
you
can
continue
to
do
new
blazer
releases.
B
As
the
mono
team
develops
new
webassembly
bits
that
we
repackage
the
templates
we
ship,
those
out
so
they'll,
be
a
blazer
o7o,
a
blazer
away,
tow
etcetera,
etc,
but
we're
not
shipping
the
blazer
on
top
of
wears
them
in
three.
Oh
right,
so
it
doesn't
need
as
many
people
on
it
as
we
as
we
had
before,
and
obviously
there
could
be
mistakes
in
the
spreadsheet
as
well.
So
if
you
think
they
I'll
point
out,
but
I
think
that
one's
great
so
yeah
blazer
was
the
next
as
a
razor.
B
Sorry
in
covering
all
the
stuff
I
talked
about,
I
think
the
next
highest
investment
we
have
is
signalized
so
signal
our
is
ten
percent
of
the
team,
which
is
about
two
and
a
half
people,
that's
a
reduction.
We
had
more.
We
had
about
three
people
all
up
full-time
in
the
previous
release,
because
we
built
signal
our
core
in
2.1,
and
then
we
added
clients
in
2.2
this
time
around.
B
This
is
mostly
adding
clients
and
I'll
talk
a
little
bit
about
the
features
for
each
of
these
in
a
moment,
and
some
work
with
the
Asian
signals
service
and
just
improve
in
some
stuff
there.
So
there's
that
and
then
I
think
the
next
one
after
that
was
servers.
If
I
recall
so,
like
you
know,
we
own
Kestrel,
we
own
the
ANC
m8
net
core
module,
it's
a
big
reduction
in
investment
this
time.
B
So
in
the
big
work
we
did
here
was
a
SEM
in
proc,
so
the
ability
to
host
a
spinet
caught
inside
a
is
in
process
with
is
that
was
a
lot
of
work.
It
literally
took
you
know
more
than
three
engineers
to
get
that
put
together
through
the
entirety
of
now
that
that's
done,
we'll
move
into.
We
have
to
finish
HTTP
in
Kestrel
in
three.
Oh
and
obviously
we
just
have
to
maintain
Kestrel
and
maintain
the
NCM
work.
There'll,
be
a
bug,
tail
node
out
and
we'll
have
to
do
some
work
there.
B
Bit
of
a
tail
after
that,
so
there's
some
new
things
here
which
are
interesting,
but
it's
probably
less
interesting
to
keep
looking
at
numbers
and
more
interesting
to
go
off
to
a
different
view
and
actually
look
at
people.
I
mean
this.
One
is
interesting,
so
there's
no
overhead,
obviously
just
keeping
things
building.
So
we
have
a
couple
of
people
whose
job
is
just
to
like
keep
the
stuff
building
integrating
with
the
bigger
build,
make
sure
our
stuff
gets
inserted
into
the
ACE.
B
A
B
B
So
in
terms
of
stuff,
if
we
look
at
sort
of
web
apps,
so
I
think
most
people
already
know.
The
big
things
here
will
support
raises
C
sharp.
You
know
C
sharp
B
inside
razor,
because
that's
the
next
version
language
we
often
have
to
do
stuff,
as
they
entered
introduced,
syntax
to
support
that
inside
razor.
The
big
thing,
obviously,
is
razor
components.
You
know,
plus
the
tooling
work,
including
vs
code,
which
we
released
in
the
latest
version
of
the
Omni,
sharp
or
C
sharp
extension
hope
folks
have
tried
that
out.
B
B
For
a
customer
we
would
love,
be
able
to
react
to
that
much
quicker,
and
that's
not.
That
is
difficult
today
when
it's
inside
the
sdk,
because
we
kinda
have
to
wait
for
the
SDKs
ship
cycle,
and
so
we
plan
to
take
those
out
of
the
sdk
make
them
separately
installable.
We
still
think
I,
don't
think
we
still
plan
to
include
them
in
the
visual
studio
experience
by
default,
because
we
have
extra
capabilities
in
there.
B
You
can
download
things
on
the
fly
and
all
the
type
of
stuff,
but
for
the
command
line
it
would
just
be
moved
out
of
the
SDK,
so
the
end
result
to
customers
isn't
any
different,
we're
still
gonna
do
them
and
all
that
type
of
stuff
it
just
frees
us
up
to
do
stuff,
hopefully
a
little
more
flexibly
for
the
generic
host.
This
is
something
we
introduced
into
one.
B
It's
basically
take
the
goodness
of
web
host.
Where
you
boot
up
your
application,
you
configure
the
server.
You
can
figure
the
container,
you
can
figure
logging
a
configure
for
configuration,
and
then
you
can
say,
go
from
the
you
know
from
your
program
CS
and
the
console
app
and
then
make
that
available
for
other
app
types.
You
know
app
types
that
don't
have
a
web
server,
for
example,
which
all
can
become
a
little
interesting
when
we
get
to
line
eight,
and
so
we
actually
intend
for
generic
host
to
basically
replace
web
host
so
everywhere.
B
Today,
where
we
you
see
web
host
and
the
templates,
the
current
planners
web
host
will
still
be
in
three
Oh.
It
might
be
marked
obsolete
with
the
intention
that
we
would
remove
it
in
the
next
major
release
in
forw,
and
then
it
would
be
a
fairly
straightforward
process
to
move.
You
know
the
few
lines
of
code
that
you
have
in
program
main
from
the
web
host
start
to
the
generic
host
art.
The
advantage
is,
then,
you
can
use
that
same
host
entry
point,
not
just
a
host
Web
Apps,
but
to
have
apps
that
are
hybrid.
B
So,
for
example,
you
could
have
signal
are
running
over
HTTP
in
the
web
part
of
your
app
but
then
also
listening
over
over
TCP,
but
on
tile
on
top
of
the
same
host
and
on
top
of
the
same
kestrel
server,
you
could
also
have
the
same
host
hosting
the
azure
web
jobs
sdk,
which
is
the
next
section
responding
to
as
your
storage
triggers
or
a
rabbitmq
message.
Bus
event,
all
inside
not
only
the
same
app
but
running
inside
the
same
host,
which
means
they
share
logging.
B
Your
message
thing
all
the
service,
bus
or
etc,
etc,
etc.
They
are
event-driven
request,
remand,
they're,
not
I,
start
a
server
and
a
way
for
requests
there
I
start
up
and
then
I
wait
for
something
to
happen.
Either
a
timer
interval
or
something
triggering
off
a
web
hook,
or
something
like
that
right.
So
that
app
model
we
want
to
share
as
much
as
we
can
with
all
the
goodness
that
we
have
with
a
spin
on
their
core.
So
again
we
want
the
same
host
type.
We
want
the
same
logging.
We
want
the
same
configuration.
B
We
want
the
same
di.
Well,
it
turns
out.
That's
already
been
built,
it
was
the
age
of
web
Jobs
SDK
and
that's
100
pinzer
functions
and
as
your
functions
v2
is
built
on
dotnet
core
and
is
built
on
generic
host.
So
they
already
do
all
this
stuff.
You
can
just
download
the
edge
of
webshots
STK
and
run
it
anywhere.
Now
we
want
our
stuff
to
be
cloud
agnostic.
We
want
you
to
be
able
to
run
these
things
on-premises.
B
You
won't
be
able
to
run
them
on
Google
and
Amazon
or
whatever
you
want
to
run
this
stuff.
Go.
It's
just
dotnet,
so
don't
be
fooled
by
the
fact.
It's
called
or
as
your
web
drops
SDK
it's
just
dotnet,
and
then
it
has
a
bunch
of
triggers
that
you
can
pull
in
fire
packages
to
say,
hey
yeah.
This
trigger
will
call
will
allow
me
to
bind
this
class
a
bit
like
an
MVC
controller,
so
that
this
method
runs
when
an
azure
blob
storage
file
is
changed
right.
B
B
A
B
Not
at
all
so
yes
at
a
compilation
as
an
aside,
we
previewed
in
2.1.
You
could
turn
it
on
in
your
2.1
apps
and
it
was
specifically
marked
as
preview.
So
we
wanted
people
to
try.
It
give
us
feedback,
but
it
wasn't
supported
for
production.
We've
had
it
on
by
default
in
in
the
runtime,
but
it
won't
be
on
in
the
previews.
I
should
say
it
won't
be
on
by
default
in
the
in
the
RTM
ok
into.
B
But
if
you
turn
it
on
into
it's
supported
so
and
it's
very
beneficial
most
people
to
turn
on
tear
compilation.
It
generally
has
a
good
improvement
on
startup
time,
but
more
so
it
has
a
really
big
improvement
on
what
we
call
steady-state
performance
or
just
throughput,
and
so
we
want
folks
to
really
try
that
out
in
and
then
the
plan
in
300
is
just
to
have
it
on
by
default.
So
the
more
people
who
turn
on
in
and
give
us
feedback
to
make
sure.
B
Now
that
it's
supported
that
we
haven't,
you
know,
introduced
any
problems,
we'll
feel
more
confident
turning
it
on
by
default
in
the
next
major
version
so
hear
more
about.
There
has
been
a
blog
post
about
tea
compilation,
we'll
do
another
one
after
was
out
to
really
encourage
folks
to
turn
it
on
and
try
it
out.
So
let's
go
back
to
my
screen,
so
a
P
I
client
James.
B
B
I
have
a
service
reference
from
this
project
to
this
swagger
document
or
to
this
swagger
or
to
this
project
that
contains
a
swagger
endpoint,
then,
as
part
of
the
build
or
throw
a
gesture,
you
can
get
code
emitted
in
the
client
project
and
we'll
start
out
with
c-sharp
code,
but
the
intent
is
that
would
support.
You
know
any
client
type,
so
you'd
be
able
to
have
type
secret
clients
being
generated
or
Java
clients,
whatever
it
might
be,
depending
on
I.
B
That
uses
msbuild,
because
this
is
an
MS
build
feature,
so
usually
going
to
be
a
mass
build
projects,
but
the
idea
obviously
is
just
to
make
a
better
fit
into
end
API.
You
know
authoring
and
consumption.
So
that's
going
on
endpoint
routing
which
we
shipped
in
is
shipping
in
behind
the
scenes
in
MVC.
B
So
MVC
gets
all
the
performance
benefits
of
endpoint
routing
in
three
Oh,
in
fact,
hopefully
in
the
first
preview
of
300,
endpoint
routing
will
be
available
for
all
and
it
will
be
updated
in
the
templates
and
so
rather
than
MVC,
just
like
well
being
having
its
own.
Endpoint
routing
will
will
enable
endpoint,
routing
and
new
projects
by
default
because
it'll
be
in
the
template,
and
it
basically
gives
you
a
new
overlay
on
top
of
a
middleware
that
makes
grouting
global.
So
routing
is
now
a
global
concern.
B
Any
many
a
middleware
can
set
the
endpoint
at
any
point
during
that
during
the
lifetime
of
the
request,
it's
a
little
similar
to
how
you
used
to
have
modules
and
handlers
and
a
module
could
set
the
handler
at
the
end
of
the
request,
and
so,
but
it
basically
is
designed
for
things
that
are
terminal.
So
if
you
have
any
middleware
today
that
usually
ends
up
being
terminal.
B
That
means
when
it
matches
it
then
runs
and
then
shortcuts
the
pipeline,
like
MVC,
does
or
Sigma
those
are
candidates
to
become
endpoint
route
handlers
in
the
new
world,
and
you
get
a
whole
bunch
of
benefits
from
doing
that,
it's
much
faster.
You
can
attach
metadata
to
routes
or
to
requests
as
they
go
through
the
middleware
pipeline,
which
means
that
things
like
authorization,
now
become
a
global
concern.
Today,
authorization
has
implemented
multiple
times
its
implemented
MVC,
it's
implemented.
A
signal
are
its:
we
don't
have
authorization
for
static
files.
B
If
you
have
your
own
framework
like
Nancy
or
some
other
thing,
then
you
don't
have
any
authorization.
We
might
share
the
attributes
today,
but
the
actual
thrift
authorization
implementation
is
not
in
the
pipeline.
That
will
be
different
in
302,
be
an
authorization
middleware
and
it
will
work
with
endpoint
routing
to
be
able
to
look
at
the
metadata
on
the
concurrent
requests
and
determine
if
the
endpoint
needs
authorization.
If
it
does
it'll
be
able
to
perform
that,
for
you
very
similar
to
how
authentication
works
today,
h-2b
2
is
basically
finishing.
B
B
Hurting
in
space
it
yeah
it's
basically
baked
time
right,
it's
basically
all
the
stuff
about
it's
baked
time,
so
HTTP
one
one.
Obviously
it's
been
in
coaster
a
longer.
We
put
a
lot
of
effort
into
making
sure
we
added
limits
and
we
tested
those
limits
and
we
had
third
parties
look
at
those
limits.
I
we
did
all
the
things
that
you
do
but
where
they
should
be
to.
B
This
is
the
first
release
that
we've
house
h2
b2
and
it's
a
minor
release,
so
we
haven't
as
much
time
so
it's
just
not
ready
to
turn
on
by
default.
The
signal
are
a
couple
things
we're
looking
at
a
feature
called
client
hubs
which
is
basic
as
a
bad
name.
It's
really
typed
hubs,
so
the
ability
to
have
the
same
type
of
type
safety
on
the
server,
but
have
that
in
dotnet
clients.
So
you
can
say
I
when
you
build
your
server-side
hub,
you
can
attach
an
interface
to
it.
B
A
A
B
Server-Side
blaze
of
stuff
or,
what's
currently
being
called
razor
circuits
or
component
circuits,
which
is
where
you
have
something
running
sort
of
rendered
in
the
browser,
but
it's
actually
running
on
the
server,
which
is
the
server-side
laser
model
that
uses
signal
are
today
whether
it
continues
to
use
the
signal
a
layout
or
whether
it
goes
lower.
The
thing
that
underpins
signal
our
core
bedrock
is
still
to
be
determined.
We
don't
run
oh
yeah,
it
smells
more
of
an
implementation
detail.
B
Then
there
is
a
future
like
idea,
which
is
what,
if
we
could
somehow
have
a
higher
level
concept
where
Blaser
and
signal
I
work
together.
So
if
you
have
a
component,
which
is
a
RZR
component,
that
needs
real-time
functionality,
could
we
give
you
a
primitive
for
that?
That
makes
it
easy,
so
you
don't
have
to
wire
it
up,
and
maybe
that's
what
your,
what
you're
thinking
about,
so
that
that
won't
be
in
300,
but
that's
kind
of
an
idea
that
we
had
further
on
that.
We
kind
of
call
c++
client.
B
We
have
a
bunch
of
customers
who
are
interested
in
using
signal,
are
in
games,
and
so
C++
is
interesting
or
IOT.
C++
is
interesting
there.
So
we
want
to
do
a
super
plus
client.
We
also
have
a
swift
client
that
was
written
by
former
team
member
who
down
doesn't
work
for
us
but
is
maintained
in
the
community.
It
might
be
interesting.
B
We've
had
some
folks
ask
for
that
as
well,
and
so
we
might
we'll
see
how
much
time
we
have
and
all
the
rest
of
it
but
I
think
that's
kind
of
the
order
of
things
that
were
looking
at
there's
like
there's
a
couple.
Little
of
other
things
in
signaler
as
well
they're,
not
really
worth
calling
out
GRP
see.
This
is
an
interesting
one.
B
So
folks
might
know
what
GFP
C
is
already
it's
a
Google
based
RPC
protocol
that
is
implemented
on
top
of
HTTP,
2
and
protobuf,
and
it's
basically
designed
for
tightly
coupled
services
where
you
need
incredibly
high
performance,
and
you
want
strong
contracts
between
the
client
and
server
for
folks
who
have
used
WCF
with
the
net
tcp
binding.
It
might
sound
familiar
it's
a
very
similar
problem.
Space
you've
got
two
services,
you
own
both
sides.
B
You've
got
a
service
on
a
client,
and
you
want
there
to
be
a
typed
interface
with
message
exchange
between
them
base
width,
which
looks
like
RPC
I,
just
call
the
method,
I
get
a
response
back
and
I
want
that
to
be
as
fast
as
possible.
That's
what
G
RPC
is
designed
to
do.
We
see
it
increasingly
being
used
in
micro
services
architectures,
where
you
have
services
calling
other
services
and
inside
Microsoft
some
people
might
have
heard
of
bond,
which
was
a
binary
serialization
format
built
by
the
Bing
team.
B
My
understanding
is
they're
now
exploring
moving
to
G
RPC
instead
because
it
becomes
more
and
more
prevalent,
and
so
we
want
to
help
Google
make
the
dotnet
G
RPC
implementation
as
good
as
it
can
be,
so
they
have
one
today.
We
think
it
could
be
a
little
better.
We
think
it
could
integrate,
probably
more
naturally
with
the
way
the
net
projects
work
in
dotnet
core,
and
so
we
are
gonna,
try
and
dedicate
some
resources
to
help.
Do
that,
so
we'll
work
with
them,
I'm
not
gonna,
build
our
own
thing.
B
We're
gonna
help
them
build
their
thing
and
make
it
as
good
as
it
can
be.
So
that's
something
that
we're
interested
in
doing
and
that,
hopefully,
will
go
all
the
way
to
you
know
you
can
one
day
you
can
file
new
and
Visual
Studio
and
there'd
be
a
G
RPC
project
template
in
there
by
default
as
part
of
our
workload
offering,
and
then
you
can
build
a
gr
PC
based
application
and
you
it
feels
like
their
core
and
but
you
get
all
the
great
benefits
of
G
RPC
cool,
distributed
tracing.
B
Teams
in
Microsoft
who
are
working
with
Google
and
some
other
vendors
and
the
standards
boards
about
this.
So
we
hope
to
get
that
integrated
into
dotnet
so
that
when
you're
using
dotnet
again
highly
distributed,
applications,
typically
micro
services,
that
call
out
to
other
things
that
we
all
kind
of
it
to
the
standard
sets
of
headers
that
he
used
to
pass
correlation,
IDs
and
bags
of
a
door
and
all
that
type
of
stuff.
So
that's.
B
Part
of
300
work
so
that
helps
folks
who
want
to
get
the
benefits
of
a
standardized
distributed.
Tracing
sort
of
story,
templates
I'll
talk
about
first
quickly,
so
some
template
stuff.
We
just
did
bitched
at
4,
into
2
4
4
3.
Oh
we're
going
to
take
this
opportunity
to
have
a
bigger
look
at
our
template
story.
I
think,
there's
a
few
things:
we'd
love
to
be
able
to
do
in
3.
Oh
now
that
we're
adding
new
workloads
like
WinForms
and
WPF.
B
It's
a
good
chance
for
us
to
look
at
the
template.
Experience
of
Visual
Studio,
for
example,
and
say:
hey!
Can
we
improve
like
today
when
you
choose
a
spinet
core
application
in
Visual
Studio,
you
get
another
dialog
like
the
famed
one
asp
net
dialog.
There
are
multi
generations
of
that
dialog.
There's
a
nice
Mirko
version
and
a
nice
P
net
version
of
that
dialog
they're
different
and
then
the
dotnet
core
console
app
doesn't
have
that
dialogues.
B
If
you
want
to
build
a
dotnet
core
console
app
but
choose
the
dotnet
core
version,
you
can't
so
we
would
love
to
be
able
to
take
this
chance
to
kind
of
build
a
one
net
template
dialog.
If
that
makes
sense,
and
so
I
don't
know
what
we're
gonna
do.
It's
something
I
would
really
love
us
to
chew
off,
though,
and
really
see
if
we
can,
if
we
can
make
the
experience
of
building
your
applications
with
templates
that
have
maybe
slightly
more
granular
options.
B
That's
other
complaints
we
get
today
is
there
are
templates,
don't
have
enough
options,
and
so
we
put
stuff
in
the
template
and
some
people
don't
agree
with,
like
the
cookie
policy
stuff,
so
we've
already
got
an
issue
to
make
that
put
that
behind
an
option,
and
so
I'd
like
to
invest
a
little
bit
more
time
in
there
in
3
hours.
Well,
the
last
one
is
focusing
on
metrics
and
diagnostics,
so
this
is
about
when
you
run
your
dotnet
core
applications.
B
How
do
you
get
details
about
how
those
applications
are
running
and
then
how
do
you
diagnose
issues
with
those
applications
when
something
goes
wrong
now
today,
if
you've
come
from,
if
you've
come
from
dotnet
framework
on
Windows,
you
have
a
whole
sort
of
workflow
available
to
and
a
whole
bunch
of
tools
available
to
you
right.
You
know
how
to
take
a
dump.
You
right,
mouse
click
and
task
manager.
You
get
a
proc
down,
you
run
proc
dump.
B
You
can
take
that
file,
you
can
analyze
it
in
Visual,
Studio
or
BGE,
or
CL
RMD
ba-ba-ba-ba-ba
right
well,
you
know,
there's
a
whole
bunch
of
things
available
to
you.
You
can
use
perf
counters
to
look
at.
What's
happened
in
your
application,
it'll
tell
you
about
the
thread.
Pool
it'll,
tell
you
about
memory
allocations
and
requests
per
second
or
you
can
use
etw
in
message,
analyzer
or
perfume
or
expert
collect,
whatever
it's
called
in
the
Windows
SDK
to
collect
all
the
messages
that
are
coming
out
of
your
dock.
B
The
applications
and
most
of
those
things
don't
require
you
as
the
app
developer
to
do
anything
there's
just
part
of
running
on
Windows.
You
get
it
basically
for
free
now
that
dr.
Corr
is
cross
platano
Windows,
not
all
that
stuff
works,
because
it
was
part
of
the.net
framework,
/
windows,
relationship
and
so
there's
quite
a
big
gap
when
it
comes
to
basic
things
like
great
we're
in
my
perfect
canvas.
Well,
there
aren't
any
and
don't
they
call.
We
have
a
new
thing
called
event
calendars,
but
no
one's
admitting
them.
Yet
how
do
I
collect
those?
B
You
really
don't
really
or
you
use
perfume
and
perfuse
only
on
windows,
and
so
that's
there's
a
whole
sort
of
gap
there
that
we
want
to
try
and
address,
and
that's
gonna
there's
a
new
thing
coming
in
too
we
called
a
vent
pipe
and
we
will
do
a
demo
on
this
in
a
couple
of
weeks,
because
this
is
a
really
really
really
cool
demo.
We
have
a
new
feature
in
that's
on
by
default
in
every
application,
so
every
dotnet
core
application
has
this.
You
have
to
do
nothing.
B
It
basically
allows
us
to
build
a
set
of
tools
which
we're
doing
right
now
that
for
any
dotnet,
core
application
you'll
be
able
to
issue
a
command
on
that
machine.
That
tells
that
application
to
start
dumping
events,
okay,
so
think
of
it
like
etw,
but
we've
built
it
into
dotnet
itself,
so
that
it
runs
on
Linux
Mac
and
on
Windows.
So
you
can
say:
hey
dotnet
core
process
with
this
process
ID.
Please
start
tracing
events
for
events
that
have
this
category
name
and
pass
these
flags
to
that
event
as
well.
B
B
It
turns
out
that
we
ship
a
few
of
these
bits
today
with
the
runtime
but
they're
kind
of
hard
to
use,
and
you
have
to
know
where
the
docks
are
there
in
github,
not
on
the
dockside.
It's
all
unis
on
a
great
experience,
then,
once
you
have
like
the
tres
session
file,
which
will
be
a
net
per
file
or
you
have
a
dump
file,
what
do
you
analyze
it
with?
B
Well,
if
it's
a
windows
dump
file,
you
can
just
use
all
the
stuff
you
do
today,
but
if
it's
a
Linux
dump
file
like
what
do
you
do?
Do
you
use
lll
DB?
Did
you
do
it
that
things
called
the
debug
of
the
open
to
buggery
tools?
Oh,
do
you
do
we
want
a
different
type
of
dump
format,
or
would
you
like
you
have
to
bring
it
to
Windows
and
use
event
perfu,
or
do
you
have
to
use
a
different
command
line
tool?
B
Wouldn't
it
be
nice
if
there
was
a
consistent
way
that
you
could
easily
look
for
events
or
say
dump
the
heap
or
use
the
SOS
commands?
So
you
know
a
lot
of
people
like
using
on
Windows
in
window
BG
today,
to
like
look
at
threads
and
to
dump
stacks
and
to
navigate
the
memory
heap,
to
look
at
objects
and
stuff
wouldn't
be
great
if
you
could
do
that
using
a
dotnet
little
tool
right.
So
those
are
the
type
of
things
that
we're
building
right
now.
B
They're
all
facilitated
by
this
runtime
feature
called
the
event
pipe
and
it
is
into
two
by
default
controlling
the
event
pipe.
It
is
based
on
a
special
magic
file
under
the
covers,
which
is
an
implementation
detail
into
two,
but
that
is
in
there
and
we
will
get
it
we're
going
to
build
these
sidecar
tools
to
kind
of
build
up
this
ecosystem
of.
How
do
we
make
it
easier
and
sort
of
functional
to
do
this
type
of
metrics
and
diagnostics
on
Dominic,
core
apps,
and
then
the
hope
is
that
by
three?
B
Super
compelling,
you
know
include
like
you,
can
get
your
app
running.
You
can
type
a
command
the
command
line
and
then
it
start
dumping
all
the
counters
in
the
console,
and
you
can
see
the
counters
update
in
real
time
a
little
bit
like
performing
on
Windows
today
or
you
type
a
command
and
then
now
you've
got
like
a
pre-canned
analyzer
profile.
So
you
can
say:
yeah
I've,
gotten
a
spin,
a
core
app
something's
wrong
with
it.
I,
don't
really
know
what
to
look
for.
Can
you
just
start
like
a
trace
session?
B
That's
designed
for
a
spinet
core
we'd
have
one
of
those
built
it'll
capture,
all
the
events
that
we
think
as
the
product
team
are
useful.
If
you
need
to
diagnose
issues
in
a
nice
kinetochore
app
you'll
get
a
net
per
file
and
you'll
be
able
to
run
it
through
a
different
command.
That
says:
can
you
find
any
problems
in
this
net
profile,
assuming
it's
an
agent
correct
and
then
it
could
like
detect
thread,
starvation
or
detect
synchronous
API
calls
when
you
should
be
doing
async
or
detect.
B
You
know,
objects
that
have
been
allocated
too
much
etcetera,
etcetera,
etc,
and
then
we
will
build
up
those
things
based
on
what
we
seen.
Customers
do
and
obviously
we
expect
the
community
would
hopefully
build
those
analyzers
as
well
so
yeah,
that's
kind
of
the
dream
right
is
that
you
be
able
to
bring
in
analyzers,
bring
in
profiles
and
and
and
all
that
type
of
stuff.
But
we
need
to
do
the
bottom-up
effort
of
even
making
the
runtime
support
and
meeting
these
events,
and
so
that's
what
we're
starting
to
and
we'll
continue
in
300
as
well.
B
A
B
B
So
yeah
the
Dante
native
as
a
name
has
kind
of
been
abused.
A
bit
thought
named
native
internally
really
refers
to
the
technology
uwp
use,
but
the
idea
of
an
IOT
net
and
dotnet
that
you
could
compile
more
ahead
of
time
and
a
linker
that
can
take
bits
out
of
your
app
that
doesn't
aren't
used.
That's
also
something
that
we're
looking
at
in
the
three
Oh
time
frame.
Obviously
it's
not
part
of
HP
net,
it's
part
of
dotnet
in
general,
but
that
is
something
that
is.
Can
we
want
to
make
some
progress
on
in
three?
B
Oh,
we're
not
gonna
get
all
the
way
there,
but
I
think
you
probably
will
end
up
seeing
something
I
think
in
the
build
we
talked
about.
This
is
like
the
app
bundler
like
Scott
talked
about.
The
idea
of
I
could
take
my
dummy
Pierre
from
dr.
Corey
run
it
through
the
app
bundler
and
I
get
a
really
small
single
executable
file.
B
B
Yeah,
so
that's
obviously
the
the
torque
on
that
has
kind
of
ramped
up
in
recent
days.
Syrup
is
the
PM
on
my
team
who
owns
Kestrel
in
the
networking
stack,
and
you
know
he
knows
a
lot
more
about
that
than
I.
Do
we
won't
do
anything
in
304?
That
is
my
understanding,
not
anything
tangible.
There
might
be
some
small
things.
We
do
it
sort
of
input
implementation.
Why
is
that
a
lot
of
move
us
further
forward,
but
I
kind
of
I
would
need
to
get
a
longer
term
plan
from
him
on
that.
B
B
Right
I
am
gonna,
go
thanks.
Everyone
Gomes
has
been
down
here,
playing
without
audio
the
whole
time,
so
we'll
see
if
it's
any
better,
this
time,
she's
shaking
her
head,
so
maybe
not,
but
we
will
continue
to
work.
We
will
continue
to
fig.
Maybe
this
machine's
just
cursed.
We
will
figure
it
out
and
we
will
make
this
audio
faked.
One
day
say
thanks
for
bearing
alright
good
to
talk
to
you
done
yep.