►
Description
Community links for this week: https://www.one-tab.com/page/QCG-y0JSS-2UmqqHN_ptzA
B
A
A
D
A
G
I
B
A
L
J
A
G
B
M
A
Awesome,
okay,
so
this
one
looked
pretty
neat:
this
is
on
tier
compilation,
yeah
and
it's
a
preview
for
dotnet
Core
2
1.
So
this
is
talking
about
kind
of
giving
you
the
benefits
of
both
faster
application,
startup
time
and
faster
steady-state
performance,
so
using
a
tiered.
So
this
is
this
is
basically
is
this,
like
a
two-phase?
Can
you're
welcome
to
jump
in
and
say
smarter
things,
yeah.
M
J
A
J
M
A
Awesome
yeah,
so
this
is
how
to
turn
it
on,
and
this
is
these
bars
illustrate
how
things
get
better
when
you
do
that,
a
few
Blazer
things
so
on
kit,
typing
or
okay,
as
opposed
here
on
server
side
Blazers.
So
this
is
understanding
kind
of
the
how
it's
working
on
the
server,
showing
the
signal,
our
communication
and
stuff
like
that.
A
Exciting
Syed,
here's
a
post
on
making
a
shopping
cart
with
blazer,
so
this
is
tying
some
things
together.
I
like
this,
because
a
lot
of
the
kind
of
blazer
things
that
I've
looked
at
so
far
have
been
pretty
much.
You
know
like
just
looking
at
a
front
end.
This
is
tying
some
things
together
with
a
Web
API,
back-end
and
EF.
So
this
is
pretty
cool
here.
Yeah.
H
A
This
includes
all
this.
You
know
that
you
have
stuff
saving,
saving
your
cart
and
all
that
kind
of
stuff.
All
right,
David
pine,
did
an
interview
with
Steve
Sanderson.
So
this
is
this
is
a
question
and
answer
you
know
just
you
know
what
is
it
what's
what's
going
on?
What
do
you?
You
know
some
interesting?
You
know
kind
of
viewpoints
on
it,
so
I.
A
A
This
one,
this
one's
kind
of
neat,
this
is
using
azor
azor
storage
to
host
the
site
and
as
your
functions
to
to
do
some
like
static
site
updates.
So
what's
cool
here.
These
are
all
new
kind
of
things
all
being
kind
of
cooked
together,
as
her
storage
has
just
recently
gotten,
the
ability,
I
think
was
announced
a
bill
to
to
host
static
sites.
So
this
is,
you
know,
because
it's
just
static
files.
This
is
actually
now
does
the
stuff
for
headers
and
everything.
E
H
J
Should
we
serve
be
like
a
high-level
thing,
John
about
like
yes
place,
we
see,
teens
been
working
on
and
doing,
and
that
might
give
some
context
for
some
of
the
demos
that
were
gonna
be
showing
sounds
good,
so
in
the
NB
C
team
obviously
owns
NBC.
So
that
means
the
all
the
embassy
functionality
in
asp.net
core.
That
includes
razor
pages,
which
is
just
built
on
top
of
of
MVC.
A
lot
of
the
team
works
heavily
assembly,
22.
J
J
Building
a
web
api
is
those
those
types
of
scenarios
is
also
handled
by
NBC
in
a
spinet
core,
and
so
this
team
also
handles
a
lot
of
that
functionality
as
well.
So
if
you're
building
like
web
api
is
and
using
for
matters
all
that
is
actually
also
done
by
this
team,
most
recently
like
what
the
team's
been
focused
on
is
when
we
just
ship
to
one
so
we're
working
on
the
next
release,
which
is
to
there's
a
roadmap.
J
That's
already
been
published,
and
so
people
are
busy
working
on
two
features
and
I
think
we
have
some
early
glimpses
if
some
of
some
of
those
things,
but
the
big
focus
in
the
2-2
wave
is
around
services
and,
being
you
know,
cloud
enabled
those
types
of
things
working
well
as
a
as
a
microscope
or
space-based
framework.
A
lot
of
the
features
are
sort
of
in
that
that
vein
and
then
of
our
razor
tooling
investment
also
just
continues
to
get
better.
J
So
so
those
are
roughly
the
the
context
for
the
set
of
features
that
we'll
be
showing
and
then
longer
lead.
You
know
we're
looking
ahead
to
the
Dominic
core
300
timeframe.
So
that's
you
know:
there's
been
a
bunch
of
stuff!
That's
been
talked
about
on
the
like
the
dominant
core
site
about
things
that
we're
doing
in
300
around
supporting
WPF
applications
and
WinForms
applications
on
top
of
Dominic
core,
but
at
the
same
time
that
doesn't
mean
we're
not
going
to
still
do
like
web
and
services
related
features
in
asp.net
core.
J
J
D
J
D
J
J
L
L
M
D
D
But
then
you
see
the
line,
numbers
are
all
drawn
because
it
thinks
okay,
this
is
from
the
background
document
not
really
from
the
C's
HTML.
So
so
that's
the
world
as
it
is
today
things
as
they
currently
are
yeah.
So
what
I
have
here
is
custom
razor
with
custom
rows
name
so
for
to
make
this
happen,
we
need
to
change
that
so
I
already.
D
D
D
D
L
E
So
we've
been
looking
at
what
that
means.
Ruby
is
good
razor,
there's
a
lot
there.
It's
a
totally
different
environment
than
visual
studio.
One
of
the
things
that
makes
final
references
inter
factoring
really
difficult,
which
is
rajab,
is
just
showing
is
that
for
every
razor
fire
we
have
a
c-sharp
file
that
corresponds
to
that
and
every
single
secret
location
in
your
razor
file
that
has
any
sort
of
coloring
or
any
sort
of
completion.
Well,
really
that's
kind
of
going
back
into
this
other
background
file
and
running
stuff.
E
On
that
background,
c-sharp
file,
which
means,
if
we
want
to
find
all
the
references
and
the
entire
project,
we
need
to
parse
every
single
file.
All
these
problems
are
just
exacerbated
in
vs
Koch,
it's
a
totally
different
environment,
but
I
have
some
very
happy
things
working.
It
is
super
prototype,
B
and
you're.
Most
definitely
going
to
see
it
demo
fail
at
some
point
today.
E
So
again,
this
is
just
investigating
not
promising
anything,
just
seeing
what
it
would
mean
if
we
had
something
like
SK
razor,
so
I've
actually
booted
up
an
extension
environment
for
vs
code
right
now,
I
have
some
of
my
code
running
I've
written
a
little
raised
your
language
server
and
one
of
the
things
you
can
see
right
now
is
I
get
some
nice
little
HTML
autocomplete.
So
it's
a
little
contextual
as
well.
E
So
if
I
end
up
writing
a
mix,
a
javascript
tag,
not
only
did
I
get
the
script
tag,
but
I
also
have
Java
serpent
Ellison's,
so
we
have
understanding
of
where
we
are
and
raise.
Your
file.
I
might
drop
the
script
on
my
CSS
and
my
HTML
and
then,
if
I
go
a
little
further
well,
if
I
start
adding
razor
blocks
and
I
invoke
some
Intel's
and
stuff,
this
is
actually
from
C
sharp.
Now
it's
not
very
contextual.
We
typically
see
in
a
razor
file
for
all
the
other
reasons.
E
I
just
said
about
via
scope
being
very
different,
but
it
is
actually
hitting
the
C
sharp
language
server
and
saying
hey.
What's
the
completion
at
this
point,
which
is
pretty
cool,
it
at
least
knows
that
that
lock
is
a
sharp
another
job,
exactly
yeah,
because
I
actually
have
the
window
here.
Is
there
actually
I'm,
not
gonna,
find
this
anyways
yeah
I
have
a
little
thing
wishes,
so
every
single
time
you
do
any
sort
of
action.
E
R
S
E
Yes,
that's
equivalently,
what's
happening
right
now,
so
what
I
can
do
is
if
I
go
here
when
I
paste
this
entire
program
that
CS
into
my
razor
file.
Well,
if
thinks
all
this
is
markup
right
now,
because
I
have
no
out
curly,
brace
but
really
I'm
hacking
things.
It's
duplicated
this
in
my
background,
C
sharp
file,
so
I
can
make
a
nice
little
comment
here
and
I'm
saying.
Well,
you
know
what
in
c-sharp
this
is
gonna,
be
read
as
just
a
comment
but
to
hack
my
to
length.
This
is
actually
C
sharp.
E
So
if
I
go
back
here
and
I
get
no
suggestions,
there's
a
one
demo
fill
there.
Oh
there
we
go
okay.
So
we
get
some
more
contextual,
based
C
truck
completion
working
here
so
again,
total
hockey
we're
seeing
what
it
means.
It's
kind
of
cool
to
kind
of
interoperate
with
all
these
various
language
servers
and
have
a
whole
bunch
of
designs
like
I'm,
starting
to
write
up
a
little
thing
is
what
I
think
a
design
might
look
like
for
this.
E
If
we're,
even
we
even
have
a
chance
of
doing
it
so
kind
of
have
the
idea
of
you
have
a
razor
extension,
which
has
a
razor
document,
and
you
have
like
I
was
saying
a
background:
C
sharp
document
background,
HTML,
1
and
then
based
off
of
what
happens
in
the
docking
and
you
kind
of
dispatch
to
one
of
these
two
guys.
We
have
multiple
language
servers,
we're
talking
to
there's
a
lot
here,
razors
pretty.
E
It's
all
the
right
places,
it's
one
of
those
things
that
there's
a
lot
of
little
nuances,
that
people
don't
understand.
So
when
we
were
first
going
into
dotnet
quarter
razor
and
to
work
really
well,
what
happens
if
we
were
reading
the
file?
Would
that
even
mean
like
if
it
was
not
dot,
c
HTML
but
dot
foo
right?
Well,
we
realized
that
a
lot
of
parts
of
our
stack
actually
depend
on
things
being
called
dot.
Css
HTML,
because
the
idea
of
another
language
being
embedded
inside
of
our
razor
file
is
a
really
special
case.
E
E
E
C
E
So
I
have
this
hold.
What
he's
referring
to
is
John.
He
was
actually
pretty
awesome
and
I'm
using
some
of
his
language
server
bits
to
make
this
razor
a
language,
server,
PC
or
work,
but
they're
not
currently
strong
name
so
I'm
kind
of
jumping
through
a
few
hoops
to
make
it
work,
but
again
we're
just
investigating.
So
it's
okay.
L
A
E
A
T
E
E
I'm
gonna
I'm
gonna
get
everything
fact-check
now,
okay,
so
you
know
what
I'll
do:
I'll
walk
I'll
show
the
completion
provider,
so
this
is
when
you
actually
try
and
vote
any
sort
of
completion
in
my
CC
agent
without
what
actually
happens.
So
this
is
a
vs
code,
abstraction
that
they
provide
this
vs
code
completion
item
provider
and
you
basically
implement
this
method
provide
completion
items.
So
the
first
thing
we
do
is
we
say:
okay,
well,
service
client
to
go
ahead
and
do
a
language
query
based
on
this
position
and
the
document.
E
So
what
that
does
is
it
goes
and
asks
I
raise
your
language
server,
sharpen
my
HTML,
what
the
heck
am
I
and
then
based
off
of
that.
If
we're
C
sharp,
then
we
go
and
we
find
our
projected
C
sharp
document.
Okay,
the
back
the
virtual
teacher
of
document
mentioned
in
this
diagram
this
one
and
then
we
say
well
as
captured
that
and
let's
reax
acute
the
same
exact
command.
We
did
on
that
background
document,
at
which
point
we
consume
the
results.
So
the
background
document
did
the
completion.
E
A
A
B
E
So
this
is
a
verb,
so
I
am
building
the
virtual
document.
Actually,
it's
not
something
that
is
commonly
done
and
vs
code
extensions,
the
idea
of
having
a
document
so
where
to
lock.
It
really
is
just
a
document
that
doesn't
exist
on
disk.
It
has
content
to
it.
It
has
a
language
to
it,
but
it's
not
really
there.
L
G
Part
of
it
was
we
wanted
to
like
focus
on
making
like
better
on
a
client
and
so
like
to
get
better
regeneration
for
the
bike
or
basically
do
projects,
and
so
on
so
forth,
and
one
of
the
aspects
was
like
well,
we
want
to
do
you
to
have
produced
better,
so
I
gotta
start
with,
and
so
what
I
have
here?
Do
you
want
to
switch.
G
B
J
G
G
G
J
Is
because
it
makes
the
the
actions
much
more
descriptive
like
it,
so
what
they
do
like
right,
if
you
didn't
actually
put
a
like
a
from
query
attribute
on
ones
like
that
int
ID
parameter
then
well,
it
could
come
from
the
query
string.
It
could
come
from
right,
Dane
I've
become
who
knows
from
from
where,
whereas
with
the
new
conventions
it's
much
more
descriptive
above
where
they
actually
come
from,
which
helps
with
swagger
top-down
generation.
Yes,
so.
G
G
G
And
it's
basically
just
telling
you
like,
hey,
you
know
like
you're
returning
something
that
you
haven't
documented
so
like
by
default
like
Emmys.
He
assumed
set
like
it
gives
you
a
200
or
201
if
you
haven't
put
his
response
time.
So
basically
it's
a
is
like
hey
you,
probably
returning
like
a
200
from
here
right,
but
then
you
know
there's
something
here
that
says
like
you
returned
to
an
authorized
and
your
own
documented
it.
So
your
swagat
isn't
going
to
look
great,
so
you
should
probably
document
it,
and
so
one
of
the.
G
G
G
G
Right
so
now
you
get
the
photo
one
nice
right
and
this
is
kind
of
nice,
but
the
thing
is
like
you
know,
if
you
should
start
off
with
this,
like
you
know,
you
start
adding
the
package
like
you
now
have
like
a
million
like
warnings
that
say,
let's
go.
Look
at
my
output
window.
It's
like
hey!
You
know.
This
is
just
one
controller
in
this,
like
you
know
a
dozen
of
them.
G
So
the
idea
is
that,
basically,
you
can
associate
an
assembly
with,
like
any
theory
assembly
with
a
set
of
conventions
that
say
like.
Oh
all,
my
actions
are
going
to
look
like
this,
like
they
will
return
a
400
or
404
a
200
or
like
post
actions,
will
do
these
sort
of
things.
And
if
you
go
back
here,
you
notice,
like
all
of
the
like
all
of
the
morning,
spent
away.
A
G
V
J
G
G
It's
a
404
and
then
400,
there's
like
a
bit
of
like
documentation
missing
here
and
like
we're
planning
on
probably
using
like
problem
details
like
in
YouTube
to
say:
hey
like
you
know,
this
is
the
shape
of
like
the
deeper
response
in
the
case
like
this
mirror
response
and
yeah,
and
so
the
idea
aside,
like
you
know,
this
is
just
a
regular
one.
But
what
did
that?
That
convention
type
like
what
was
that
thing?
Yeah.
J
G
Yeah,
so
let's
look
a
look
at
a
get
one:
let's
become
so
yeah
it.
Basically,
you
know
is
a
way
to
sort
of
say,
like
applying.
You
ste
use
some
sort
of
rules
to
figure
out
what
methods
match.
What
like
what
this
method
matches
in
your
controller
action
and
then
like
apply
these
sort
of
response
types
to
it.
So
here,
what's
saying,
is
that,
like
you
know,
any
method
starts
that
starts
with
a
get
so
like
the
name
match
like
prefix,
a
prefix.
Q
C
G
It
matches
a
parameter
that
ends
in
like
the
suffix
IDE
anytime,
like
you
know,
apply
I've
244
to
it,
and
the
thing
is
is
like
you
can
like.
If
you're,
if
you
are,
you
know,
base
these
conventions
based
on
what
it
we
use
with
our
scaffolding
output.
We
said,
like
our
scaffolding,
does
this
so
we're
like
tailoring
like
these
conventions
based
on
that
like
if
you
have
like
a
different
set
of
rules,
say,
for
example,
you
don't
return
404
a
bad
request.
You
were
to
know
for
one
for
2200.
G
And
so,
instead
of
creating
all
your
actual
methods,
but,
like
you
know,
a
set
of
like
five
or
six
that
you
set
this
one
style
like
you
would
have
one
set
of
thing.
So
sorry
go
ahead
and
you
can
still
use
your
producer,
this
one's
type
for
like
things
that
are
unconventional.
So
like
let's
say
you
have
a
search
method
like
this
one
doesn't
like
do,
search
and
you
know,
or
you
have
a
get
method
that
returns
a
201.
You
know
200,
like
you,
can
still
use
producers
as
one
step
on
it.
H
G
M
The
other
way
that
this
helps
you
is
that
one
it
saves
you
typing.
If
you
have
a
set
of
conventions,
for
you
know
what
sort
of
status
codes
and
responses
you
want
to
use
the
other
way
that
it
helps.
You
is
well
if
you
have
a
set
of
conventions
about
what
status
codes
are
using
and
how
you're
using
them
it
helps.
You
know
if
you've
made
a
mistake
or
know
if
you've
got
places
in
your
API,
where
you
deviate
and
these
work
with
these
work.
The
analyzer
works
correctly
with
that
as
well
right,
yeah.
M
A
G
G
G
M
G
Part
of
that
to
to
announcement,
which
was
we're
gonna,
make
it
to
be.
You
know
so.
I
could
client
generation
now
to
the
box,
and
so
you,
basically
you
would
have
the
cat
I
spread
project.
That's
associated
with
your
API
project.
You
could
say,
like
hey,
generate
like
either
reference
to
my
service
reference
to
my
API
project,
engineer,
detective
client
or
a
c-sharp
lion.
It's.
J
U
U
I
I
I
W
I
Here,
as
with
the
bootstrap
for
nice,
that's
the
idea.
We
also
have
an
angular
here,
on
the
other
tab
same
same
general
idea
both
of
these
still
in
progress,
but
we
still
have
some
getting
started
information
here,
but
otherwise
it's
very
similar
we've
got
hamburger
button
which
keeps
trying
to
school
past
to
hide
your
menus.
When
you
get
small
and
yeah,
that's.
I
A
I
A
A
A
J
J
We
haven't
integrated
that
into
the
templates
yet,
but
that's
something
we're
working
with
that
team
on
pretty
pretty
closely
so
that
you
can
have
a
simple
way
of
acquiring
the
client-side
libraries
making
sure
they
end
up
in
the
the
right
place
and
the
dub-dub-dub
root
folder
when
they
need
to
actually
be
served
up
as
static
files
and
having
that
done
seamlessly
without
you
having
to
do
happy
chef,
a
turnkey
solution,
if
you're
not
interested
installing
the
the
node
based
tool
chain
like
the
mm
cam
days
based
tool
chain.
But
of
course.
J
J
Behind,
like
the
plan,
is
still
to
support,
for
example,
scaffolding
and
to
bootstrap
tree
based
applications
and
still
have
that
work
like
like
being
able
to
detect
like
oh
wait.
This
isn't
a
bootstrap
for
app.
Yet,
let's
not
scaffold
in
a
bunch
of
bootstrap
for
based
content
into
your
project
like
you're
setting
up
MVC
views
or
razor
pages,
we'll
still
be
able
to
scaffold
those
things
for
you,
so
that
your
existing
applications,
if
you're
not
quite
ready
to
move
to
bootstrap
for
yet
you
can
still
use
the
tooling
still
be
be
productive.
L
J
A
J
A
J
A
template
pack
on
new
get
with
the
irelia
templates,
which
I
believe
you
can
still
install
and
use.
That's
that's
actually
for
a
lot
of
the
client
side
stuff
because
it
moves
so
fast.
We're
we're
actually
more
moving
more
in
that
direction
where,
instead
of
having
things
sort
of
in
the
box
and
vs
where
they
would,
they
have
a
lot
of
latency
in
terms
of
how
fast
we
can
update
them
to
keep
up
with
the
latest
versions
of
those
frameworks.
J
We're
probably
gonna
actually
move
to
a
more
new
gap
based
model
so
that
they
can
update
faster,
like
as
soon
as
the
angular
sticks
come
out.
We'd
like
to
be
able
to
give
you
guys
the
angular
6
templates
or
English
7
or
bootstrap
10
or
whatever
it
is
having
it
in
the
baked
into
the
SDK.
That
just
means
that
we
can't
update
it
quite
as
quickly
as
we'd
like
to
so.
J
A
And
one
other
thing
to
prevent
you
from
moving
forward
with
the
demo
you're
anxious
to
show
it's
a
so
Martin
asked
if
lipman'
is
already
integrated
into
msbuild
for
new
projects.
That
would
be
awesome.
No
no
vs
needed
I.
Guess
that's!
Well,
there
is
a
set.
There
are
separate
solutions.
People
have
built
global
tools,
I
think
that
yeah.
J
There's
a
CLI
experience
for
live
man,
and
that's
maybe
he's
asking
for
some
more
I
must
build
direct
integration
that
doesn't
require
any
PS
at
all.
I,
don't
know
like
with
that
be
really
a
better
question
for
the
the
live
man.
Folks,
I
don't
have
as
much
visibility
into
into
that
space,
but
yeah
I
mean
let
them
know
like
complete
comment
on
their
their
blog
post.
M
J
J
A
J
A
J
We
shipped
support.
We
did
some
explorations
into
out
of
process
models
for
for
blazer.
If
you
haven't
haven't
been
following
along
with
the
the
Blazer
experimental
project.
What
it
is
is
an
effort
to
try
and
bring
dotnet
web
development
into
the
browser
via
web
assembly.
We
basically
have
a
web
assembly
based
dotnet
runtime
that
we
can
use
to
run
normal
dot
and
assemblies
directly
in
the
the
browser,
so
full
stack
development
with
with.net,
but
we
have
been
interested,
though,
in
these
other
cases
where,
like
today,
blazer
actually
runs
in
the
browser.
J
Out
of
process
models
where
the
blazer
component
model
and
it's
rendering
can
actually
be
done,
someplace
else
and
then
have
the
the
Dom
updates
and
the
UI
interactions
be
handled
over
some
amount
of
process
Channel.
Originally,
this
was
done
because
we
were
thinking
well.
It
might
be
great
to
run
blazer
in
like
a
web
worker
instead
of
having
it
run
directly
on
the
browser
UI
thread,
and
then
we
took
that
mall
and
like
well
this.
J
It
over
a
network
and
actually
you
could
run
blazer
all
the
way
on
the
server
and
handle
all
the
UI
interactions.
Like
a
signal,
our
connection,
so
let
me
let
me
show
you
what
I
mean
like
this.
I
have
two
apps
running
here.
This
first
one
is
a
standard,
blazer
application.
If
we
go,
you
know
it
does
all
the
standard
blazer
things
like
it
can
click
buttons
and
you
can.
It
can
issue
an
HB
request
to
the
server
and
pull
down
some
JSON
data
and
render
it
on
the
screen.
J
Know
it's
it's!
It's
it's
a
little
bit
feet.
You
know,
1.8
megabytes
is
what's
being
pulled
down
from
from
the
server
and
that's
because
well
we're
literally
pulling
down
a
full
dot
at
runtime.
There's,
there's
ma!
No
that
way
as
I'm
right
there,
that
is
the
dot
at
runtime,
implemented
in
web
assembly
and
there's
my
application
assembly
and
all
of
the
dependencies
that
requires,
including,
like
the
PCL,
regulated
libraries.
So
that's
the.
A
J
Thing
about
this
model
is
it's
all
running
on
the
client
and
you
have
full
access
to
the
browser.
You
can
do
offline
scenarios
all
that
stuff,
but
here's
another
version
of
that
app.
This
is
a
server-side
version
of
Blaser,
where
the
the
Blaser
component
model
is
actually
being
executed
on
the
server
and
all
interactions
are
happening
on
the
client.
And
so
let
me
let
me
do
one
trick.
Let.
J
The
download
happens
and
the
donít
runtime
gets
spun
up.
We
go
to
the
server-side
version
of
the
app
first
I
hope.
You
noticed
that
the
the
download
size
is
now
dropped
to
under
100
K,
which
is
that
looks
pretty
good,
and
if
you
refresh
the
application,
you
know
it's,
you
know
it's
just
basically
there
it
refreshes
really
really
quickly,
but
it
still
has
all
the
same
functionality
like
I
click.
The
button
I
can
update
my
counter.
There's.
J
There
I
could
don't
render
the
dynamically
the
table
of
weather,
forecast
data
so
same
functionality,
and
it's
literally
the
same
code
like
the
same
component
implementations
that
we
had
in
the
blazer
application
like
if
we
can
only
look
you're
look
at
your
counter
component.
This
is
the
e
blazer
app
code,
the
capture
component,
and
that
looks
like
a
little
bit
more
for
folks.
That
looks
like
a
normal
component.
Just
got
a
feel
for
managing
the
count
and
then
a
on
click
handler
for
incoming
the
count.
J
If
we
go
to
the
server
side
version
of
that
same
component,
yeah
well,
I
know
big,
surprise,
looks
the
same
I
guess
it's
literally
the
same
codes,
the
same
component
model
just
basically
running
in
a
different
place,
and
so
we
shipped
this
in
zero
five
and
people.
There's
there's
been
quite
a
bit
of
interest.
I
wish
Javier's.
J
J
A
Let's
talk
about
that
just
for
a
second
because,
basically
like
okay,
we
had
razor
pages
already
working
on
the
server
shipping
HTML
down
to
the
client
right
and
then
we're
like
hey
now,
we've
got
blazer
and
we're
running
my
c-sharp
code
and
the
browser
amazing,
and
then
now
it
looks
like
you're
showing
me
we're
moving
that
c-sharp
code
back
up
to
the
server,
but
we
already
had
that.
What's
the
what.
J
J
J
That
wasum
and
having
a
web
assembly
based
on
at
runtime
that's
still
very
much
a
work
in
progress.
Like
there's
a
lot
of
things,
we
could
do
there
on
perf
and
download
size,
optimization,
which
will
happen
and
is
happening,
but
it
may
take
a
little
longer.
So
the
thing
that
we
we've
been
talking
about
internally
is
well,
let
maybe
we
could
actually
move
fast
with
the
server-side
model,
get
that
to
people,
so
they
can
use
it
today
and
in
our
survey
results
we've
been
asking
people
like.
Do
you
want
this
like
with
server-side.
J
A
A
J
Server-Side
I'm
interested
in
that
as
well.
So
that's
what
we're
gonna
do
we're
planning
to
in
Dominic
or
three:
oh
we're
going
to
go
ahead
and
take
this
blazer
server-side
model
that
I'm
showing
you
here
and
we're
going
to
integrate
that
deeply
into
a
spec
core.
So
that
from
like
your
your
razor
page
or
MSE
view
you
can
take
a
blazer
component
and
use
that
within
that
file
within
that,
within
that
viewer
or
page,
you
can
define
components
within
your
a
spinet
core
project.
If
you
want
to
define.
A
J
J
A
J
Components
are
so,
unfortunately
named
so
everyone
who's,
trying
to
use
a
view
component
and
try
to
make
it
into
like
this.
Reusable
piece
of
UI
actually
probably
relates
completely
to
what
I'm
talking
about
with
like
wanting
a
true
UI
composition
model.
Like
view
components,
look
like
and
sound
like
they
do.
What
you
want
them
to
do,
and
then
you
find
out
that
they
don't,
whereas
I
think
a
lot
of
snares
that
people
try
to
use
view
components
for
they're,
they're
gonna,
try
out
Razer
components
and
find
a-ha.
J
The
covers,
or
some
other
assets,
like
the
Razer
components,
enable
that
I
need
a
way
to
have
like
a
prepackaged
piece
of
UI
that
I
can
just
drop
as
a
new
get
packaged
into
an
app
and
just
use
it.
That's
what
raised
your
components
were,
gives
you
and
at
the
same
time,
while
we
work
on
the
Razer
components
feature,
we
will
continue
to
work
on
the
the
blazer
client
side.
Effort
like
that's
not
going
away
and
I
think
the
two
models
are
completely
symmetrical.
J
J
O
J
Now
two
projects
like
there's
the
dot
app
project,
which
is,
has
all
the
components
and
all
the
Blazer
server-side
stuff.
But
then
there
is
also
this
server-side
project
and
that's
just
your
a
spin
at
a
speed
on
a
core
app,
that's
actually
hosting
the
whole
application.
So
the
interesting
things
in
here.
If
you
can
look
in
startup,
so
we're
setting
up.
You
know.
J
Ad
server-side
blazer
is
setting
up
the
server-side
blazer
services
and
then
down
at
the
bottom
use
server-side
blazer,
it's
pointing
at
the
startup
class
for
the
app
project,
and
that's
so
the
the
adding
the
services
is,
first
of
all,
unifying
the
service
providers.
So
the
same
service
provider,
that's
used
in
the
spinet
core,
app
that's
available
to
the
the
blazer
application,
so
they
can
share
services
and
then
down
below
the
used
server-side
blazer.
J
When
we
compile
your
components,
we
compile
it
into
these.
You
know
statements
that
are
have
deep
knowledge
about
the
structure
of
the
HTML,
whereas
normal
razor
files
are
true,
basically
treating
the
HTML
as
strings.
We
need
to
do
a
bunch
of
work
to
make
it
so
that
those
two
compilation
models
can
be
used
within
the
same
project,
which
may
involve
I.
Think
someone
mentioned
like
having
a
different
file
extension
core
for
those
for
those
files.
We
may
involve
doing
that
work
so
that
we
can
enable
those
scenarios
it.
A
Seems
interesting
to
me
to
be
able
to
have
the
flexibility
where
you
can
almost
kind
of
toggle
it
on
and
off,
like
have
the
same.
App
like
I
can
see
a
case
where
I
would
like
to
have
them
as
keep
it
separate.
Even
though
I'm
running
on
the
server
to
be
able
to
say,
like
hey,
allow
running
some
on
the
client
and
someone
that
sometimes
on
the
server
and
that
kind
of
thing.
The.
M
Part
where
that
would
really
help
is
like
at
the
level
of
individual
components
right,
we
said
we
still
care
about
the
clients
model
for
blazer
we're
still
developing
the
client
site
model
still
experimenting
like
you
write
a
component
definition
as
a
reusable
library
or
reusable
package,
and
you
support
both
of
those
models,
and
you
didn't
have
to
do
any
work
to
get
there.
We
brought
you
there
yeah.
J
Y
A
J
No,
that's
how
you
set
it
up
on
the
a
spec
core
project
and
then
the
only
other
difference
in
the
dot
app
project
is
instead
of
be
like
blazer
dot,
webassembly
JJ
s,
JavaScript
bootstrapping
file,
it's
like
blazer
server,
Jas
cou
just
need
to
make
sure
your
code
is
structured
in
a
way
so
that
it
now
runs
on
the
server
liking.
You,
for
example,
you're,
probably
not
gonna,
want
to
issue
HTTP
requests
to
yourself
from
from
that
application
anymore,
you
can
just
access
a
service.
That's
we're
in
these.
J
In
the
DI
container,
for
like
accessing
your
weather,
forecast
say
there
are
things
like
that,
because
it's
literally
running
on
the
server?
So
that's
what
we
wanted
to.
Let
you
guys
know
that's
something
that
we
are
planning
to
move
forward
with,
and
the
client
side
stuff
will
also
continue
to
make
progress.
It's
just
that
one
will
continue
to
be
experimental
for
a
little
while
longer
while
we
make
the
the
runtime.
A
M
A
Repo,
yes,
of
course,
yeah
for
that
and
so
wow.
This
is
great.
Thank
you
again
is
the
whole
MVC
team.
This
is,
this
is
fun
I
personally,
as
I
am
going
out
and
doing
presentations
and
talking
about
MVC
and
talking
about
you
know
just
building
applications
with
asp
net
cora.
I
always
flip
over
to
the
code
and
show
your
commits
as
they're
going
in,
and
it's
really
cool
to
just
you
know.
A
O
A
The
experience
is
productive
and
you
as
well
as
possible.
It's
you
know
it's
a
lot
of
people
in
the
room
and
then
on
the
point,
also
from
the
other
side
of
how
many
people
are
using
MVC
and
how
many
features
you
crank
out.
This
is
an
amazing
thing.
How
much
you
folks
get
done
so
hooray,
big
group,
hugs
and
now
are
you
ready
for
the
dramatic
zoom
out.