►
Description
Community links for this week: https://www.one-tab.com/page/QS1nEXIhSdKwqhauVItHJQ
A
A
You
very
much-
and
our
hope
is
that
this
week
this
will
be
the
best
technical
show
in
terms
of
production
and
no
gremlins
and
audio
and
switching
and
all
the
things
that
we've
ever
done.
I
spent
an
hour
in
this
room
earlier
today,
I
put
a
little
bits
of
tape
here
without
numbers
on
them,
so
everyone's
in
sitting
in
the
right
spot,
we've
got
a
new
screen
set
up
here,
so
we
can
see
our
guests
and
they
can
see
us.
Can
you
say
hello,
John
I
can
see
hello.
A
Their
levels
are
good.
The
one
thing
I
found
with
you
I've
just
realized.
Oh
no
I
have
the
chat
open
here,
so
I
can
talk
to
people
as
well,
so
it
doesn't
like.
People
can
see
us
as
well,
which
is
good,
well
looks.
Why
are
we
here
today?
Why
do
I?
Have
these
fine
gentlemen
on
my
left?
It's
because,
oh
and
of
course
it's
Steve
saari
on
the
on
the
road
that
way
create
it
right
next
week.
C
E
B
F
F
E
D
Ok,
so
this
is
a
short
small
collection
of
just
Blazer
links
for
this
week.
I
have
some
other
ones,
but
this
is
blazer
specific
this
week,
so
one
thing
I
looked
at
was
it's
kind
of
cool
people
are
kind
of
lighting
up
different
things
that
have
been
in
the
dotnet
ecosystem
and
lighting
the
upon
blazer.
So
this
one's
an
interesting
just
Sarah
log.
You
know:
we've
seen
this
in
asp
net
core
for
a
while
and
here
lighting
up
in
laser.
D
So
the
idea
is,
like
you
know,
I'm
having
structured
data
in
your
browser
console
so
I
thought
that
was
kind
of
cool.
So
this
repo
here
log
syncs
browser
console
next
one
here.
This
one
is
cool,
so
my
hair
has
set
up.
He
needed
to
do
medical
imaging
and
you
wanted
to
do
it
on
the
client
side,
which
is
pretty
cool.
So
there's
this
DICOM
format
and
rather
than
kind
of
try
and
write
something
new
hey.
We.
C
D
D
Yep
so
yeah,
and
we
featured
him
a
lot
over
over
time
on
the
stand
up
so
yeah.
So
here
he
say
he
grabbed
a
new
get
package
and
I
think
this
is
a
really
cool
like
a
powerful
thing.
People
are
looking
at.
You
know,
what's
what
are
some
advantages
of
blazer
and
definitely
being
able
to
use
existing
NuGet
packages
that
you
know
work
and
run
that
code
on
the
client?
D
It's
really
pretty
slick,
so
here
he's
pulled
in
a
package
that
does
that
does
DICOM
package
or
parsing
so
I
believe
it's
faux
DICOM
drawing
library,
and
so
this
is
pretty
like
lightweight
I.
Would
imagine
you'd
want
to
do
something,
maybe
more
in-depth
for
something
like
you
know,
I'm
is
he
here
he's
just
basically
creating
a
bitmap
and
rendering
the
bitmap
and
you
could
add
on
more
stuff.
D
D
Alright.
So
here
are
two
cool
ones
from
sorrow,
Southall.
This
one
is
looking
at
using
Cassandra
API
in
cosmos,
DB,
so
cosmos,
DB
upcoming,
there's
support
for
this
using
EF
core.
But
what
he's
using
here
is
another
the
the
data
stacks
implementation
of
the
Cassandra
API
and
pointing
at
cosmos
DB
using
that
so
in
this
walkthrough
he
goes
to
creates
a
cosmos,
DB
front-end
then
he's
going
to
grab
a
new
get
package
so
grabbing
the
Cassandra
c-sharp
driver.
C
D
D
So
this
is
pretty
slick
and
so
I'm
guaranteed
when
you
like,
I'll,
read
something
wrong
but
but
I.
So
you
know
sharp
eyes
here
and
tell
me
what
would
I
mispronounce
or
whatever,
but
the
general
idea
I
believe
is
all
the
localization
is
actually
being
pushed
down
to
the
client.
So
we
have
the
the
res
x
files.
We
have
resources
pushed
down
to
the
client
and
then
using
the
Microsoft
J's
Interop
in
a
bit
here,
there's
some
some
clever
stuff,
where
it's
actually
invoking
and
calling
into
that.
A
Specific
just
to
clarify
a
thing
from
what
I
can
see
going
by
they're
using
the
mayor's
interrupts
in
order
to
get
the
low-cal
or
the
language
yes
or
the
culture
depends
on
which
one
via
the
JavaScript
cuz.
Obviously
you
have
that
stuff
set
in
your
browser,
so
the
JavaScript
can
there
are
API
is
a
you
can
call.
A
It
says:
hey
I'm,
looking
at
this
page
and
my
browser
is
set
to
English
or
Japanese
or
whatever
so
I'm,
assuming
they're
doing
that,
and
then
downloading
just
the
resources
they
need
from
the
server
I'd
hope,
or
maybe
they
can't
yet.
But
this
is
a
prototype
and
then
they'll
use
the
language
they've
determined
from
JavaScript
in
order
to
figure
out
which
resource
to
load
using
the
normal
dotnet
api's.
Are
they
using
resource
manager
or
are
they
using
are
doing
it
manually?
I.
D
F
A
A
Right
absolutely
and
then
I
think
I'm,
assuming
that
the
web,
the
requests
that
you
were
talking
about,
John
is
a.
They
probably
have
a
controller
set
up
that
the
blazer
app
can
use
to
ask
for
resources
for
the
current
language,
and
so
they
would
pass
the
language
up
to
the
server
say:
hey
I
need
the
French
resources,
please
for
this
page
or
this
resource,
and
it
would
then
send
it
down
and
then
it
would
do
the
client-side
swap
using
the
blaze
of
stuff.
A
D
Yeah
I'll
send
the
links
over
there,
so
there's
a
decent
amount
of
code
here
so,
but
this
is
really
neat
to
be
able
to
see
it,
and
so
two
nice
ones
from
Sarah
thought
keep
an
eye
out
from
work
from
him.
This
is
just
a
general
web
assembly
when
I
saw
it
come
by.
So
this
is
from
Lin
at
Mozilla
and
talking
about
calls
between
JavaScript
and
web
assembly
are
finally
fast
and
some
work
on
streamlining
Interop
between
the
two.
So
I
don't
know
how
this
relates
to
other
browsers.
I,
don't
really
know.
D
C
D
F
It's
good
because
it's
setting
the
benchmark
as
much
as
any
browser
pushes
ahead
to
the
others
that
gives
the
rest
of
them
a
reason
to
try
and
catch
up
and
Firefox
has
definitely
been
the
fastest
running
web
assembly
so
far
and
looks
like
they're
pushing
even
further
ahead
with
this,
but
that's
great
because
that
forces
Google
and
Microsoft
to
try
Auto
catch-up
and
use
some
of
the
same
techniques
to
close
that
performance
gap.
So.
A
D
D
A
B
A
D
D
D
C
B
A
A
C
That
mean
that
means
that
you
can
define
components
that
take
one
or
more
template
parameters
to
use
as
part
of
his
rendering
logic
and
those
template
parameters
can
basically
capture
a
chunk
of
Razer
logic
and
then
use
that,
within
the
the
components
render
method
those.
Those
templates
can
also
be
parametrized
like
you
can
take
a
take
an.
C
Use
as
part
of
part
of
their
logic,
and
they
can
now
also
be
generic.
So
if
you
wanted
to
find
a
generic
list
view
of
T
components
that
takes
a
collection
of
pets
or
whatever
and
render
them
as
a
list
of
bets
on
the
as
part
of
your
UI,
you
can
now
do
that
through
through
temporary
components
where
the
user
gets
to
specify
how
they
want
each
pet
in
that
list
to
be
rendered.
It's.
C
So
we
also
expanded
our
support
for
a
server-side
blazer.
This
is
the
model
where
you
can
take
your
components
and
instead
of
running
them
in
the
browser
on
top
of
web
assembly,
you
can
now
also,
alternatively,
run
them
on
the
server
on
top
of
dotnet
core,
and
then
all
your
UI
action
interactions
actually
get
handled
over
a
signal,
our
connection,
so
the
server
who
has
the
representation
of
the
the
Dom
and
then
when,
as
it
calculates,
Dom
differences
based
off
of
user
interactions,
it
can
push
the
Dom
dips
down
to
the
browser.
C
C
So
now
you
can
take
your
server-side
blazer,
app
and
scale
it
out
to
thousands
of
persistent
connections,
leveraging
the
scalability
that
the
signal
our
service
provides
you
so
that
that
was
also
enabled
in
0.6
and
then
probably
also
worth
mentioning
since
we're
talking
about
server-side
blazer
at
net
comp
last
month.
We
also
announced
that
the
server-side
blazer
model
we've,
we
previewed
it
was
0.5.
We
got
a
lot
of
feedback
that
you
know,
there's
quite
a
few
people
actually
like
it
and
want
to
go
ahead
and
ship
with
it.
C
In
our
surveys,
we
asked
people,
you
know
how
many
of
you
were
which
of
these
hosting
models,
which
one
would
you
like
to
use.
You
know.
The
vast
majority,
of
course,
are
very
interested
in
client-side,
and
that
is
still
the
goal,
but
about
60%
of
Blazer
users
said
you
know
that
server-side
model,
that's
all
I
need
in
fact,
that's
what
I
want
I
like
the
idea
of
having
the
my
code
living
on
the
server
I
like
the
control
I,
like
that
the
client
can
be
thinner.
C
C
You
know
sometime
sometime
next
year,
I
think
we
said
that
we
would
have
the
first
preview
bits
of
dotnet
course
Ryo
going
out
in
early
2019,
so
we're
pumped
about
that,
because
blaze
is
really
made
up
of
two
parts
right,
like
you,
have
the
component
model
and
then
you've
got
this
web
assembly
paste
dotnet
runtime.
That
really
enables
the
client-side
scenarios.
The
component
model
is
flexible.
C
It
could
run
on
the
browser
you
can
run
on
the
server
and
in
fact,
we've
made
it
so
that
if
you
want
to
start
on
the
server
and
then
switch
to
the
client,
you
can
do
that
by
just
basically
changing
a
line
of
code
assuming
you've
written
your
components
in
a
way
that
are
abstracted
from
server
specific
things.
So
we
can
make
progress
on
the
component
model
and
the
web
assembly
based
runtime.
That
will
continue
experimental
for
a
little
while
longer.
We
are
still
working
very
hard
on
that.
C
We
will
continue
to,
of
course,
to
the
ship
support
for
the
the
client-side
model
on
top
of
web
assembly.
We
think
of
the
server
side
support
as
a
as
a
path
to
get
to
that
client.
It
enables
us
to
ship
a
big
chunk
of
Blaser
as
fast
as
we
can.
While
we
continue
to
work
on
getting
the
runtime
to
be
fast
to
be
small,
to
have
good
hitter
at
build
times.
All
those
things
are
things
that
we're
working
on
in
parallel,
yeah.
C
There
are
things
that
you
can
do
on
the
server
that
it
just
feels
so
natural
now
like
you,
can
go
ahead
and
go
right
to
the
database.
If
you
want
to,
you
can
use
any
dotnet
library
that
you
want
on
the
server,
because
it's
just
net
core
you
can
de
bugging
just
works
as
it
normally
does,
because
it's
just
dotnet
core
running
on
the
server
there's
a
lot
of
things
that
are
that
are
very
natural
about
that.
Like.
A
Any
type
of
things
I
think,
as
I
said,
of
trade-offs
like
if
something's
running
in
a
different
place
from
somewhere
else,
you
get
a
different
set
of
stuff.
You
can
do
different
set
of
capabilities
and
that's
traded
off
against
things
that
you
can't
do
commonly
so
I
think.
The
way
forward
is
both
models
and
like
the
one
that
we
can
commit
to
right.
Now
is
the
server-side
model,
because
we
don't
need
a
runtime
for
that.
We've
already
got
one
and
so
we're
working
through
right.
A
Now
what
it
looks
like
to
get
that
into
the
server
side,
es
that
call
we
have
today.
We
already
have
a
server-side
model.
We
have
raised
the
pages
we
have
raised
a
very
have
stuff
and
so
we're
working
through
the
process
of
like
what
does
it
mean
to
introduce
a
third
thing.
We
have
use
pages,
and
now
we
have
components
and
how
they
will
work
together
and
all
that
type
of
stuff
and.
B
A
A
B
Six,
let's
flip
over,
let's
flip
over
to
me
and
I'm
gonna-
have
I'm
gonna,
have
the
world's
least
impressive
demo
here
to
start
off,
but
this
is
a
as
a
general.
This
is
going
to
be
a
gentle
introduction
to
templated
components.
So
if
you
haven't
read
the
haven't,
read
the
the
blog
post
or
haven't
seen
anything
about
this.
This
is
hello
world.
So
we've
got
the
standard
blazer
template
here.
We've
got
the
little
counter.
You
click
it.
It
counts.
B
A
D
A
B
B
B
So
here's
this
component
can
use
it
and
then,
if
we
come
back
here,
you'll
see
I've
got
these
two
render
fragment
properties
you
might
be
familiar
with
using
render
fragment
with
the
name
child
content
before
that
was
like
a
magic
name.
It's
sort
of
the
implicit
whatever
is
in
the
middle
of
your
component
would
show
up
in
child
content.
Now
you
have
the
ability
to
define
multiple,
render,
fragments
and
render
fragments
to
take
and
use
these.
B
So
let's
I've
defined
these
two
I
did
this
ahead
of
time
just
to
save
just
to
save
typing,
but
let's
go
ahead
and
use
them
so
I'm
going
to
replace
this
with
the
counter
content.
So
this
is
the
display
of
the
counter
and
so
to
do
that
I'm
going
to
I'm
going
to
do
at
counter
content
in
case
this
is
a
funk
and
I'm
gonna
invoke
it
and
then
I'm
gonna
pass
in
the
current
count.
So
I'm.
B
If
you
hover
over
that,
you
can
see
that
it's
an
integer,
so
the
current
count
from
here
is
going
to
be
passed
into
this
when
this
renders
and
if
I
want
to
change
the
name
of
that.
I
can
do
that
as
well.
So
if
I
say
like
current
count,
notice
that
went
red
right
away,
I
can
take
this
back
and
I
can
put
this
put
this
here.
If
I
prefer
a
different
variable
name
or
something
like
that,
and
that's
all
fine
and
then
I've
also
got
this
button
content.
B
So
let's,
let's
take
this
out
of
here
and
we'll
put
the
button
content
and
the
way
that
you
use
these
render
fragments.
Is
you
just
effectively
return
them
from
Razer
anytime
anytime
in
Razer?
You
see
like
at
foo,
you
can
think
of
this
as
like.
Well,
that's
not
a
good
example,
but
you
can
think
of
this
as
just
like
returning
something
to
let
it
be
to
be
rendered.
B
So
if
you've
got
a
render
fragment
of
integer,
it's
a
function
that
you
call
if
you've
got
a
regular
old
render
fragment
you
just
return
it,
and
then
let's
come
over
here
and
let's
fill
that
in
so
I
think
I
called
this
button
content
and
let's
ooh
that
was
gross.
Let's
give
this
you
know,
I
said
hi
stand
up
and
if
we
run
this
you'll
see
that
my
my
stuff
is
filled
in
here
and
it's
I've
passed
these
two
fragments
into
this
other
component.
B
So
the
way
that
you
use
this
or
sort
of
what
I've
accomplished
here
I
know
this
is
kind
of
a
hello
world
example.
Is
you
can
build
components
that
are
very,
very
reusable
because
you
don't
have
to
specify
all
the
content
inside
these
components?
You
can
specify
the
content
where
they're
used.
We
had
a
limited
form
of
this
before,
but
now
we're
taking
it
much
much
further
we're
making
it
much
much
richer.
We.
C
B
So
this
is
kind
of
the
basic
example
for
something
more
sophisticated
I'm
going
to
come
over
here
to
the
flight.
Finder
and
I
have
enhanced.
You
may
have
seen
this
demo
before
a
flight
fan.
There
is
a
sample
that
we've
had
around
for
a
while.
You
can
do
a
search
and
you
can
see
that
I
find
some
flights.
I
can
sort.
These
two
are
already
sorted
by
both
those
things.
I
can
add
them
to
this
list.
I
can
remove
them
from
this
list.
It's
pretty
great,
pretty
useful.
B
We
use
this
to
plan
all
of
all
of
Steve's
travel
to
come
visit
us,
but
you
can
see
that
I've
enhanced
this
now
and
I've
added
the
new
tab
to
this
I've
added
the
search
for
car
rentals.
So
if
we
put
in
I
think
Steve's
coming
later
this
month,
so
you
know
I'm
gonna
pick
I'm
gonna
pick
the
date
so
I'll,
let
him
know
later
I'm
gonna.
Actually
you
know
it'd
be
great
if
he
could
leave
tomorrow.
B
So
if
I
search
I'll
get
some
cars
and
then
I
can
add
them
to
this
short
list
and
you'll
see
that
if
I,
if
I
move
back
and
forth,
these
are
all
you
know
part
of
the
same
list
here.
So
what
I
have
created
here.
This
is
this
is
kind
of
standard
stuff,
but
what
I
have
created
here
is
an
opportunity
for
us
to
learn
about
templated
components
with
generics.
So
if
we
come
over
to
this
this
code,
which
is
the
flight
finder
code,
you
see
that
I've
got
these
two
high-level
pages.
B
So
this
is
like
the
main
page.
This
is
where
the
flight
search
happens
and
you
see
the
flight
search
results
and
then
I've
got
this
car
rental
page,
which
is
where
you
see
the
car
rentals
and
the
car
rental
results.
Now
I
want
to
dig
into
these
I'm
going
to
dig
into
this
a
little
bit
and
we're
going
to
be
spending
our
time
inside
this
car
rental
search
results.
So
you
remember
at
the
top.
We
have
the
search
area
at
the
bottom.
We
have
the
results
area
and
at
the
right
to
hand
side.
B
We
have
the
short
list
or
like
the
list
of
things
that
are
being
considered,
we're
going
to
be
spending
our
time
inside
this
results,
control
air
component
and
see
what
we
can
do
with
that.
So
I've
got
a
car
rental
search
results
and
I've
got
a
flight
search
results
here
and
if
you
pull
these
out
and
look
at
them
side-by-side-
and
it
may
be
a
little
hard
to
do
this
with
the
window
size
and
the
font
size,
you'll
you'll
start
to
notice
that
these
two
things
are
really
kind
of
the
same.
B
I
mean
they
have
the
same
markup.
They
both
take
a
list
of
itineraries,
they
both
sort
the
list
and
then
they
both
display
some
kind
of
component
in
the
body.
They
really
are
kind
of
the
same.
So
this
is
a
good
opportunity
for
us
to
use
generics
and
template
components
to
sort
of
like
extract
the
common
features
of
these
and
make
a
component
that's
a
little
bit
more
reusable.
B
B
So
I
have
this
add
type
per
annum
directive
and
we'll
say
t
results,
because
these
are
search
results.
So
now
you
see
I've
declared
a
generic
type
parameter
and
I
can
start
filling
this
in
places
so
I'm
going
to
uncomment
this
code.
This
is
my.
This
is
my
little
sorting
helper
here,
I'm
going
to
uncomment
this
code,
and
you
can
see
I've
already
got
T
result
here
and
that's
going
to
light
up
and
that
that
works.
I've
now
got
a
generic
in
here.
So.
B
So
what
else
do
I
need?
Well,
I
noticed
that
I've
got
flight
search.
Result
here
and
I
want
to
I
want
to
basically
mix
up
the
last
demo
with
this
demo.
I
need
to
pass
in
the
thing
that
I
want
to
render
here
so
I'm
going
to
have
this
list
of
sorted
itineraries
which
I'll
going
to
change
this
right
now.
So
this
should
be
sorts
of
items
for
itineraries.
B
B
So
that
I
can
pass
that
in
and
then
to
use
this,
it's
just
like
I
did
before
this
is
going
to
be
result.
Content
and
I
just
pass
in
the
item,
so
I've
sort
of
like
abstracted
out
this
loop
right
now,
there's
one
other
change
that
I
have
to
make
here
is
I
have
to
deal
with
the
fact
that
this
is
hard-coded
to
use
the
flight
itinerary
sort
instead
of
these
sort
options.
So
I'm
just
going
to
do
that.
Real
quick.
B
And
sorts
can
sort
options
that
count.
I
always
get
this
confused
between
count
and
length
and
I
always
want
to
use
length
for
I,
read
only
list
which
is
the
best
interface
and
dotnet,
and
then
we're
going
to
put
this
option
inside
the
loop
and
use
our
variable
here
and
then,
instead
of
using
the
enum
value,
we're
just
going
to
use
the
index,
because
that
would
cause
problems
with
generics
to
actually
use
the
enum
value.
And
then
this
will
be
the
text
that
we
get
from
sort
options.
Oh.
B
I
forgot,
my
@:
that's
why
it's
not
completing
its
play
text
so
now
we're
going
to
render
all
of
the
sort
options
in
this
options
drop-down,
so
somebody
can
pass
in
the
sort
options
somebody
can
pass
in
a
result,
content
to
render
from
here-
and
if
you
look
at
this,
you
see
that
there's
no
there's
no
flight
options,
there's
no
flights!
Anything
in
here
where
are
we
complaining
about
here-
does
not
contain
a
definition
for
compare.
Oh
because
I
didn't
give
it
a
name,
does
not
contain
any
flight,
anything
or
any
car.
B
Anything
it's
become
totally
totally
generic.
At
this
point
and
if
I
give
this
a
bill,
this
should
build.
I
haven't
used
it
yet
we'll
do
that
next,
okay,
good!
So
we've
done
a
build.
So
let's
come
over
here
and
let's
use
it
so
inside
of
here
instead
of
flight
search
results.
I'm
going
to
plug
in
my
generic
search
results.
Now
I
still
need
to
pass
in
the
itineraries.
B
So
in
this
case,
it's
a
flight
search
results,
so
I'll
pass
those
in
and
then
I
need
to
pass
in
the
sort
options
now
I
mentioned
that
I've
done.
I
had
done
this
earlier,
so
I've,
already
kind
of
stashed
these
away
somewhere
out
of
the
way
married
sort
of
get
sort
options,
so
I
already
stashed
these
away
somewhere
else,
and
then
inside
the
body
of
this
we're
going
to
need
to
specify
that
result,
content
and
the
result
content.
B
If
we
look
back
at
this
search,
results
was
just
this
guy,
so
I'll
grab
that
put
that
here
inside
result,
content
and
then
remember.
We
had
talked
about
the
parameter
names
for
these
templates
before
this
parameter
name
by
default
will
not
be
item.
It
will
be
context,
so
we
could
either
use
context
here
or
we
could
rename
it
I,
like
I,
like
item
a
little
bit
better,
so
we'll
put
item
here
and
then
this
is
coming
from
our
appstate
container.
B
B
G
B
B
This
should
all
just
work,
and
you
should
see
the
flight
page.
The
flight
search
page
in
search
results
page
come
up
sort
of
as
it
is
so
remember.
This
is
the
same
thing
we
saw
before
and
I
can
do
a
search
and
I've
got
sorting
here.
These
are
already
sorted
in
the
same
order
for
both.
So,
let's
see
if
we
can
get
a
different
one,
but
I've
got
I've
got
my
sorting
here.
These
are
also
already
in
order
by
shortest
I've
got
my
sort
here.
B
C
B
C
That's
that's
kind
of
like
a
an
application
of
the
you
integrating
that
into
your
application
development,
but
you
can
sort
of
imagine
them.
Taking
that
feature
and
building
out
like
component
libraries
that
have
generic
functionality.
That
then
can
be
reused
in
a
variety
of
applications.
Not
like
you
know,.
B
B
The
really
neat
part
of
this
that
makes
this
go
is
kind
of
how
generics
interact
with
the
compiler,
so
something
else
that
you
can
do
with
this.
If
you're,
if
you
don't,
you
know,
if
you
use
generics
in
c-sharp
before
you
know
that
sometimes
the
type
can
be
inferred
and
some
the
type
has
to
be
specified.
B
B
Yeah,
so
this
parameter
name
is
derived
from
the
type
name
of
the
of
the
component
and
that
won't
be
needed
all
the
time,
but
it
will
be
needed
and
I
think
in
some
complicated
cases.
There's
some
things
that
don't
infer
super
super
well,
but
that's
that's
kind
of
an
overview
of
this.
So
we've
got
a
couple
features
that
are
working
together
here.
A
A
B
A
B
A
So
it's
there's
no
right
or
wrong.
Some
folks
like
to
have
it
in
the
one
file,
it's
very
common
to
see
that
in
other
component
based
UI
frameworks,
especially
from
the
spar
world,
it's
very
common
to
have
it
together
from
the
dotnet
side
of
the
world.
We
seem
to
see
a
lot
of
more
folks
prefer
to
have
them
separated
and
there
seems
to
be
some
connotation
with
bad
practice
or
something
with
them
together,
I'm
not
gonna
jump
on
either
bandwagon.
A
C
The
way
you
do
it
is
like,
if
you
had
countered
OCS
HTML,
you
can
define
a
counter
CSS
HTML
CS,
and
to
find
a
counter
base
class
that
derives
from
blazer
component
and
then
in
your
CSS
HTML
file.
You
say,
inherits
from
that
base
component,
and
then
you
can
put
all
of
your
your
code,
like
your
your
event,
handling
methods,
your
on,
indeed
whatever
in
the
the
base
class
and
that
that
allows
to
the
majority
of
the
code
that
would
normally
live
in
the
app
functions
section
to
move
into
a
separate
file.
C
C
It
kind
of
speaks
to
the
fact
that
that
blazer
is
a
big
topic.
It
has
been
operating
in
this
experimental
mode
like
for
as
much
as
possible.
We've
been
trying
to
use
the
available
expect
extensibility
points
that
we
have
the
available
tooling
extensibility
points
that
we
have
to
enable
as
much
of
the
experience
as
we
can
without
really
going
too
deep
into
like
making
actual
runtime
feature
changes
as
we
move
into
this
300
wave
like
actually
productizing
razor
components
and
making
that
part
of
the
the
a
spec
core
experience.
A
There'll,
be
a
big,
tooling
train
that
we'll
be
able
to
make
some
of
these
underlying
changes.
I
mean
they.
We
could
have
built
the
partial
class
support
that
just
wouldn't
have
worked
well
and
bs
right
like
so.
You
could
have
been
done
but
like.
Why
do
that?
If
you
can't
really
dev
in
it
and
then
get
feedback
on
that
model,
because
the
tooling
so
broken
I
think
one
of
the
philosophies
that
we've
tried
to
keep
with
this,
as
Dan
just
said,
is
that
we
want
the
tooling
experience
to
be
there.
A
So
you
get
a
nice
what
we
call
a
dev
in
a
loop
and
that
you're
just
sitting
there
typing
code,
all
the
time,
so
I
think
that
that's
worthwhile
I
think
it's
worthwhile
making
sure
that
we're
going
to
prosper
in
this,
because
it
requires
a
whole
bunch
of
tooling
things.
We
can't
retrofit
it
in
using
an
existing
thing,
so
we're
just
gonna
hey.
C
In
browser
debugging
experience
is
effectively
unchanged
like
it's
it's
what
it
was
in
0.5,
which
means
that
it's
it's
a
pretty
rough
experience
like
it's
enough
to
to
demo
and
show
how
the
pieces
fit
together.
It's
and
you
can
maybe
debug
some
very
simple
cases,
but
if
you
breathe
on
it
wrong
it
content
stuff
all
over.
That
said,
in
our
next
place,
release
we've
we've
been
talking
with
the
mono
folks,
and
they
have.
C
They
had
shifted,
focus
a
little
bit
to
focus
on
the
äôt
story,
and
they
are
still
doing
that,
but
they've
managed
to
get
to
shuffle
their
resources
a
bit
so
that
they
now
have
someone
who
can
actually
go
back
and
devote
for
more
time
to
the
debugging
experience.
So
we're
expecting
to
see
some
some
nice
improvements
coming,
hopefully
in
the
z-row
0.7
wave.
Okay,
you.
D
C
D
C
C
A
Asks
about
CSS
how
is
CSS
handled
in
Blazer.
Oh
six
I
believe
someone
else,
or
he
again
asks
later
on
it.
Will
there
be
a
way
to
package
static
resources
in
no?
It
is
it's
a
Ladislav
skinny
chance
of
style
encapsulation
for
components
similar
like
real
web
components
and
dan
and
I
were
talking
about
this.
Just
yesterday,
I
think
yeah.
A
We
did
raise
the
class
libraries
in
a
spirit
core
to
one
which
is
kind
of
the
first
step
to
what,
if
we
could
have
the
ability
to
like
build,
raise
a
thing
you
could
reuse,
but
we
don't
have
a
first
class
story
for
great
that
has
some
images
in
it
and
some
style
sheets,
and
some
JavaScript
and
I
could
just
use
it
like
control
blaze.
The
components
are
much
further
along
in
that
story
is
my
understanding
laser.
C
A
A
Matches
up,
it
seems
so
anti
how
CSS
should
be
done,
but
I
can
understand,
I
mean
they've
got
two
tensions
working
against
each
other
here,
which
is
you
want
this
isolation,
this
componentization
of
UI?
But
you
want
to
use
this
cascading
based
system
with
inheritance
rules
and
specificity
rules
in
order
to
facilitate
it.
You
just
kind
of
have
to
get
well.
C
A
Can't
have
both
of
those
things,
so,
let's
just
carve
out
a
part
of
the
world
with
a
good
and
that's
what
we'll
use
is.
I
I've
never
looked
closely
at
how
they
do
it
and
then
on
that
side
of
the
fence-
and
I
I'm
interested
in
how
you
have
a
component
that
can
inherit
some
aspects
of
the
pager,
that's
in
or
the
or
the
component
that
it's
in,
but
also
habits,
only
things
that
these
aren't
unique
problems
that
we've
had
this.
You
know
issue
with
doing
web
base
you
I
composition,
forever.
A
A
Most
control
frameworks
often
come
with
a
like
a
manager,
control
that,
like
it's,
the
marshall
marshall,
are
on
the
page
of
what
CSS
gets
loaded
when
and
how
they
compose
together
and
I've,
seen
some
patterns
in
the
CSS
community
to
where
people
come
up
with
like
mini
frameworks
and
are
frameworks
and
more
like
rules
to
follow
just
structure
CSS
in
a
way
that
composers
well
together,
and
then
you've
got
things
like
bootstrap
and
stuff
like
that
as
well,
which
tries
to
give
you
things
that
you
can
just
lay
on
top.
But
it's
an
interesting
problem.
A
Think
we
would
get
to
the
point
like
you
said:
where
you'd
have
your
component
library,
you
can
put
components
in
it
with
static
files
and
they
all
get
embedded
into
the
same
DLL,
thus
package,
but
then
on
the
consumption
side,
when
you
bring
that
in
the
question,
is
great
I
have
the
types
that's
easy
as
to.net
path,
but
like
how
do
the
static
files
get
served?
We
have
a
pattern
in
a
spinet
core
where
we
can
find
them
in
the
ref
like
a
web
part.
A
C
F
So,
with
a
blazer
component
library,
we
use
some
NS
bill
metadata
to
identify
which
files
are
the
static
assets
that
you
want
to
make
possible
to
serve,
and
so,
as
part
of
the
build
process,
we
will
drop
those
static
files
in
a
location
that
the
middleware
can
find
at
runtime.
So
basically,
it
does
just
work
without
you
having
to
do
anything,
okay,
I'm,
and
if
you
want
to
customize
it,
you
need
to
get
into
the
msbuild
side
of
that.
But.
A
A
C
A
F
Don't
say:
okay,
good
all
right,
then.
So,
let's
talk
a
little
bit
about
some
of
the
things
we're
trying
to
do
in
the
point
7
release,
which
obviously
hasn't
come
out
yet.
But
one
of
the
ideas
we've
got
with
this
release
is
to
build
on
the
work
that
Ryan's
done
on
temperature
components
and
make
it
easier
to
build
more
interesting,
high-level
components.
F
The
sort
of
thing
that
you'll
remember
from
all
of
the
your
our
tool
kits
things
like
grids
and
tabs,
and
you
know
carousels
or
whatever
all
these
kinds
of
controls,
that
people
are
used
to
making
sure
that
they
can
be
modeled
really
well
as
laser
components.
Okay,
so
temperature
components
is
part
of
that.
Another
part
of
it
that
we
haven't
addressed
prior
to
now
is
the
ability
for
components
to
communicate
based
on
ancestor
and
descendant
relationships.
F
So
you
might
want
to
say,
okay
for
all
of
the
components
within
this
particular
subtree
of
my
UI
I
want
them
all
to
share
a
certain
bit
of
data,
or
you
might
want
to
say
something
like
okay,
I've
got
a
grid
row
component
and
it
needs
to
be
able
to
find
which
grid
it's
inside
in
order
to
be
able
to
interact
with
that
in
various
ways.
Does
that
make
sense?
Well,
good,
all
right!
So
let
me
show
you
a
couple
of
demos
of
things
that
we
are
freshly
working
on.
This
is
very,
very
fresh.
F
F
All
right,
so
you
can
see
the
counter
component
right.
You've
all
seen
this
before
it's
got
this
blue
bar
and
we
click
the
account
goes
up
all
right.
So
let's
say
we
don't
want
this
button
to
be
blue
necessarily,
in
fact,
we
don't
know
what
color
we
want
it
to
be.
Yet
we
want
to
have
a
sort
of
theming
system
built
into
our
application
so
that
we
can
define
themes
in
one
location
and
all
the
components
within
a
certain
part
of
our
UI,
we'll
be
able
to
pick
up
that
theme,
information.
Okay.
F
F
F
One
of
these
theme-
infos,
okay
and
I'm-
going
to
say
that
the
button
plus
on
this
theme
is
button.
Success
all
right
so
to
provide
that
I
can
choose
which
part
of
the
UI
I
want
to
provide
it
to
and
I'm
going
to
provide
it
to.
Whatever
is
the
body
part
of
the
page?
I
can
put
this
wherever
I
want
really
but
I'm,
going
to
put
a
provider
here
and
I'm
gonna
say
the
value
we
are
providing
is
the
theme
okay
and
let's
get
the
nesting
correctly
all
right.
F
So
if
I
recompile
my
application
now
and
then
I
go
back
into
a
browser
and
reload,
let's
see
what
effect
that
has
on
this
blue
button.
The
effect
it
has
is
nothing
at
all.
Why
is
that?
Because
I
have
not
been
consuming
the
value
that's
been
provided
yet
so
let's
say
we
want
to
consume
that
value
and
we're
going
to
go
over
to
the
counter
component
now
and
I'm
going
to
consume
it
as
a
parameter.
F
So
if
you've
used
Blaser
before
you'll
be
familiar
with,
they
are
something
that
gets
passed
into
your
component
and
the
value
can
change
and
value
can
be
whatever
type
you
want
and
so
on.
So
in
this
case,
I'm
going
to
be
taking
a
theme
in
fur
and
I
can
give
it
any
name.
I
want
I'm,
gonna
call
it
current
theme,
because
that
obviously
makes
sense
and
we'll
put
to
get
and
set
on
that.
Okay.
F
Now,
with
this
defined
as
it
is,
this
is
just
a
normal
parameter,
which
means
it's
part
of
the
contract
between
this
component
and
its
immediate
parent.
But
that's
not
what
we
want
in
this
case.
We
don't
want
this
value
to
come
from
the
immediate
parent.
Necessarily
we
want
it
to
come
from
any
ancestor
that
can
provide
that
value.
F
So
I'm
going
to
use
this
new
flag
called
from
tree
and
the
naming
here
by
the
way
is
very
likely
to
change
so
I've
sort
of
made
this
up
without
really
thinking
it
through
very
carefully
we're
going
to
in
veritably,
have
meetings
and
search
and
decide
what
the
right
names
for
these
things
are
really
big.
Gonna
be
so
it
might
not
be
called
from
tree.
It
might
be
call
something
like
from
ancestor
or
it
might
be
something
like
cascades
equals.
F
True
or
something
I
don't
know,
but
let's
not
worry
about
that
right
now,
the
logically
we're
just
getting
this
parameter
from
somewhere
in
the
ancestry.
Okay
and
since
we're
doing
that,
I
can
now
say
instead
of
displaying
button,
parameter
button
primary
I'm
going
to
image
current
theme
button
class.
Okay,
hopefully
the
value
will
be
provided
further
up
the
tree
by
the
provider
component
and
then
it
can
be
picked
up
by
any
descendants
that
wants
to
get
the
current
theme
info.
F
So
now,
when
I
reload
my
browser
instead
of
the
blue
button,
you'll
see,
we've
got
a
green
button
because
that's
what
the
theme
information
declares
and
if
I
wanted
to
change
that-
and
of
course
I
can
go
back
to
whichever
part
of
the
UI
subtree
is
receiving.
That
theme
and
I
can
change
what
gets
passed
to
it.
F
A
G
Know
it
seems
like
there's
gonna,
be
a
class
of
person
who
is
going
to
look
at
this
and
say
it
looks
like
polymer.
It
looks
like
web
components.
These
things
are
all
very
important,
there's
the
overloading
of
words
component,
but
then
there's
also
the
old
heads
that
are
gonna
say
this
looks
like
web
forms
and
it
seems
like
that's
a
good
thing.
It
is
the
best
concepts
from
all
the
different
things.
Yeah.
A
A
F
Yeah,
that's
right
theme
is
a
common
example,
so
this
feature
in
Blazer
is
very
similar
to
the
inject
feature
from
view
and
it's
very
similar
to
what
used
to
be
called
context
in
react.
So
you
know
all
these
UI
frameworks
do
essentially
share
the
same
concept
and
theming
is
basically
the
hello
world
example
that
everybody
uses
when
tunneling
data
from
one
place
to
another.
That's
why
I've
shown
you
that
I
will
show
you
a
more
interesting
example
now.
F
Whatever
was
the
selected
thing
before
and
select
the
new
thing
and
change
what
is
being
displayed,
so
you
need
this
form
of
collaboration
and
it's
based
on
ancestor
descendant
relationships,
because
she
could
have
multiple
tab
sets
in
different
parts
of
your
application
and
you
need
each
tab
to
know
which
tab
set
it's
part
of
now.
You
could
do
this
in
the
past,
with
blazer
by
manually
wiring
everything
up,
but
the
point
of
this
inherited
parameters
or
three
parameters.
F
Whatever
we
call
it
is
that
the
wiring
can
be
done
by
the
person
who
are
authors,
the
controls,
the
components
not
by
the
person
who
is
consuming
them.
So
if
you're
building
a
UI
toolkit,
you
can
use
this
feature
to
make
your
components
work
together
and
the
person
uses
them
without
average.
Think
about
that
so
I
have
about
an
hour
ago
made
a
very,
very
simplistic
version
of
tab
sets
and
let's
just
use
that
now
and
then
I'll
show
you
how
it
works.
F
So
here
on
my
home,
page
I'm,
going
to
add
a
tab
set
okay
and
inside
that
will
put
a
tab
and
we
can
give
it
a
title.
First
tab
and
we'll
put
some
content
inside
there.
Let's
say
this
is
the
first
tab
and
it
is
the
best
tab.
Okay
and
then
we'll
have
another
tab.
Title
equals
let's
say
counter
and
just
to
show
you
input
arbitrary
things
in
there.
I'm
gonna
put
a
counter
component
inside
that
tab.
F
Alright,
so
let's
just
show
you
this
working
and
then
I'll
show
you
how
it
works
and
how
it
does
this
collaboration
using
three
parameters
so
back
over
here,
you'll
see,
we've
got
these
tabs
now
that
we've
just
added
and
they
do
actually
work
so
I
can
switch
between
first
and
counter
like
you'd
expect
and
the
counter
does
actually
work,
because
you
know
it's
just
a
normal
component
and
it's
picked
up
the
themes
and
everything's
working
like
it
should
okay,
but
how
does
it
work
so?
How
do
the
components
talk
to
each
other?
F
Well,
if
I
go
into
this
implementation
of
tab
set
here,
you
will
see
that
it's
not
completely
trivial
I'm,
not
I'm,
not
going
to
pretend
that
it
is
it's
51
lines
and
not
all
of
it
is
totally
obvious,
but
the
important
bit
that
you
need
to
understand
is
that
we
are
using
these
providers
to
enable
collaboration
between
components.
So
here
the
tab
set
just
before
it
renders
its
own
child
content.
F
It
says
I'm
going
to
provide
myself
to
all
the
children,
so
any
of
the
descendants
that
want
to
find
which
tab
set
they
are
inside
can
just
say:
oh
I
want
to
receive
a
tab
set
as
a
parameter
and
they're
going
to
get
the
tab
set
that
they
are
inside.
So
if
I
go
over
onto
the
tab,
you
will
see
that
here
and
we
I've
got
this
three
parameter.
That's
of
type
tab
set
called
ancestor
tab
set,
and
so
the
tab
can
discover
what
tab
set
it's
inside.
F
F
F
The
point
is
that
components
can
discover
each
other
based
on
ancestor
relationships
and
then
call
methods
on
each
other,
and
that
allows
you
to
do
this
sort
of
collaboration
and
this
sort
of
form
of
building
components
declaratively.
Well,
it's
not
just
declarative.
It's
also
procedural
I
want
to
show
you
a
thing
that
might
not
be
obvious
that
you
could
even
do
it.
So,
let's
say
I
want
to
add
a
third
tab.
F
F
Input
type
equals
checkbox
I'm
going
to
bind
that
to
the
sure
third
tab
thing
like
that:
okay,
so
now
back
in
the
UI,
when
I
reload,
we
should
see
that
we've
got
the
three
tabs.
No,
we
have
got
three
tubs
yet
because
I
haven't
checked
this
checkbox
when
I
check
it,
a
third
tab
will
appear,
I
can
go
and
show
it.
I
can
go
back,
I
can
uncheck
it.
The
top
disappears
I.
A
D
A
D
A
Nothing
declared
those
things
is
like
bind
as
a
binding.
It's
like
it's
just
that
I'm
using
that
property
in
an
expression
like
an
if
statement.
That's
not
a
binding
of
the
declaration
in
the
traditional
sense
of
the
word.
The
way
that
we
kind
of
were
all
brought
up
with
binding
systems
or
you
have
a
binding
expression,
which
is
a
different
thing
like,
in
example,
there's
a
binding
expression
in
a
spin
air
there's
a
binding
expression.
A
They
take,
and
you
can't
do
everything
in
a
binding
expression
that
you
can
do
in
a
normal
code
block
in
here.
It's
just
code
and
like
this
is
this
is
incredible
mix
of
declaration
and
imperative
flow,
and
it
it
just
it's
so
deceptively
simple
when
he
wrote
that
code
I
was
like.
Why
can't
work
is
doing
it
like
you
just
wrapped
it
a
new
statement.
I'd
have
to
duck.
Don't
I
have
to
declare
like
a
boolean
thing
with
it
a
binding
thing
and
like
a
to
Wavelab?
No,
it's
just
it's
just
way.
F
So
the
fact
that
we
can
do
this
really
is
the
combination
of
the
temperatures
components.
That's
an
incentive
part
of
this,
because
a
tab
set
is
a
temperature
component.
A
tab
is
also
a
templates,
a
component
and
it's
a
combination
of
the
generic
components
as
well.
That
might
not
be
obvious,
but
if
I
go
back
over
here,
this
provider
is
a
provider
of
tea.
If
you
can
read
incredibly
small
tax.
C
F
That
that's
what
that
is,
so
the
value
we're
providing
there
is
generic
as
well,
which
means
that
we
can
differentiate
different
types
of
nulls
and
things
like
that
that
wouldn't
be
possible
if
it
wasn't
a
generic
component
and
and
finally
it's
these
ability
to
do
tree
parameters
that
allow
you
to
pass
stuff
up
and
down
the
ancestry.
So.
D
E
D
B
D
Terms
of
like
the
same
sort
of
thing
when
I
was
looking,
I
was
working
on
something
and
I
had
to
like
I
was
looking
for.
How
do
I
notify
it
to
change
and
how
do
I
notify
an
update
and
it
just
magically?
Does
it
right,
and
so
is
it
kind
of
almost
like
a
react
style
way
of
thinking
where,
if
I
set
a
property
on
somewhere
on
the
tree,
it
like
smartly
figures
out
what
to
re-render
and
that
kind
of
thing.
Yeah.
F
It's
very
much
a
react
style
of
things.
It's
so
much
a
react
style
of
things
that
you
it
doesn't
it's
not
magic.
When
you
change
your
properties,
you
sometimes
have
to
notify
the
system
that
you've
done
that,
because
it's
not
sort
of
magically
inspecting
the
state
of
all
your
Donette
objects
and
observing
if
they
change
in
some
way.
B
F
Another
case
will
be
collaboration
between
components,
so
let
me
show
you
how
what
tabs
set
is
doing
you'll
see
that,
at
the
end
of
these
on
tab
added
and
on
tag
removed,
I'm
calling
state
has
changed,
because
otherwise
the
framework
just
doesn't
know
that
you've
done
anything
like
we've
called
a
method
on
a
class
and
it's
mutated,
some
of
its
internal
stay.
The
blazes
doesn't
know
that
you've
done
that,
because
this,
the
event
that
caused
the
tab
to
be
removed
is
not
part
of
the
tab
set.
F
A
F
That's
right
and
some
people
have
actually
really
adopted
the
inotify
property
change
model.
If
you
want
to,
you
can
do
that.
You
can
have
a
base
component
that
supports
that
interface
and
triggers
state
has
changed
at
the
right
time
and
such
so.
If
you
like
that
pattern,
you
can
absolutely
use
that,
and
then
you
can
forget
about
state
has
changed,
but
we're
being
a
little
bit
more
general
than
that
and
allowing
multiple
different
notification
models
of.
A
Course
so
we
only
will
be
at
59
minutes
in
I
had
one
more
question:
someone
asked
which
I
thought
might
be
worth
getting
getting
some
comments
on
from
you
folks,
someone
asked
about
this
party
just
came
up
in
a
meeting.
We
had
yesterday
about
web
components
and
they
were
looking
at
this
and
go.
This
is
amazing.
I
would
like
you
to
be
wonderful.
A
If
you
know
if
this
was
when
they
hit
the
browser,
it
was
using
similar
technologies
to
other
things
like
shadow
Dom's
and
see
if
there's
a
virtual
CSS
properties
and
there's
other
types
of
stuff
and
I
think
they
were
wishing
for
the
same
type
of
world
that
we've
talked
about.
Where
imagine
you
could
just
write
a
web
component
in
any
language
and
it's
a
standard
web
component
and
you
could
load
it
into
any
app
that
was
using
any
UI
framework
Steve.
Do
you
have
any
comments
about
that?
I,
don't
I,
don't
know
the
latest
status.
A
F
I
would
agree
with
that
statement
so,
as
for
how
we
can
approach
this
and
Blaser
I
think
we
can
take
it
from
a
couple
of
different
angles.
So
there's
the
angle
of
I'm
writing
a
mostly
blazer
component,
but
I
want
to
use
some
web
components
type
technologies
within
it,
such
as
shadow
Dom
or
such
as
web
components
written
in
other
languages
or
even
frameworks,
and
so
it's
possible
to
imagine
that
we're
put
in
some
infrastructure
to
make
all
that
stuff
work
and
then
there's
the
other
angle
of
it,
which
is
I'm.
Writing
a
blazer
component.
F
I
want
and
I
want
to
expose
it
as
a
web
component
so
that
it
can
be
used
in
something
else
and
again,
it's
possible
to
imagine
some
sort
of
library
like
feature
that
adapts
Blazers
api's
to
the
web
component
api's,
so
other
frameworks
could
consume
the
component
without
having
to
know
what
it
is
implemented
in.
So
that's
a
similar
model,
that's
been
attempted
with
angular
already
and
they've
had
some
success
with
that.
We
haven't
really
got
started,
but
we
could
do
more
or
less
the
same
thing:
cool.
A
A
C
And
I
gotta
say
thank
you
also
to
the
community.
Folks,
like
honestly,
a
big
chunk
of
what
Blazer
is
is
is
not
just
the
work
of
the
people
here
that
you
know
code
on
it,
but
also
the
people
that
are
building
samples
and
libraries
and
component
libraries
Interop
libraries
like
that's
a
huge
chunk
of
what
the
Blazer
experience
really
is
today.
Thank
you
for
all
that
great
work
that
you
guys
are
doing
and.
A
Finally,
that
we've,
you
know,
we've
reiterated
the
announcement
a
few
times
that
we
live
with
going.
We
plan
to
now
take
a
lot
of
the
the
Blazer
component
model
into
a
spinet
core
three.
At
least
you
can
do
that
from
your
server
side
apps.
When
would
we
have
a
little
more
detail
on
that
winkin
customers
and
folks
in
the
community
start
to
see
what
that
will
look
like
we.
B
A
G
A
A
G
A
A
I'm,
sorry,
everyone
you'll
just
have
to
live
with
it
again,
thanks
for
joining
us
and
share
this
around
so
that
we
get
the
blaze
of
love
out
there
and
continue
to
get
feedback
on
it
and
we'll
see
you
again
do
ever
guess
for
next
week.
Lined
up
do
we
know
we're
talking
about
next
week,
yet
John
well,.