►
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).
D
D
B
E
D
F
Cool,
my
name
is
Steve
Sampson
and
I'm.
Yet
another
developer
on
the
SP
net
team
and
blazer
is
my
main
focus
at
the
moment.
The
other
thing
that
I
do
sometimes
is
the
single
page
application
stuff
for
SP
net
course,
or
the
reactant
angular
templates
and
all
of
the
supporting
technology.
For
that
awesome.
C
Okay,
so
before
we
get
too
deep
into
all
the
demos
and
excitement
and
news
and
stuff
from
from
your
team,
let's
run
through
the
community,
stand
up.
Links
and
I
have
a
lot
of
asp
net
stuff
in
general,
including
some
cool,
blazer
content.
At
the
end,
I'm
sharing
my
screen-
hopefully,
okay,
so
starting
starting
here
with
this
one.
This
is
a
cool
post,
so
David
Fowler
did
kind
of
just
a
Twitter
thread
on
here's,
some
cool
like
hidden
gems,
in
an
asp
net
or
2.1
and
there's
a
lot
of
stuff.
C
That's
you
know,
there's
some
big.
You
know
banner
features
that
we
talked
about.
You
know,
and
then
you
know
like
all
kinds
of
stuff,
HTTP
and
and
razer
UI
in
class
library
is
an
identity,
stuff
and
gdpr
and
etcetera
etcetera.
But
then
there's
a
bunch
of
like
cool
stuff
that
if
you
dig
a
little
deeper
is
in
there.
C
So
david
wrote
this
up
in
a
Twitter,
Ted
and
then
Scott,
Hanselman
kind
of
filled
it
out
in
a
blog
post,
so
going
through
generic
host
I,
hosted
service
window
services
on
dotnet,
core,
pretty
cool
configuring
using
eye
hosting
startup
shared
source
packages,
etc.
So
you
can
go
through
and
read
all
this
and
kind
of
it's
it's
nice
to
be
able
to
kind
of
dig
in
a
little
deeper
and
see
and
see
some
of
those
more
advanced
features.
Wow
we
ship
this
stuff,
a.
C
Lot
of
stuff
in
there
yep-
oh
speaking
of
shipping,
stuff,
there's
a
damien
tweeted
about
this.
So
this
is
the
dotnet
Core
2
1
1
early
access
downloads,
so
this
includes
asp
net
core.
So
this
is
a
my
understanding
from
reading
this.
This
is
a
servicing
release.
So
this
is.
This
is
bug
fixes
so
this
this
early
access
is,
if
you
want
to
test
this
pre-release,
it's
it's
and
there's
caveats
and
it's
you
know
stuff.
You've
got
to
do
as
far
as
setting
up
the
new
get
packages
etc.
C
At
the
bottom
of
this,
it
links
over
to
what
is
actually
fixed
in
this
release,
and
so,
for
instance,
here
you
can
see
the
the
list
in
github
all
the
github
issues
for
s
peanut
core
to
one
one
what's
been
fixed
in
there,
so
you
know
about
if
you
want
to
do
an
early
testing
before
before
its
release.
This
is
a
good
way
to
both
see,
what's
in
there
and
also
tested
out
all
right
now
we're
to
a
little
of
the
more
advanced
rocket
surgery,
portions.
C
So,
first
of
all,
andrew
lock
digging
into
a
few
ways
of
suppressing
the
startup
and
shutdown
messages
in
the
console
from
asp
net
core.
So
the
issue
is,
if
you're,
using
structured
logging,
the
startup
and
shutdown
messages
are
not
structured.
So
you
have
these
structured
log
messages
that
work
great
with
your
structured
logging
systems
and
then
the
kind
of
hey
we're
starting
up
that
doesn't
work
for
him.
So
there's
a
few
different
ways
to
control
that
and
kind
of
digs
into
those
a
simple
way
is
using
environment
variables.
C
So
there's
there's
actually
this
asp
net
core
suppress
status
message
then
also
looking
at
ways
ways
you
can
do
it
using
use
setting
and
then
also
in
asp
net
core
to
one
going
in
and
configuring
using
a
hosted
service
so
and
what
I
like
with
all
this
there's
a
lot
of
information
there,
but
then
down
at
the
end
summary
it
kind
of
wraps
up
everything
you
need
to
know
there.
So
obviously
I
think
the
simplest
one
is
setting
it
using
an
environment
variable
potentially,
but
but
you've
got
options.
Maybe
we
should
do
anything.
D
C
Know
it's
the
way
he
writes
it.
It's
just
like.
Well,
this
is
frustrating
here's
how
how
I
can
configure
it.
It
does
seem
like
because
of
that
environment
variable-
that's
relatively
straightforward
to
me
on
reading
this,
that
I
can
that
I
can
change
that,
but
I
don
ously
I,
don't
know
I'm,
that
being
interesting
for
people
on
the
chat
to
respond
to
and
then
Andrea
or
if
you're
you
know,
if
I
change
this
I.
D
Do
notice
that
in
David
and
the
one
of
the
hidden
gems
that
I'm
looking
on
the
enhancements
blog
post
as
there
is
this
oppress,
Status,
Messages
extension
method
off
of
the
the
web
host
builder?
That
sounds
like
at
least
that
does
something
similar
I
don't
know.
So
maybe
we
actually
did
work
for
that
thing
already
in
into
one
might
be
worth
checking
out.
Yep.
C
C
A
E
C
Okay,
cool
on
to
the
next
one.
This
is
from
this
is
from
Philip
and
he's
writing
about
an
interesting
thing
here,
where
he
did
controllers
as
action
filters
in
asp
net
core
NB
c--.
So
the
idea
here
is
he
actually
wiring
two
things
together
he's
using
a
controller
as
an
action
filter.
So
this
seems
like
a
pretty
like
I,
don't
know
of
a
case
where
I've
actually
run
into
where
I've
needed
to
do
this.
C
A
D
C
C
Honestly,
this
one's
relatively
in-depth,
he
does
has
always
have
have
some
good
code
there
you
know
and
and
links
out
to
github
as
well.
So
this
is
cool
because
he's
had
a
lot
of
things
in
the
service
or
is
in
this
series,
where
he's
kind
of
gone
into
into
this.
So
this
is
cool
right,
some
fun
stuff.
Here
we've
looked
at
tech
and
power
benchmarks.
You
know
recently,
the
this
is
they're
actually
released.
Last
time
we
were
looking
at,
they
were
just
about
to
be
released,
so
they
are.
C
This
is
their
blog
post
talking
about
them
being
for
real
released.
So
that's
exciting
the
the
results
pretty
much.
What
we
dug
into
last
last
week
on
the
call
so
I'm
not
going
to
go
into
it
more,
but
but
that's
what
they're
amazing
they're
super
amazing.
C
Here's
here's
an
interesting
thing
that
developed
just
over
last
night,
Ben
Adams
was
tweeting
about
wanting
to
see
F
sharp
on
tech,
empower
as
well
so
long
Twitter
thread
and,
as
a
result,
there's
already
a
pull
request
in.
So
this
is
using
graph,
and
this
is
F
sharp
in
the
tech
empower
benchmarks,
though
very
cool
cool,
to
see
the
community
jumping
into
this,
and
if
people
want
to
continue
to
contribute,
you
know,
here's
your
support
request.
C
C
C
G
D
Click
that
if
you
have
a
project
that
you
think
that
we
should
share
with
the
community
around
blazer,
just
click
that
submit
us
at
PR,
we'll
take
a
look
at
it
and
we're
happy
to
add
stuff
here.
We've
got
I
see
a
bunch
of
folks
on
the
call
actually
that
have
contributed
stuff.
That's
on
this
page
and
we're
happy
to
add
more
so
let
us
know
the
good
work
you're
doing
the
Blazer
cool.
C
So
a
lot
of
good
stuff
on
here.
You
picked
out
some
favorites
here
and
well
and
we'll
point
those
out.
So
this
one
is
blazer
strap.
So
these
are
bootstrap
four
components
for
Blazer.
One
of
the
things
like
I've
done.
Some
presentations
on
Blazers
lately
and
one
of
the
things
I
always
like
to
point
out
to
people
is
that
it
is.
You
know,
people
make
guesses,
I,
think
it's
you
know
like
Silverlight
or
whatever
it
is,
and
it's
I
think
it's
great
to
really
make
sure
people
understand
that
this
is
web
technology.
C
F
So,
just
for
anyone
who's
not
sure
why
I
have
those
two
things
go
together
like
you
can
use
all
the
existing
third-party
stuff,
but
there's
also
a
package
for
it,
though.
The
reason
for
that
is,
you
can
just
pull
in
the
Blazer
cxeh,
sorry,
the
bootstrap,
CSS
files
and
JavaScript
and
just
use
it
directly
if
you
want
to,
but
this
blazer
strap
gives
you
nice
blazer
component
wrappers
around
it,
so
you
get
all
the
intellisense
and
the
normal
idiomatic
blazer
type
ap
is
for
working
with
them.
C
C
Got
it
you
got
it
right,
so
the
next
one
is
blazer
is
I'm
going
to
learn
from
my
lesson
on
the
previous
and
go
straight
to
his
cool
site
here.
So
this
is
maintainable
CSS
with
blazer.
So
you
know
honestly
I
just
learned
about
this
right
before
the
call,
I
guess
yeah.
Here's
we're
doing
this
is
like
a
fluent
interface
for
creating
CSS.
That
sound
right
looks
like.
F
C
It
looks
like
it,
okay,
so
so
so
very
cool
and
then
one
more
here,
some
polyfills.
So
this
includes
polyfills
for
blazer
for
ie11
support
and
some
other
browsers,
I
guess
like
buggy
safari
with
web
assembly,
so
very
cool
and
I.
Don't
oh
and
then
also
here
you
pointed
out
the
xamarin
template
for
launch.
So
explain
this
one
to
me
this
is
xamarin
and
blazer,
and-
and
I'm
not
sure
what
we're
doing
here
well.
D
I,
haven't
I,
haven't
actually
played
around
with
this
one
personally
yet,
but
from
what
I
understand,
this
is
integrating
blazer
into
a
xamarin
application
through
a
effectively
a
webview.
So
you
can
use
the
blazer
program
model
from
within
these
an
or
an
application.
That's
that's!
That's!
Basically
what
I
would
I
get
from
this
one.
So
I
interesting
to
try
out
there's
an.
D
F
B
D
C
Alright
and
the
last
one
here
is
blazer
extensions,
I'm,
not
sure
I,
don't
think
I
pointed
this
out,
actually
I've
had
a
bookmark
for
a
while
and
I.
Don't
think
I've
actually
shared
it
yet
so
these
are.
These
are
additional
extensions,
so
I
think
a
lot
of
these
are
are
these
kind
of
well
you've
got
a
canvas
component,
but
you've
also
got
storage.
I.
C
Think
storage
is
really
interesting
right,
because
you've
got
browser-based,
storage
and
so
being
able
to
take
advantage
of
html5
storage
on
the
client
is
pretty
cool
I've
seen
a
few
different
different
implementations
where
people
have
done
that,
so
these
are
curated.
Here,
though,
yeah
and
signal
are
two
whoa-oh
signaling.
D
I,
don't
think
he's
made
any
progress
on
that
one
yet
because,
because
we
told
them
that
we'll
hold
on
we're
we're
working
on
one
ourselves,
xavier
has
been
actually
been
working
on
a
blazer
signal.
Our
client,
but
most
of
the
repos
in
this
in
this
org
are
JavaScript
Interop
base
based
projects
where
they
take
a
browser,
API
wrap
it
in
a
and
they
Don
a
trapper
so
that
you
can
use
it
from
within
a
blazer
application.
That's
like
the
canvas
and
storage
cases,
the
logging
one.
D
They
took
microsoft,
extensions
logging
and
road,
a
logging
provider
that
works
within
a
blazer
application
and
then
there's
some
component
stuff
in
there
as
well
like
the
last
one
like
blazer
materials,
is
a
exposing
like
a
material
style
of
components
within
within
a
blazer
application,
and
the
idea
there
is
to
just
keep
adding
more
stuff,
it's
sort
of
a
place
where
community
members
can
get
together.
If
you
have
an
interesting
extension,
but
you
want
to
share
with
everyone,
it's
a
nice
convenient
place
to
define
and
discover
those
extensions
and
also
to
share
them
very.
D
If
you
haven't
downloaded
it
yet
installed
it,
you
should
go.
Do
that
don't
update
your
apps,
it
should
be.
It
should
be
fairly
straightforward
update
if
you
have
existing
Blazers
here,
dot
three
applications
there
weren't,
really
any
big
breaking
changes
per
se,
he's
just
updating
the
packages
and
there's
a
bunch
of
new
stuff
in
that
release
that
we're
gonna,
Steve's
gonna
do
a
bunch
of
demos.
There
was
some
I
think
the
biggest
the
biggest
features
that
come
to
mind
or
the
JavaScript
Interop
like
we.
D
We
did
a
bunch
of
a
facelift
on
the
Interop
model
to
make
it
easier
to
go
from
fromthe
on
net
to
javascript,
both
synchronously
and
they
and
for
asynchronous
api's,
and
then
the
javascript
add-on.
That
path
was
pretty
hard
before
it
was
actually
fairly
low-level
api
that
you
had
to
use
in
previous
versions
of
blazer
hobby
I
made
that
almost
trivial
right
happy.
Are
you
just
any.
B
D
You
can
call
synchronous
and
asynchronous
net
methods
from
from
your
javascript
code,
so
that
should
be
fun
to
play
around
with.
If
you've
been
hoping
to
write
some
JavaScript
Interop
libraries
like
stuff
to
contribute
to
that
blazer
extensions
repo.
It
should
be
a
lot
easier
to
do
now
and
there's
still
more
improvements
that
we
expect
to
do
in
that
space.
But
it's
pretty
pretty
good
right
now.
So
that
was
that's
one
of
them.
Another
big
one
was
the
support
for
fleshing
out
our
event,
handling
type
so
that
you
can
get
access
to
the
actual
event.
F
Well,
I'm
sure
they
can
but
into
her.
If
anyone
seems
to
have
a
problem,
all
right
then
so
like
down
just
mentioned,
we've
shipped
laser
point
four
and
there's
a
bunch
of
cool
things
in
there
and
I
want
to
demonstrate
a
couple
of
them
to
you,
but
I'm
not
going
to
show
all
of
the
new
things
that
are
in
point.
Folks.
I
want
to
probably
spend
the
majority
of
the
time
showing
off
some
demos
of
possible
future
things
that
we
have
not
shipped
yet
stuff.
F
So
the
first
thing
I'm
going
to
show
you
is
a
cool
enhancement
that
we
got
from
I,
think
it
was
Robin
Hsu
in
the
blender
community,
the
ability
to
do
binary,
HTTP
requests
and
responses,
and
then
I'm
gonna
show
you
the
work
that
Xavier
did
on
improving
the
JavaScript,
Interop
and
I'm.
Going
to
try
and
tie
those
together
into
one
cool
little
demo,
okay,
so
firstly,
this
thing
about
sending
and
receiving
binary
content.
You
might
be
thinking.
What's
the
point
of
that,
then
I
can
already
send
and
receive
JSON
data.
F
D
Are
people
are
saying
images,
images,
images.
F
Okay,
there's
loads
of
good
reasons
for
it
enough
of
that
I'm
just
gonna
show
you
some
stuff
now
all
right.
So
what
I've
got
is
a
blazer
application
which
is
hosted
on,
as
you
know,
and
it's
going
to
make
a
request
to
the
server
and
at
the
moment
it's
just
going
to
use
traditional
json
serialization
when
it
talks
to
the
server.
So
let's
just
start
that
up
and
I'll
show
you
the
code
behind
there,
so
you
can
get
familiar
with
that
before
I
change
it
to
use
the
new
feature.
Okay.
F
If
I
go
into
this
purchase
page
here,
you
can
see
that
it's
a
normal
blazer
component,
it's
using
some
HTML
a
series
of
divs
there
to
display
each
of
these
form
elements
and
each
of
the
inputs
users
bind
to
associate
self
associate
itself
with
a
property
on
one
of
my
domain
objects
and
I've
got
this
object.
This
class
called
purchase
info
and
I've
set
some
initial
properties
on
there.
F
This
URL
that
I
specified
and
the
data
we
sent
was
JSON
formatted
and
the
response
that
comes
back
from
the
server
is
just
this
plain
string
that
says:
ok,
the
server
did
receive
your
order
and
to
prove
that
we're
just
going
to
repeat
some
of
the
stuff
that
you
send
back
to
us.
Ok,
now
the
server-side
code,
for
that
it's
pretty
simple.
It's
easy
to
receive
JSON
data
in
a
espÃa
application.
F
I've
got
this
order's
controller
with
an
order
action
and
it's
going
to
receive
from
the
body
of
the
request
they
purchase
info
object,
and
so
that
can
be
formatted
in
any
way
that
asp
net
knows
how
to
deserialize
and
json
is,
is
built
in
there
by
default,
and
my
purchase
info
contains
all
of
these
properties.
So
it's
the
same
actual
class
that
I'm
using
on
the
client
and
I've
got
the
shared
project
here
and
if
you
can
see,
I've
got
my
purchase
info
as
a
class
and
shared
there.
F
F
You
got
it
great
all
right,
so
that's
the
traditional
way
of
sending
JSON
data.
Okay,
but
we've
got
dotnet
on
the
client
here
and
we've
got
dotnet
on
the
server.
So
do
we
really
want
to
use
JSON
JavaScript
object,
notation
as
the
communication
layer
between
them?
Jason
obviously
originated
in
the
JavaScript
world,
and
it's
a
very
nice
serialization
format,
it's
very
human,
readable
and
friendly,
but
it's
not
very
efficient
on
the
wire.
F
It
repeats
lots
of
property
names
all
over
the
place
and
it
contains
loads
of
symbols
like
braces
and
colons,
and
things
like
that
that
wouldn't
really
be
needed
in
a
more
low-level
serialization
format.
So
you
might
think,
since
we've
got
dotnet
on
both
client
and
server,
couldn't
we
use
some
kind
of
binary,
serialization
format,
and
the
answer
is
of
course.
Yes,
you
can,
and
there
are
lots
of
different
libraries
that
are
near
binary,
serialization
and
one
of
the
ones
that
people
really
like
is
a
format
called
protocol
buffers
which
was
originally
defined
by
Google,
I.
F
Think
and
there's
a
really
good
implementation
of
protocol
buffers
for
dotnet
called
protobuf
net
and
that's
what
I'm
going
to
use
and,
in
fact,
I've
already
referenced.
This
NuGet
package
called
protobuf
net,
which
was
created
by
mark
gravel,
is
quite
prolific
in
the
darknet
community
and
using
that
I
can
change
how
this
data
is
serialized
on
this
client
and
how
its
deserialized
on
the
server
so
to
use
protobuf.
F
Now
you
go
to
your
dotnet
class
and
you
annotate
it
with
these
extra
attributes,
so
I've
added
proto
contract
and
proto,
a
member
and
stuff
I'm
not
really
going
to
explain
what
that
is.
You
can
go
to
the
protobuf
documentation
if
you
want
to
understand
what
that's
all
about,
but
basically
that's
the
information
I
need
to
give
in
order
to
serialize
this
in
a
nice
binary
way.
So
now,
I've
got
that
I
can
write
some
code
on
the
client
to
serialize.
F
F
Okay,
so
I'm
going
to
recompile
that
now
and
we'll
see
what
happens
on
the
clients
when
I
start
to
try
and
make
that
request
to
the
server.
Let's
see
whether
it
works,
though
I'm
reloading
over
in
the
browser
and
then
I'm
going
to
have
a
look
in
the
network
tab
again
and
we'll
see
what
actually
happens
this
time.
So
when
I
click
on
post
now,
you'll
see
that
we
don't
get
200
okay
anymore,
we
now
got
this
415,
which
is
something
like
media
type,
not
recognized
us
yeah,
unsupported,
Lydia,
tad,
yeah,
acceptable,
okay,
okay,.
C
F
F
Though
that's
the
thing
that
we'll
fix
in
a
minute
all
right,
but
did
the
client
do
its
job
properly?
Firstly,
let's
have
a
look.
What
happened
inside
the
client?
If
we
look
at
what
stuff
got
sent
by
the
client
you'll
see?
Well,
it
was
sent
to
the
orders
endpoint
and
if
we
go
into
params,
it's
not
JSON.
Now,
if
it
was
JSON,
we'd
be
seeing
it
in
JSON
format,
but
it's
not.
You
can
see
that
this
is
some
kind
of
binary
stuff
that
Firefox
doesn't
even
know
how
to
display.
F
Hence
all
these
red
dots,
it
doesn't
really
know.
What's
going
on
it's
just
some
series
of
bytes
and
the
response
from
the
server
is
I.
Don't
know
what
you're
talking
about?
What
are
these
bytes
that
you're
sending
to
me?
Okay,
so
can
we
make
the
server
receive
a
protocol,
buffers
request
and
do
something
useful
with
that?
Well,
obviously
we
can.
So
let
me
show
you
the
easy
very
easy
way
of
doing.
It
is
to
add
a
reference
to
a
new
get
package
called
web
api
contrib
core
formatter
protobuf.
F
And
if
you
do
that,
then
you
can
go
to
your
server-side,
config
and
say
add
proto
before
matters,
and
you
don't
have
to
make
any
changes
to
your
controller
code.
It
just
ties
in
with
how
MVC
deals
with
deserializing
incoming
requests.
So
if
I
reload
now
once
it's
recompile
the
server
and
start
the
application
up,
it
should
behave
a
little
better
this
time.
F
So,
let's
see
if
I
hit
post
again
this
time
instead
of
the
four
one,
five
I
get
a
200
response
from
the
server
now
and
if
we
look
in
the
response
there
you'll
see
the
server
said
yes,
I
did
receive
your
order
for
the
cat,
monocle
and
I
was
able
to
deserialize
it
correctly
just
to
prove
that
it's
not
just
fake
hearted
later,
if
I
change
that
and
make
another
request,
you'll
see
that
this
stuff
I
typed
in
okay
through
that.
So
we
now
are
free
of
the
tyranny
of
JSON.
F
Well,
we've
got
a
server
that
can
receive
jason.
If
it
wants
to
you
see,
I
could
still
send
JSON
to
orders
control
and
it
would
still
receive
it
and
work
correctly,
but
I
can
also
send
protobuf
formatted
requests
to
the
server
for
even
more
efficiency,
and
that
is
thanks
to
the
fact
that
we
can
now
send
and
receive
binary
content
on
the
wire
okay,
I.
F
F
That
would
be
a
fake
demo
and
I.
Don't
do
that
so
I
think
that
would
be
dishonest
if
I,
if
I
had
changed
it
in
some
way.
I've
never
done
that
honestly,
but
no
I
did
not
change
the
package
in
any
way.
For
this
demo,
it
is
literally
out
of
the
box
yeah.
Okay,
so
that's
one
of
the
two
things
I
want
to
show
you.
F
Well,
because
things
happen
asynchronously
and
increasingly
over
time,
browser
api's
are
starting
to
return
promises
rather
than
just
pure
results,
so
in
JavaScript,
world
asynchrony
is
represented
by
promises
and
in
dotnet,
world
asynchrony
is
represented
by
tasks,
but
these
are
almost
equivalent
concepts
and
it's
quite
easy
to
map
from
one
to
the
other.
So
that's
what
we're
doing
if
you
call
a
javascript
method
that
returns
a
promise,
then
the
dotnet
code
receives
that
as
a
task
that
you
can
away
and
vice
versa.
F
If
you
call
dotnet
from
javascript
and
your
net
code
returns
a
task,
then
the
JavaScript
code
gets
a
promise
and
it
can
away
on
that
as
well.
Making
the
interrupt
quite
easy.
So,
let's
give
an
example
of
a
asynchronous
API
that
we
want
to
call.
Let's
say
that
when
I
place
this
purchase
order,
I
want
to
get
some
payment.
Information
from
the
user,
I
want
their
credit
card
details
and
shipping
address
and
such
so
that
I
can
charge
them
for
it.
Now.
F
You
might
not
know
because
a
lot
of
people
don't
know,
but
for
at
least
the
last
six
months
or
so
browsers
have
had
a
native
API
for
collecting
payment
requests
from
users.
So
browsers
can
show
some
native
UI
to
say
to
the
user.
Hey.
This
website
wants
some
money
from
you.
Will
you
give
it
to
them
and
it
lets
the
user
select
from
the
payment
details
that
have
been
stored
on
the
device?
F
F
No,
not
really,
please
don't
do
so
the
code
that
the
JavaScript
code
that
I
want
to
call
to
to
make
this
payment
request
looks
like
the
following
and
it's
a
quite
a
long
block
occurred.
But
trust
me
it's
not
that
difficult.
So
what
I'm
doing
is
I'm
saying:
okay
using
the
normal
blazer
and
drop
ATP
eyes.
I'm
registering
this
function
with
the
ID
request.
Payment
and
I'll
be
able
to
call
that
from.net
code
and
it
takes
a
couple
of
parameters,
product
name
and
total
price
and
then
I'm
going
to
use
the
the
JavaScript
payment
request.
F
Api's
I'll,
say
I'm,
going
to
create
a
new
payment
request
and
I
can
configure
that
in
loads
of
different
ways.
I
can
say
which
methods
it
supports.
What
line
items,
what
tax,
what
grand
total
all
kinds
of
stuff
I
can
use
to
configure
that
but
I'm
not
really
getting
into
that
I'm.
Just
displaying
these
two
items,
the
the
product
that
you
try
to
purchase
in
the
grant,
I'll,
okay
and
when
I've
created
that
payment
request.
F
I
can
then
say,
request
show
and
that
will
return
a
promise
of
type
promise
of
payment
response,
because
it's
asynchronous
the
user
can
spend
any
amount
of
time
that
they
want
to
interacting
with
the
UI
that
comes
up
there
and
when
they
finish
interacting
with
it,
that's
when
the
promise
will
complete
and
so
we're
returning
the
result,
promise
back
to
net
code,
all
right
and
so
I
want
to
receive
this.
The
result
of
that
promise
asynchronously
inside
my
purchase,
blazer
component,
so
to
do
that.
F
Firstly,
I
need
to
import
the
namespace
for
browser
and
truck,
which
is
this
quite
unwieldy,
long
thing
there.
So
the
browser
interrupt
input
and
once
I've
got
that
I
can
say.
Registered
function
got
invoke
yeah,
but
not
just
regular.
Invoke
you'll
see
now
ads
of
point.
Four
we've
also
got
invoke
async,
and
that
is
going
to
return
a
task,
so
I
can
await
on
it
inside
my
darn
net
code
and
in
fact,
the
actual
code
that
I
want
to
call
looks
like
this
I'm
gonna,
say:
I'm
gonna
await
for
the
result
of
this
task.
F
I'm
gonna
call
request
payment.
That's
the
idea:
I
registered
it
with
I'm
gonna,
pass
the
product
name
I'm,
going
to
pass
this
completely
fake
part
price
into
it,
and
that's
going
to
return
a
task
that
I
can
await
and
if
that
will
complete
with
a
payment
details,
object
and
I'm
going
to
put
that
on
to
my
purchase
info
so
that
it
gets
sent
to
the
server
and,
if
you're,
wondering
what
payment
details
class
looks
like
well.
F
Just
by
reading
the
JavaScript
documentation
for
what
stuff
gets
returned
from
a
payment
request
and
blazing
will
deserialize
all
of
that
stuff
into
an
instance
of
payment
details
and
then
I'm
using
protobuf
to
send
that
to
the
server
and
then
my
server-side
code,
which
is
using
the
same
class
library,
will
get
the
payment
details
and
I'll
have
access
to
that
on
the
server.
Alright.
Do
you
believe
me?
Does
it
sound
plausible?
Let's
try
it
out
all
right.
So
now,
in
fact,
I
have
to
do
this
in
Chrome.
F
The
reason
I
have
to
do
it
in
Chrome
is
because
I
think
Firefox
is
the
the
last
browser
to
implement
payment
request
support.
They
have
confirmed
that
they're
working
on
it,
but
they
haven't
done
it
yet,
but
I
think
all
the
other
major
browsers
have
done
it
already
anyway.
So
I'm
going
to
do
it
in
Chrome
and
then
I'm
going
to
show
you
what
happens.
Let's
look
at
the
network
tab,
so
we
can
see
the
requests
going
when
it
does.
F
Okay,
so
I'm
going
to
click
on
this
post
button,
and
so
now
that's
going
to
call
my
JavaScript
function
and
you'll
see
this
native
UI
appears
review
your
payment.
Okay
and
inside
there.
I
can
click
and
get
a
list
of
the
stuff
that
I'm
ordering
I
can
go
in
and
choose
from
the
payment
details
that
I've
stored
in
my
browser
and
then
finally,
I
can
click
on
this
pay
button
and
because
it's
chrome
chrome
chooses
to
ask
for
confirmation
in
the
form
of
this
CVC
number.
F
Other
devices
might
ask
for
a
fingerprint
or
something
like
that
anyway,
I'll
type
in
my
CVC
number
and
when
I
click
on
confirm,
you'll
see
that
the
promise
completed
and
so
immediately
it
is
able
to
make
this
call
to
the
server
and
pass
all
the
information
to
the
server.
So,
let's
check
what
was
in
there,
if
we
look
in
the
what
is
it
if
we
look
down
here
at
the
bottom,
you'll
see
we're
sending
the
same
information
as
before,
but
we're
now
also
sending
all
this
stuff
that
came
back
from
the
payment.
F
F
E
F
F
Ya,
apologist
20
people
are
actually
called
faking
like
that
face
anyway,
so
yeah,
so
the
server
did
get
that
data
and
that's
the
power
of
having
proper
asynchronous
interrupt
between
dot
map
and
JavaScript.
Ok,
so
that's
that
any
thoughts
or
remarks
anyone
wants
to
make
about
that
before
I
move
on
well.
F
Cool
alright.
So
that's
that's
some
stuff
that
we've
implemented
in
the
point
for
release,
but
we
didn't
implement
a
whole
lot
of
new
functionality
in
point
four,
because
what
are
the
biggest
things
that
we
were
focused
on
actually
was
prototype
and
some
potential
major
new
things,
because
splitter
is
in
an
experimental
phase.
We
are
really
interested
in
trying
the
widest
range
of
things
that
we
can
in
order
to
get
the
the
most
interesting
sense
of
all
the
stuff
that
you
could
really
do
with
laser
here.
F
So
we're
interested
in
what
other
application
delivery
models
might
exist
for
a
blazer
application
and
one
of
the
obvious
ones
that
quite
a
lot
of
people
have
asked
is
about
already
is
what
about
electron?
What,
if
I,
want
to
make
a
desktop
a
cross-platform
desktop
application
that
people
can
install
and
use
offline
and
think
of
it
as
just
a
normal
installable
desktop
application,
but
actually
implement
it
with
blazer.
F
So
you
get
to
use
all
of
your
web
programming
skills,
but
you
also
have
access
to
all
the
native
api's
in
your
operating
system,
and
so
we
went
off
and
we
had
a
go
at
doing
that
and
we
needed
a
realistic
application
to
us
act
as
a
test
case.
For
that
we
didn't
want
to
just
do
some
silly
hello
world
thing.
We
wanted
something
that
really
looked
and
felt
like
a
real
application,
so
we
decided
to
use
the
azure
storage
Explorer.
That's
a
real
thing
that
Microsoft
actively
ships.
F
That's
a
desktop
application
that
you
can
install
to
see
everything.
That's
inside
garages,
storage
accounts
such
as
blob
stores
and
things
like
that
and
upload
and
download
stuff
and
generally
work
with
those
accounts.
So
we
took
some
of
the
UI
code
that
they
implemented
for
that
in
CSS
and
we
we
built
an
electron
application
with
blazer.
That
looks
and
feels
quite
similar.
So
let
me
just
start
at
up
and
then
I'll
show
you
some
of
the
code.
That's
inside
there.
C
D
D
B
D
The
the
honestly,
the
the
reaction
to
blazing
so
far
has
been
fantastic,
like
people
have
been
giving
us
lots
of
great
feedback
on
it,
so
things
are
looking
I
would
say,
looking
good
in
terms
of
Blazers
future,
but
there's
still
nothing
committed.
Yeah,
there's
no
committed
timeframe.
People
are
asking
like
when's
the
window,
gonna
ship.
We
don't
have
a
committed
timeframe
for
a1o
at
this
time,
but
as
soon
as
we
know
more
about
the
blazer
roadmap,
we
will
be
happy
to
share
that
with
everyone,
and
you
will
know
the.
C
D
A
D
Yeah
we
we
look
at
all
those
things:
everything
you
with
people
talking
at
meetups,
so
people
you
know
doing
presentations
on
blazer
that
that's
all
helpful
to
make
sure
everyone
knows
that
this
is.
This
should
be
a
thing,
so
we're
we're
optimistic,
but
unfortunately,
nothing
official
to
announce.
At
this
point,
cool.
F
F
F
Okay
right
then,
so
this
has
got
some
of
the
functionality.
That's
in
the
real
storage
Explorer
such
as
I
can
expand
this
tree
and
I
can
look
at
all
the
storage
accounts
and
I
can
look
at
my
blog
containers.
I
can
open
things
in
tabs.
I
can
pin
tab,
so
that's
just
open
a
few
tabs
and
have
them
all
pinned
and
then
I
can
see
the
stuff.
That's
actually
inside
my
storage
accounts
and
then
I
can
do
things
like
an
open
them.
For
example,
this
first
thing
at
the
top.
F
You
can
see
that
say
a
bitmap
image,
and
so,
if
I
click
on
the
Open
button,
what's
that
going
to
do?
Well,
that's
going
to
download
it
and
it's
going
to
open
it
in
the
operating
systems
native
image
editor.
So
that's
not
the
sort
of
thing
that
you
can
do
from
a
normal
browser
application,
but
it's
not,
let's
say
an
electronic
occation
this
one
down
here.
This
is
a
text
file.
F
If
I
right
click
it,
you
can
see,
firstly,
that
I've
got
a
native
operating
system
context
menu
there
and
when
I
click
on
this
open,
that's
going
to
open
in
notepad
kosis
a
text
file,
ok
and
that's
pretty
much
most
of
what
we
implemented.
Ok,
that
we
try
to
make
the
UI
feel
pretty
good
so
that
you'll
notice
that
things
like
the
state
between
the
treeview
on
the
left
and
the
tabs
is
synchronized.
So,
as
I
move
between
tabs
the
I
just
killed
it.
What
I?
Don't?
F
D
That's
a
but
we
were.
We
were
working
on
this
during
0.4
and
it
was
a
a
proof-of-concept
effort
like
an
internal
investigation.
So
that's
like
there
was
no
nothing
released
with
the
blacks
floor
bits
as
part
of
0.4,
but
we've
wanted
to
share
with
you
guys
so
that
you
could
see
what
what
what
stuff
we've
been
working
on.
The
progress
we've
that
we've
made
and
and
how
blazing
really
can
apply
to
a
variety
of
application
models,
not
just
for
in
the
browser
scenarios.
Yeah.
C
A
Think
I
think
to
John's
question
I
think
we
had
hoped
to
find
a
couple
of
those
things
and
I'm
not
sure
I'm,
not
sure
that
we
really
did
I
mean.
Maybe
the
one
thing
that
came
out
of
it
was
we'll
need
to
think
about
what
what
does
it
mean
to
write
a
larger,
a
larger
Blaser
application?
What
would
be
our
guidance
for
how
to
structure
an
application?
Now?
A
Do
you
do
state
management
and
and
what
what
would
be
a
default
story
that
we
would
put
in
the
box,
but
there
weren't
we
were
able
to
build
this
pretty
effectively
with
the
things
we
have
there.
Weren't
too
many
there
weren't
too
many
extra
things.
The
big
the
big
challenge
that
had
to
be
solved
to
get
this
working
was
mostly
related
to
interrupts
than
just.
What
does
the
Interop
story
look
like
in
electron
versus
in
in
the
browser?
Okay,.
C
F
D
F
Go
on
the
SP
net
samples,
repo
you'll,
see
a
small
application
called
flight
finder,
which
has
this
very
simple
state
container,
with
the
c-sharp
events
and
basically,
we've
used
that
same
pattern
but
scaled
it
up
here.
So
I
think
we've
learned
a
little
bit
about
some
of
the
limitations
of
that
and
how
we
might
want
to
expand
that
guidance.
But
it's
kind
of
too
detailed
too
to
really
get
into
that
and
then.
C
F
So
let
me
show
you
some
of
the
code:
that's
inside
there,
so
I'll
go
through
that
ib
quickly,
but
actually
before
I.
Do
that?
One
other
thing
that
we
wanted
to
use
this
as
a
little
test
case
forward
was
around
performance.
So
we
wanted
to
make
sure
that
we
can
make
really
really
big
you
eyes
with
like
vast
and
vast
number
of
new
elements
and
nothing
would
slow
down.
F
So
we've
got
this
infinitely
deep
tree
here
that
you
can
keep
on
expanding
for
as
long
as
you
feel
like
it
and
over
on
the
right
yet
you'll
see,
we've
got
this
grid,
it's
quite
a
big
grin.
It's
got
a
lot
of
items
in
it.
If
I
scroll
down
to
the
bottom
you'll
see
that
I've
got
to
actually
scroll
to
the
bottom.
You'll
see,
we've
got
a
hundred
thousand
rows
in
that
grid.
So
that's
a
virtualized
grid
there's
not
really
any
perceptible
delay
as
we
moving
around.
F
So
that
was
a
good
sort
of
validation,
of
some
of
these,
of
some
of
the
ways
that
this
works
internally,
but
anyway,
onto
looking
at
a
quick
bit
of
code.
So
it
is
a
normal
blazer
application.
I'll
talk
about
how
it
interacts
with
electron
in
a
second,
but
if
I
open
one
of
the
blazer
components
here,
here's
the
app
component
and
yes
John,
as
you
suggested
there
is
blazer
components
all
the
way
down.
So
at
the
top
here,
we've
got
a
few
blazer
components:
reference
vertical
toolbar.
Now
the
panel
tab
panel.
F
If
we
drill
down
into
the
nav
panel
component,
there
you'll
see
that
this
contains
some
of
the
things
that
you've
seen
in
the
UI.
It
says
Explorer
here
at
the
top
and
you'll
see
that's
why
it
says
Explorer
up
here
on
the
top
left
and
then
underneath
there
we've
got
the
search
area.
We've
got
action
links.
F
Then
we've
got
this
nav
tree
below
that
and
if
we
look
inside
an
aviary
you'll
see
nav
tree
basically
just
iterates
over
all
of
the
roots
level
tree
nodes
and
renders
an
Avatara
nerd
and
if
I
drill
down
again
in
turn
a
Vettori
node
that
contains
loads
of
markup.
That's
way
too
boring
to
read
and
explain,
but
one
bit
about
it
that
is
worth
looking
at.
F
Is
it's
a
recursive
component,
so
each
Navarino
iterates
over
its
own
children
and
renders
more
nav
tree
nodes
and
that's
how
we
get
this
recursive
tree
of
navitor
e
nodes,
all
the
way
down
that
I
sense
yep,
excellent,
all
right
cool!
So,
let's
let
me
just
quickly
cover
how
we're
doing
the
inter
up
here
between
dotnet
and
electron.
F
So
the
obvious
way
to
run
a
blazer
application
under
electron
would
be
literally
just
to
take
a
normal
browser-based,
blazer
application
and
just
run
it
in
electron,
because
electron
is
a
chromium
frame,
so
we
come
run
webassembly
and
we
could
just
run
blazer
under
webassembly
inside
electron.
That
would
work
absolutely
fine,
but
we
wanted
to
try
a
slightly
more
ambitious
approach
of
not
doing
that
and
if
I'm
not
using
webassembly
at
all,
but
rather
running
net
natively
under
the
normal
net
core
runtime
and
having
that,
inter
up
with
the
electron
shell.
F
So
if
you
look
at
what
type
of
project
this
thing
is,
you
will
see
that
it
is
a
console
application,
which
is
why,
when
I
started
the
thing
up,
this
console
showed
up
and
from
there
it
launched
electron.
So
it
is
a
normal
dotnet
core
console
application
where
all
your
blazed
occurred
is
running
under
regular
core
CLR,
not
under
webOS.
Only
and
it's
interacting
with
electron
shell.
That's.
F
F
It
runs
much
much
faster
and
it
means
you
get
full
visual
studio,
debugger
support
straight
away,
and
it
also
means
that
you
can
use
literally
any
NuGet
package
without
any
restriction
at
all,
because
you
know
it's
just
a
normal
net
core
console
application,
and
yet
you
can
still
do
all
the
stuff
that
blazer
does
and
you
can
do
all
the
stuff
that
dotnet
core
does
when
it's
running
as
a
console
application.
Okay,
Wow.
F
Alright,
so
we're
not
making
public
the
actual
blacks,
pleura
application,
because
that
contains
quite
a
lot
of
stuff,
that's
specific
to
well
things
that
you
don't
want
to
get
into,
and
we
don't
necessarily
is
enough
permission
to
redistribute.
But
we
know
that
some
people
will
want
to
try
this.
So
what
we
did
is
earlier
today,
I
published
this
git
repo
yeah,
a
blazer
electron
experiment
sample,
and
you
can
try
that
out
yourself
if
you
want
to,
and
that
contains
a
blazer
application
that
runs
in
electron,
using
the
same
architecture
that
I
just
showed
you.
F
So
it's
running
the
dotnet
code
under
normal
core
CLR
and
it's
doing
the
interrupt
to
the
electron
shell.
So
if
you
closed
and
that
Reaper
you'll
get
this
project
here
and
if
I
start
that
up
and
it
compiles
correctly-
which
it
does
not,
this
is
pretty
frustrating
I
have
to
keep
firm.
It's
because
I've
got
more
than
one
version
of
the
of
the
got
Maps
SDK
on
my
machine
and
Visual
Studio
gets
associated
with
a
specific
one,
and
then
it
does
not
like
it.
When
I'm
switching
from
one.
D
B
F
Go
alright
so
now
it's
building
and
I
controller
five.
You
can
see
that
we've
got
the
normal
blazer
project
template,
but
now
it's
inside
the
electron
shell,
it's
still
got
routing
support.
It
all
works
the
same
as
before,
and
if
you've
seen
a
blazer
application
before
you'll
be
familiar
with
how
that's
put
together
but
there's
a
couple
of
differences.
One
is
when
we're
fetching
this
data
for
the
weather
forecasts.
Normally
in
the
browser.
We
do
that
using
an
HTTP
request,
but
because
this
runs
as
a
native
desktop
application,
we
don't
need
to
use
HTTP.
F
We
can
use
file
IO,
just
normal
dot
map
API
for
interacting
with
the
local
machine.
So
in
some
ways
that's
really
cool
and
simplifies
things
a
lot,
and
the
other
thing
that's
worth
pointing
out
is
that
you
have
access
to
all
of
the
electron
donor.
Ap
is
one
of
the
tools
that
we
use
to
link
electron
and
blazer
together.
Is
this
open
source
project
called
electron
dot
net
and
that
provides
a
lot
of
api's
on
the
electron
static
object
there?
F
So
I
can
go
and
I
can
call
all
these
different
things
on
electron
that
app
in
order
to
change
what
stuff
gets
displayed
in
the
doc
or
to
change
the
jump
list
in
the
operating
system.
Things
like
that
also
have
got
access
to
you.
The
operating
system,
clipboard
and
I
can
show
dialogs
and
I
can
use.
Shell
commands
all
that
kind
of
stuff,
so
you've
really
got
access
to
everything
that
the
electron
that
can
do
directly
from
your
donate
code
in
a
really
convenient
way.
Okay.
F
So
if
that's
of
interest
to
you,
please
go
and
clone
that
repo
and
get
up
and
try
it
out
and
tell
us
what
you're
thinking
of
that
sort
of
thing,
but
I'll
just
caution:
you
we're
not
supporting
any
of
that
at
this
stage,
that's
purely
at
a
group
of
concepts,
I
think
if
you
to
experiment
with
I,
wouldn't
recommend
building
a
production
application
on
it
just
yet
make
sense.
So.
C
C
F
Very
cool,
alright
and
so
last
was
dude
all
right.
So
that's
that's
a
bit
of
a
future
idea.
Now.
I
want
to
give
you
idea
for
another
future
idea
that
we're
not
at
all
sure
whether
we
want
to
do
yet.
But
you
know
it's
experimental
and
we're
trying
out
some
cool
new
diet,
ideas
and
seeing
what
we
can
do.
F
You
could
have
your
dotnet
code
running
not
on
the
browser
and
a
web
assembly,
but
on
the
server
under
normal
core
CLR
as
part
of
your
web
server,
and
then
it
could
use
a
WebSocket
connection
to
the
client
to
send
the
UI
updates
into
the
browser.
So
the
user
would
have
the
same
experience
in
the
browser
but
the,
but
the
code
would
not
have
to
be
in
the
browser.
The
code
would
be
on
the
server
okay.
F
D
F
F
F
C
C
F
F
In
any
case,
regardless
of
whether
the
execution
is
client
or
server
but
yeah,
there
are
a
whole
bunch
of
pros
and
cons
and
I'll
explain
those
in
a
second
but
I.
Just
let
me
just
show
you
this
thing
running
so,
as
you
can
see,
I've
done
it
for
the
Explorer
application
as
well,
and
when
I
start
clicking
on
things,
you'll
see
it
still
works
the
same
as
before.
I've
got
all
the
same
functionality.
I've
got
my
giant
grid
and
everything
like
that.
F
It
all
works
the
same,
but
what's
different
about
it
now
is
that
all
of
the
dotnet
code
is
on
the
browser
I'm
not
having
to
send
it
down
to
the
sorry
all
the
dotnet
codes
on
the
server
I
don't
have
to
send
it
to
the
browser.
So
when
I
click,
this
reload
button
watch
how
quickly
the
application
starts
up.
F
That's
probably
like
more
than
150
kilobytes
or
something
so
I'd
say
that,
with
a
bit
of
optimisation,
we
could
easily
get
this
application
down
to
less
than
100
kilobytes,
probably
about
50,
kilobytes
or
something
so
it'd
be
incredibly
lightweight
and
starts
up
incredibly
quickly,
and
the
user
does
not
need
does
not
need
to
be
running
the
the
application
locally.
It's
all
running
on
the
server
and
we're
streaming
stuff,
cuz
you're
actually
streaming
the
updates.
F
Let's
have
a
look
at
the
list
of
WebSocket
connections
if
I
reload
you'll
see
there's
a
connection
called
underscore
blazer
and
inside
there.
If
we
look
at
the
list
of
frames
that
have
been
sent
every
time,
I
click
on
something
in
the
UI
you'll
see
it
sends
this
invocation
to
the
server
that
says.
What's
just
happened
and
in
this
case
it's
a
mouse
event.
That's
just
occurred,
a
click
in
fact,
and
we
we
know
exactly
what's
been
clicked
on
and
then
the
response
from
the
server
is
these
binary
frames
and
I
can't
visualize
those.
F
But
it's
a
very
compact
representation
of
how
the
UI
needs
to
update
it.
That's
what
blazing
normally
does
when
it's
running
under
webassembly
in
order
to
tell
javascript
how
to
update,
and
so
it's
doing
the
same
thing
now.
It's
just
that
it's
serializing
those
updates
of
the
WebSocket
connection.
Okay,
so
that's
just
the
flexibility,
the
architecture
that
we've
got.
F
We
can
run
the
application
in
all
these
different
ways
and
if
we
wanted
to
summarize
some
of
the
pros
and
cons
of
the
different
approaches,
if
you're
running
on
the
client,
that's
in
some
ways,
ultimately
the
ideal
situation,
because
ultimately,
that's
going
to
give
you
the
fastest
possible
UI
by
the
time
it's
loaded.
So
every
time
the
user
clicks
on
something
you're
always
going
to
get
an
instant
response,
because
the
application
is
running
locally.
There's
going
to
be
zero
latency
in
updating
the
display.
F
Also,
if
you're
running
on
the
client
under
webassembly,
your
application
can
work
offline,
which
is
important
for
progressive
web
applications
or
places
where
the
user
has
got
intermittent
network
connectivity.
The
other
benefit
of
client-side
execution
is
that
you,
the
developer,
are
not
paying
for
the
application
to
actually
execute
so
because
all
your
server
is
serving
is
static.
Files
in
the
client
brings
their
own
processing
power
to
execute
the
application,
so
it's
very,
very
cheap
to
Hearst,
whereas
there
are
some
big
benefits
to
running
the
darknet
on
the
server
as
well,
such
as
the
application.
F
Startup
is
going
to
be
incredibly
fast
and
you
only
need
to
send
a
tiny
amount
of
data
to
the
client
in
order
to
get
it
to
start
up
and
because
you're
running
on
core
CLR
on
the
server
you've
got
access
to
everything
that
dotnet
core
can
ever
do,
such
as
all
the
vs
debugging
support
and
all
the
new
get
packages.
Another
thing
that's
really
interesting
about
the
server
execution
model
is
that
whenever
you
want
to
do
data
access,
there's
no
need
to
be
creating
Web
API
endpoints.
F
You
can
just
directly
interact
with
your
database
or
file
system
or
anything
you
want
from
your
dotnet
curve,
because
it's
not
inside
the
the
client
it's
on
the
server,
so
you
can
do
whatever
would
normally
do
in
server-side
netcode
without
having
to
go
through
additional
API
endpoints.
So
I'm
really
interested
to
know
what
people
think
about
this.
We
are,
we
don't
intend
either
one
of
these
to
be
a
replacement
for
the
other.
F
I
think
that
there
are
probably
good
uses
cases
for
either,
but
I
would
be
really
interested
in
which
people
feel
is
the
best
fit
for
their
particular
application
scenarios,
and
don't
tell
us
you're
interested
in
both.
That's
not
very
useful
to
us.
Tell
us
which
specific
one,
you
think
is
the
one
that
you
would
choose
for
the
specific
applications
that
you
would
like
to
build.
Please
in.
F
F
On
YouTube
yeah,
it
told
us
in
any
way
they
like
we're
not
trying
to
conduct
a
formal
poll
yeah.
But
the
whole
point
of
this
experimental
phase
is
to
for
us
to
try
out
some
of
the
wildest
ideas
we've
got
about
how
stuff
can
work
and
for
the
community
to
be
able
to
tell
us
what
we
should
actually
do.
F
A
C
Very
interesting
I
mean,
of
course,
the
one
thing
you
said.
That
is
not
helpful,
but
I.
Think
of
like
maybe
a
blazer.
You
know
maybe
it's
blazer,
200
or
whatever,
but
it's
a
thing
where
you
have.
The
flexibility
of
I've
got
a
server
model
and
then
I,
you
know,
click
here
to
to
do
whatever
and
then
or
click
here
to
install.
You
know
the
electron
base,
one
you
know
like
having
that
kind
of
flexibility.
It
would
be
amazing.
You.
F
C
What
I
mean
like
basically
install
local
version
Wow?
So
there
was
a
question
somebody
was
concerned
about
latency
for
the
server
side,
but
I
think
what
you
were
showing
there
is,
because
there
are
those
tiny
binary
out
codes
that
you're
not
really
it's.
It's
a
tiny
amount
that
you're
transmitting
back
and
forth
right,
yeah.
F
That's
right,
yeah
and
it
latency
is
a
huge
concern
for
that
for
the
server
side
model,
and
so
in
order
to
try
that
out,
we
had
to
go
at
deploying
this
application
to
a
few
different
Azure
data
centers
around
the
world,
and
we
went
to
them.
You
know
to
see
what
was
going
to
work
well
and
what
wasn't
and
what
I
think
most
of
those
agreed
on
was
that
if
the
data
center
was
you
know
within
like
a
thousand
miles
of
you,
then
the
responsiveness
was
really
good.
F
Assuming
you
had
a
an
acceptable
network
connection,
then
you
couldn't
really
tell
that
it
wasn't
executing.
Luckily,
those
diffs
are
tend
to
be
under
one
kilobyte.
You
know
it's
usually
going
to
fit
within
one
tcp
frame,
so
yeah,
it's
just
limited
by
speed
of
light,
and
it's
really
hard
to
make
that
any
faster
we've
tried,
but
you
know,
there's
some
fairly
fundamental
physics
that
we
haven't
been
able
to
overcome
yeah
on
that,
but
basically
yeah.
If
the
data
centers
really
is
close
enough,
then
it
tends
to
work
really
well.
F
I
also
tried
deploying
two
data
centers,
that
sort
of
diametrically
opposite
on
the
planet
and
the
like
was
noticeable
yeah.
So
I
was
getting
about
sort
of
half
a
cent
second
of
lag
between
clicking
and
seeing
things
up
day,
which
is
not
a
super
user
experience.
So
you
might
want
to
look
at
some
sort
of
you
know:
geographical
distribution
of
your
application.
If
you've
really
got
a
truly
global
reach
for
your
app.
D
F
C
Yeah,
as
far
as
then
collecting
feedback
and
all
that
kind
of
stuff,
there's
this
general
kind
of
questions
and
people
can,
you
know,
can
get
in
touch.
You
know
on
the
on
the
video
or
you
know,
I
guess
on
Twitter
or
things
but
probably,
but
if
people
have
questions
feedback
they
can
also
log
issues
just
on
the
blazer
repo.
Is
that
a
good
spot
totally.
F
C
There
was
one
thing
that
was
a
little
bit
interesting.
Somebody
was
asking
for
a
view
style,
you
know
like
a
razor
operation,
so
like
V
for
or
things
like
that
and
I
guess.
Some
of
that
is
just
is,
is
a
little
bit
razor
specific,
but
are
there
things
that
you've
looked
at
as
far
as
kind
of
change?
You
know
like
razor
specific
things
for
the
component
model
or
for
bringing
in
some
logic
and
looping
and
things
I.
A
Know
so
I'll
speak
up
on
that,
so
regarding
specifically
the
four
and
F
the
sort
of
thought
there,
or
at
least
the
thinking
amongst
the
razor
team
there
is.
We
wouldn't
do
something
like
that
lightly,
because
it
really
changes
the
experience
for
everybody.
We
would
only
do
something
like
that
if
we're
going
to
tell
everyone
to
use
it
in
every
scenario,
because
it
sort
of
changes
how
the
language
is
defined
right
now,
we're
in
this
weird
place
with
razor,
where
we're
trying
to
catch
the
tooling
up
to
what
you're
able
to
do
with
the
runtime.
A
So
it's
kind
of
big
big
sort
of
foundational
things
like
that
are
as
far
as
language
support
are
not
really
on
our
radar
at
this
point,
I
think
when
the
tooling
we're
actively
investing
in
the
tooling
and
that's
an
ongoing
effort
and
we're
hoping
that
in
a
year
or
so,
the
landscape
is
different
there,
but
it's
kind
of
not
a
it's.
It's
kind
of
not
a
big
consideration
for
us,
so
something
we
would
do
in
like
the
next
couple
weeks,
if
you're
in
Razer,
you
can
build
that
sort
of
thing
yourself
as
tag
elder.
A
This
point,
which
is
right
now,
we've
been
sort
of
thinking
about
app
bottles
and
what
what
is
a
blazer
application,
look
like
what
are
all
the
things
that
are
possible.
So
that's
a
long-winded,
that's
a
long-winded
explanation!
If
you
like,
the
idea
tell
us
why
you
like
the
idea
we
get
a
lot
of
people
proposing
just
alternatives
to
things.
We
want
to
know
why
you
think
it's
important.
What
problems
does
it
solve
for
you
that
you,
those.
C
So
in
the
flight
finder
you
have
the
gray
out
region
and
then
also
I,
believe
you
have
some
kind
of
transition,
sort
of
animations
or
things
where
things
can
kind
of
fade
in
or
out
or
that
kind
of
thing
have.
You
looked
at
anything
as
far
as
I.
Don't
know
component
wise,
like
transition
things,
or
is
that
where
you
just
basically
say
go
use,
you
know
whatever
libraries
are
already
available
in
JavaScript.
Yes,.
F
At
the
moment,
we
don't
have
anything
built-in
that
does
anything
magic
for
you,
so
you're
kind
of
limited
to
wherever
you
can
do
with
CSS
right
now
and
so
with
CSS.
You
can
quite
easily
do
things
like
hover
effects
and
highlight
stuff
instantly
when
it
becomes
clicked
on
without
having
to
wait
for
any
further
round-trips,
and
then
you
can
just
use
normal
CSS
transitions
if
you
want
to,
but
it's
a
bit
manual.
F
My
general
expectation
about
where
this
goes
is
that
we
would
probably
take
inspiration
from
some
of
the
other
spar
frameworks
which
have
got
things
like
animatable,
repeater
components
and
the
repeater
is
a
sort
of
low-level
thing
that
you
can
build
other
stuff
on
top
of,
like
grids
and
other
higher
level.
Things
like
that
with
animations.
F
C
C
Yeah
but
I
guess
we
have
to
let
you
go
and
get
back
to
actually
building
blazer,
so
I
I
mean
there's
some
great
kind
of
any
other
big
questions.
Jumping
out
at
people,
I
guess
somebody's
asking
about
data
templating
is
also
something
interesting
is
that
is
that
something.
A
C
D
We
don't
get
folks
questions
answers
for
folks
and
in
this
time,
do
come
and
join
us
on
the
the
blazer
getter
like
there's,
actually
a
fairly
active
community
of
folks
there
that
are
chatting
about
blaze
there
pretty
much
non-stop
24
hours
a
day.
We
try
to
be
on
there
fairly
fairly
regularly,
so
feel
free
to
ask
your
questions
in
that
forum
as
well,
and
we'll
help
you
out
and
happy
to
discuss
anything
blaze
are
related
there
right.