►
From YouTube: ASP.NET Community Standup - Oct 3, 2017 - SignalR Demos
Description
Blog post: Announcing SignalR (alpha) for ASP.NET Core 2.0
https://blogs.msdn.microsoft.com/webdev/2017/09/14/announcing-signalr-for-asp-net-core-2-0/
Links for this week: https://www.one-tab.com/page/fegfxJvBQoe-L4K4IsO_FQ
A
B
A
A
B
A
B
B
A
B
C
A
B
A
B
A
C
B
Got
sidetracked
by
having
to
update
it
for
all
the
European
cookie
compliance?
Oh
yeah!
That's
fine!
That
kind
of
site
that
kind
of
derailed
my
to
o
upgrade
so
now.
I
have
to
go
back
and
rebase
all
the
to
o
stuff
on
all
the
cookie
stuff
and
I
have
no
chance
yet,
but
we'll
get
there
we'll
get
there.
But
we're
here
today
to
talk
about
Sigma.
A
B
That's
saying
that
the
microphone
is
a
little
sensitive
today.
I
did
change
the
mode
on
the
microphone,
because
there's
two
people
I
think
I
put
it
in
stereo
mode
I.
Think
let
me
change
it
back
and
I
think
I
think,
maybe
that
one
we'll
see
if
that's
better
I
just
switched
the
mode.
So
whoever
is
commenting
can
tell
me
whether
it
sounds
better
awesome.
B
B
A
B
Exactly
I
mean
fiebag,
you
have
to
use
view
data
to
pass
stuff
between
pages
and
layout
pages.
No,
there
really
isn't
any
other
first-class
way
of
doing
that.
We
do
intend
to
fix
that
at
some
point,
but
today
that's
kind
of
the
only
way
and
viewbag
is
just
the
dynamic,
like
a
sharp
dynamic
way
of
doing
that
without
me.
Instead
of
using
view
data
but
view
bag
is
using
dynamic.
This
way
just
makes
me
sad.
So
all
right,
so
here's.
B
B
A
Right
so
here's
a
nice
one
from
Andrew
Locke
and
he's
going
through
creating
interesting,
a
self-signed
cert
on
Linux,
with
kestrel
name's,
peanut,
core
and
yeah.
So
this
is
nice.
This
is
kind
of
walking
through
you
know,
creating
it
using
open,
SSL,
and
you
know
some
kind
of
interesting,
like
in-depth
specifics
on
what
you
need
to
do
to
trust
it.
It's.
B
C
B
On
first
launch
Visual
Studio
will
market
is
trusted
so
that
it
works
in
the
browser,
and
we
want
to
replicate
the
experience
from
the
command
line
on
a
Mac
and
on
Linux,
and
so
we're
looking
at
ways
that
we
could
do
that
with
new
api's
and
dotnet,
core
2.1,
etc,
etc.
So,
but
until
then,
you're
gonna
have
to
do
it
all
manually.
Using
that
like
open,
SSL,
cool.
A
Ok,
so
this
one
is
an
interesting
one
from
Francisco,
so
he
noticed
that
he
wanted
to
use
the
asp
net
core
with
spa
services
and
out
of
the
box
file
new
project.
You
just
see
angular
and
react
and
he
wanted
to
use
knockout,
and
so
he
shows
how
to
do
that,
using
the
spa,
templates
and
and
then
kind
of
walks
through.
A
You
know
what
you
can
do
with
knockout
and
building
an
application
with
knockout
very
good,
so
this
one
is
from
rostislav
and
he's
just
walking
through
what
they
did
in
upgrading
an
application
to
asp
net
core
to.
I
think
this
is
always
you
know
nice
to
see
you
when
people
show
here's
what
we
did
in
our
specific
application.
There's
some
standard
things
you'll
see
as
far
as
you
know,
updating,
and
then
he
digs
into
a
little
bit
of
things
that
were
important
for
them,
with
changes
for
authentication.
A
C
A
That's
nice,
okay,
so
this
one
from
junus
he
wanted
to
find
out
if
a
URL
matches
a
an
action
in
asp
net
core
and
so
he's
using
the
iraq
collection
and
and
wearing
it
to
see
if
it's
there.
So
it's
just
useful
if
you
want
to
before
you
maybe
show
a
link
or
you
know
if
you
want
to
understand
that
out
ahead
of
time.
That's
how
you
can
do
that
this
was
cool.
I
just
saw
this
come
by.
A
So
this,
the
as
peanut
core
docks
in
dock
stopped,
microsoft.com
have
enabled
bilingual
view
on
hover
and
edit,
and
so
what
this
means
is.
We
have
a
lot
of
international
viewers
on
here
and
it
would
be
great
to
have
people
start
going
in
and
translating
and
improving
the
translations
here.
So
that's
kind
of
cool,
very
good,
so
neat
one.
A
This
guy
Hanselman
pointed
this
out
to
me:
adi
has
been
just
cranking
away,
creating
tons
of
really
cool
videos
so
he's
over
in
Lagos,
Nigeria
I
hadn't
realized
how
how
strong
the
the
Lagos
SP
net
and
just
dotnet
core
community
is.
They
just
had
a
dotnet
Kampf
live
or
a
local
event
there
and
so
I'm,
so
I've
been
kind
of
following
these
folks
more,
but
so
so,
just
looking
at
adi
he's
created,
tons
and
tons
of
videos
and
just
join
ya,
he's
building
things
using
his
peanut
core.
So
that's
great!
A
So
this
one's
from
Laurel
and
he's
talking
about
debugging
in
today,
SP
net,
core
OH
source
code,
ID
actually
meant
to
feature
this
feature.
This
previously
and
I
forgot
I
closed
the
tag,
so
here
he's
just
showing
about
you
know
loading
from
the
simple
server
and
debugging
into
it,
so
cool
and
finally
here
is
one
from
Juergen
and
he's
doing
a
walkthrough
on
unit
testing
and
asp
net
core
application.
A
Some
things
I
like
about
this
one
is:
he
shows
off
using
the
test
toast
using
using
so
he's
got
an
X
unit
project
and
he's
using
the
test
host.
So
let
me
skip
down
to
that.
So
here's
his
test
project
calls
out
using
the
test
host
for
that
and
then
he's
doing
some
interesting
things
he's
pulling
in
some
libraries
like
Gen,
foo
and
fluent
assertions,
so
gen
foo
is
nice
because
it's
a
it's
a
nice
way
to
create
a
lot
of
test
data.
A
So
he
says:
I
want
you
know
a
bunch
of
test
people
and
you
know
here's
and
you
know,
create
all
those
and
then
he
also
uses
fluent
assertions
and
he
shows
off
some
nice
things
along
the
way
like
live
unit
testing,
so
you
know
showing
how
how
that
works,
so
I
believe
where's.
The
somewhere
in
here
is
the
gen
for
everything.
So
that's
that's
kind
of
cool
too.
So
this
is
kind
of
a
nice
getting
started.
It's
a
little
bit
more
than
file
new
project.
But
it's
simple
enough.
B
B
So
for
those
who
don't
know
we
released
well,
parvo
basically
did
and
the
arrest
of
the
signal
and
team
I
had
nothing
to
do
with
it.
A
signal
alpha
for
signal
of
for
a
zealot
net
core
now
signal
off
race,
but
on
that
core
is
a
complete
rewrite.
We
have
effectively
felt
like
them
effectively.
We
are
practically
rewriting
the
entire
system
from
the
ground
up.
B
Fowler
and
I
did
a
talk
about
this
build
earlier
this
year.
So
it's
worth
going,
have
a
look,
but
a
bunch
of
stuff
has
changed
since
then.
This
alpha
in
particular,
was
designed
to
work
on
a
spinet
core,
so
if
you're
using
a
snake
horde
Oh,
which
was
released
what
couple
months
ago
now
a
month
ago,
now,
then
this
is
designed
to
work.
B
On
top
of
that,
although
the
final
signal,
our
rtm
version
for
this,
will
actually
be
as
part
of
the
a
snit
core
2.1
release,
but
we
hoping
to
do
at
least
another
alpha
for
people
on,
oh,
so
that
we
can
get
some
feedback
before
the
first
one
preview
comes
out,
don't
ask
if
it's
production
ready
it's
an
alpha,
alright!
So
your
tolerance
from
production
is
your
tolerance
for
production,
but
I
am
gonna
say
this.
Is
production
ready?
It's
not
all
right.
It's
gonna
change!
It'll
have
bugs.
B
This
is
for
people
to
give
us
feedback
on
the
direction
that
we're
going
to
find
issues
that
we
may
not
be
aware
of.
As
specifically,
there
may
more
specifically
we're
obviously
interested
in
design
issues
more
than
actual
implementation
issues.
It's
an
alpha
after
all
and
we'll
find
the
implementation
issues,
but
we
want
feedback
on
the
design
and
the
direction.
So
please
do
try
it
out
if
you've
been
waiting
for
signaler
and
you
can
carve
away
some
time
from
your
normal.
Day-To-Day
it'd
be
great.
C
Right
about
changes
because,
as
daniel
said,
is
a
tree
right
and
we
decided
to
make
a
number
of
changes
that
you
know
remove
some
features,
add
new
features,
so
it's
not
the
same
thing
as
it
was
before,
and
also
because
of
that
it's
not
compatible
meaning.
He
cannot
run
the
old,
similar
client
with
a
new
server
or
vice
versa.
I
cannot
run.
Then
you
a
new
client
with
the
old
server
it
just
like,
won't
work,
so
you
can
try
and
I
I
tell
you
that
it
just
won't
work.
C
So,
let's
take
a
look
at
the
biggest
changes
that
we
made.
I
actually
wrote
this
announcement
for
the
Alpha
to
release
and
it
does
have
most
of
the
stuff.
So
I
will
just
go
over
it
and
a
little
bit
wrote
each
of
these
things.
First,
we
have
the
new
JavaScript
client.
This
was
one
of
the
biggest
pain
point
people
have
with
the
old
stock,
with
JavaScript
client
dependent
on
jQuery
and
this
dependency.
Many
people
didn't
need
the
amount
of
dependency
and
it
also
made
it
difficult
to
take
the
JavaScript
client
outside
the
browser
browser.
C
So
now
we
don't
fjq
anymore.
The
new
client
is
written
in
typescript,
so
it's
much
nicer
to
use
that
you
have
a
type
Street
application.
You
can
just
use
it
and
it's
very
nice
to
use.
We
also
change
the
way
we
distribute
the
client
with
the
main
distribution
Meccans
for
the
new
client
is
npm,
so
we
know
ship
on
NPM
and
you
use
NPM
to
install
the
client.
C
We
are
planning
to
put
it
also
on
CDN,
but,
as
I
said,
like
NPM
is
the
main
way
to
consuming
the
client,
and
it
does
have
both
JavaScript
version
for
browsers
and
typescript
that
you
can
use
the
idea
of
a
type
suit
project
now,
with
regards
to
the
features
of
the
server
and
the
and
one
of
the
things
that
we
dropped.
Support
for
is
automatically
connects
before.
C
If
a
connection
was
dropped,
you
could
identify
with
try,
reconnecting
and,
even
though
successful,
then
the
server
would
replay
or
the
message
was
the
missed
messages
it
had
to
the
client.
This
issue
is
no
longer
that
they're,
basically,
the
the
old
feature
was
seem
to
be
very
useful,
but
the
cost
to
pay
was
very
high
and
you
still
had
to
hunger.
Reconnect
yourself
in
cases
where
the
client
could
not
be
connect
within
the
time
window.
C
C
Going
to
explain
so
basically
because
the
server
the
server
I
needed
needed
to
keep
a
buffer
with
messages
to
be
able
to
reply
the
message.
Instead,
you
know
in
case
of
reconnect
so
basically
for
each
connection.
The
server
contained
a
ring
buffer,
which
was
the
default
size,
was
1,000
messages
and
whenever
a
message
was
sent
to
the
client,
it
would
be
stored
in
his
bathroom
right.
C
So
now,
when
the
client,
when
the
connection
was
drugged
and
the
bank
was
reconnecting,
that
the
server
could
go
back
and
check,
you
know,
and
just
we
send
messages
that
it
was
buffering.
But
imagine
even
if,
like
many
thousand
connections
connected
to
a
server,
and
each
of
them
contains
this
buffer
of
1000
messages,
it
basically
did
the
memory
used
by
the
signal.
Arthur
was
very
high
right,
so
people
were
complaining
that
similar,
it
was
leaking
and
was
oftentimes
was
because
of
these
buffers.
C
Also
the
client
and
the
server
had
to
we
had
this
thing
called
core
source,
which
basically
told
it
was
the
point
in
time
or
the
ID
of
the
last
message
that
was
received.
So
the
clients
thought,
when
a
client
received
a
message,
it's
to
do,
store
the
I
D
for
this
message
of
the
cursor
and
if
reconnects
happen
it
would
have
to
it
would
send
this
the
server
and
the
server
would
start
replaying.
The
message
is
starting
from
this
from
this
course
all
right.
C
One
thing
that
was
interesting
is
that
you
have
this
replay
message
replay
feature,
but
if
you
decided
to
make
the
buffer
smaller,
you
had
a
lot
of
messages,
you
would
still
lose
messages.
You
could
still
lose
messages
when
you
are
disconnected
because
if
the
buffer
was
a
ring
buffer
mean
all
this
message
would
be
overwritten
by
the
newer
one,
newer
ones.
So,
basically,
what
will
happen
is
that
if
you,
if
you
lost
more
than
you,
know
the
worth
of
the
size
of
the
buffer
messages,
then
you
would
just
through
some
of
the
messages
completely.
C
So
it
was
a
nice
feature,
but
not
really
working
and
required
a
lot
of
work
on
on
the
other
side.
So
we
decided
we
need
to
take
it
from
the
server
so
that
it
is
much
faster.
It
doesn't
use
as
much
memory
and
it
still
can
be
implemented
on
you
know,
by
by
by
the
client,
by
by
the
customer,
we
are
trying
to
come
up
with
some
ways
that
will
make
it
easier
to
implement
by
the
user
if
they
need
any
dysfunctionality.
C
So
this
one
of
the
one
of
the
big
one
of
the
big
changes
that
we
made
another
big
change
that
we
made
was
externalizing
scale-out,
basically
again
in
signal
are
in
this
old.
Similar
version
scale
goes
built-in,
whether
you
use
it
or
not.
The
home
signal
or
server
was
built
built
around
in
message,
bus
and
you
had
to
pay
the
cost,
for
you
know
having
this
message,
bus
or
being
able
to
spit
out
an
application.
C
The
thing
was
that
this
Kellogg
was
supposed
to
work
for
everyone,
but
it
turned
out
that
each
application
like
if
you,
if
you
try
to
run
application
on
multiple
servers,
there
is
no
one
way
to
scale
out
the
application
right,
so
something
that
was
supposed
to
work
for
everyone
basically
work
from
really
so
we
realized
and
you
had
to
pay
the
cause
right.
So.
B
B
For
these
specific
types
of
solutions,
depending
on
the
type
of
application
you
have
or,
and
so
whether
that's
message
replay
when
a
client,
you
know,
gets
a
blip
in
their
logical
connection
or
whether
it's
the
way,
the
application
scales
out,
there's
a
few
other
ones
as
well.
I
I
think
what
we'll
end
up
with
is
a
more
core
product
in
some
ways
like
there'll,
be
less
things
that
it
does
for
you
out
of
the
box
without
you
have
to
think
about
it.
But
the
reality
is
with
this
type
of
framework.
B
Obviously,
because
reality
is
connections,
you
know,
physical
connections
are
going
to
come
and
go
all
the
time
depending
on
network
conditions,
and
you
need
to
design
for
that
depending
on
what
your
application
does
and
then
there
are
other
little
things
that
we
got
rid
of
like
hub
state,
which
was
you
know,
little
used
to
didn't
really
provide
a
lot
of
value,
but
it
complicated
the
protocol.
You
know
the
way
the
messages
were
separating
the
server
in
the
client,
and
so
that's
kind
of
the
theme
here
and
then
there's
details.
C
One
more
thing
that
is
important
in
the
same
kind
of
theme
is
that
we
now
require
the
clients
to
be
the
discussions
to
be
sticky,
meaning
the
client
can
only
be
connected
to
one
server
and
it's
kind
of
similar,
it's
kind
of
ready
to
reconnect
first
and
then
also
it's
ready
to
the
thing
that
war,
the
world
has
moved
like
the
original
version
of
similar
one
will
when
it
was
designed,
we
kind
of
thought
about
the
world
as
in
terms
of
long
Pauline.
Now
we
won't,
we
actually
prefer
to
think
out
the
world.
C
You
know
it's
a
WebSocket
right,
so
you
just
open
the
connection
and
it's
open
to
the
server.
It
makes
much
easier
to
reason
about
the
system
overall,
for
instance,
with
the
old
version,
with
your
version.
When
you
have
free
connects
and
connections
who
are
jumping
the
server,
you
will
have
multiple
on
disconnect
messages
for
the
same
connection
and
people
couldn't.
You
know
why
it
was
the
case
on
how
kind
of
the
situation
now,
if
everything
is
clear
either
the
connection
is
connected
to
the
server
or
it
isn't.
C
It
also
is
very
interesting
in
in
case
when
you
have
to
scale
up
your
application,
because
if
you
know
that
the
connections
thanks
to
a
server,
you
know
whether
to
broke
as
a
message
to
the
you
know,
we
want
to
send
a
message
to
a
different
connection.
If
it's
on
the
same
server,
you
don't
need
to
send
it
to
other
servers,
so
you
know
just
so
that
the
message
reaches
the
client.
C
If
you
just
know
that
the
client
is
connected
connected
to
the
server,
so
you
just
send
a
message
directly
to
to
the
to
the
connection
without
broadcasting
to
each
server
saying
hey,
try
to
send
to
this
client
because
I
don't
know
where
it
actually
is
alright.
So
these
are
the
the
bigger
biggest
changes
that
we
I
decided
to
make.
These
are
the
breaking
changes.
Now,
let's,
let's
talk
a
little
bit
about
new
features
at
the
D
are
added,
so
one
of
the
teachers
is
support
for
custom
protocols
and
binary
protocol.
C
C
in
general,
this
was
currently
that
you
can
implement
a
custom
protocol.
We
we
keep
all
the
interfaces
in
the
so-called
optimal
way,
meaning
they
are
public,
but
you
have
an
internal
namespace.
We
shipped
the
product
out
of
the
box
with
support
for
two
protocols.
One
is
Jason
base
and
the
idea
is
message
bug,
base
and
message.
C
Bot
is
a
binary
protocol,
so
this
is
one
of
the
ways
we
wanted
to
make
it
to
make
sure
that
it's
actually
possible
to
write
a
custom
protocol
and
also
you
know,
people
were
asking
for
for
binary
protocols,
especially
in
the
in
the
previous
version.
The
size
of
messages
was
could
be,
the
messages
could
be
pretty
big,
so
people
were
asking.
How
can
I
make
them
smaller,
and
in
this
version
we
first
would
redesign
the
protocol.
C
The
important
thing
is
that
the
protocol
is
actually
documented
on
github,
so
we
have
a
spec
with
a
protocol
and
it
describes
all
the
messages
and
you
know
how
to
how
to
encode
the
messages
how
they
probably
look
on
the
on
the
wire,
depending
on
the
on
the
protocol.
You
use,
for
instance,
here,
are
the
messages
for
how
to
loop
when
you're
using
message,
part
or
some
here
are
how
they
look
Jason.
C
So
it's
not
like
before
where
people
were
asking
hey,
what
do
these
all
I
saw,
Rams
or
C
mean
in
the
in
the
messages
that
I
see
when
I
open
the
developer
tools.
So
now
the
protocol
is
fully
described.
I
think
you
know
you
can
you
can
think
about
the
expect
I
think.
Actually,
this
is
the
feature
of
the
of
the
product
to
have
like
clearly
described
protocol.
Another
thing
that
we
added
is
streaming
methods,
so
basically
the
server
can
send
a
stream
of
data
to
the
client
and
it's
not
like.
C
C
C
These
days,
we
just
send
an
options
request
which
contains
some
data,
but
if
you,
if
you,
if
you
are
using
WebSockets,
you
don't
need
to
send
this
ferrocene
shot,
HTTP
request.
So
basically
we
have
a
WebSocket.
You
can
connect
to
the
server
and
start
start
sending
messages.
We
we
have
this
demo
called
social
weather
where
we
show
how
to
use
signal
are
with
the
WebSockets
and
one
of
the
clients
is
a
client
running
on
the
node
MCU.
The
weapon
board
is
it
has
an
ATS
v8
266
chip
which
basically
provides
the
Wi-Fi.
C
You
know
further
for
the
board
and
then
the
board
itself
is
using
Lua
and
we
just
connect
from
Lou
I
using
WebSockets
to
similar
seven
are
able
to
send
and
receive
messages,
so
they
simplified
and
we
are
going
to
take
it
a
bit
further
internally.
The
client
currently
is
using
options,
even
if
using
whip
so
pensive.
You
are
thinking
about
removing
this
completely,
because
this
is
we
know
we
are
sticky.
The
website
is
just
you
know,
a
pipe.
We
have
a
pipe.
We
don't
need
another
site
information.
We
can
send
and
receive
messages.
C
C
It
makes
the
model
easier
and
again,
like
conceptually,
you've
got
like
people.
Actually,
the
vast
majority
of
people
thought
about
similar
connection.
Is
you
know
it's
a
single
app,
so
we
basically
made
it
happen
and
we'll
see
how
it
goes.
I
think
it
is.
If
you
see
you
need
multiple
apps
per
connection.
I
think
it
is
possible
to
build
some
master
layer
on
top
of
that
and
we
might
need
in
my
hair
the
sample
or
something
that's
showing
how
we
can
you
can
do
that.
The.
D
B
D
C
By
having
a
dispatching
up
on
the
server
side
and
kind
of
proxy
approach,
you
come
to
power
on
the
client
side,
and
you
can
say
when
you
start
the
collection,
you're
always
concerned
on
some
data
in
the
Indus
Mike.
So
you
can
provide
if
you
need
more
data.
If
the
seven
is
more
data,
the
client
can
provide.
D
C
C
C
C
Okay,
let's
go
to
the
side.
I
will
call
my
other
Chrome
so
that
I
know
who's
talking.
Let's
see
it
works,
so
this
is
the
well-known
Sun
application
in
the
new
new
form
kind
of
introducing
her
the
new
server
and
the
new
new
client
I,
actually
wrote
a
blog
post.
I
wrote
two
blog
posts
in
our
client.
The
first
one
is
my
experience
of
taking
the
I
feel
that
the
application
from
the
tutorial,
which
is
here,
is
the
tutorial
for
the
alt
for
the
previous
version.
C
C
C
We
no
longer
use
asp.net
namespace
new
signals
in
the
asp
net
core
names,
but
that
this
is
basically
the
same
thing
and
then,
let's
take
a
look
at
the
so
that
the
Java,
the
HTML
code
is
again
like
just
copied
directly
from
from
here.
Only
there,
because
I'm
using
my
cotton
I'm
using
now
typescript
I,
don't
have
this
JavaScript
code
in
HTML
and
I
converted
it
to
typescript.
C
Ok,
so
this
is
the
typescript,
and
this
is
how
you
can
see
how
you
use
the
connection.
You
need
to
create
a
new
hub
connection,
and
then
you
subscribe
to
hundreds.
So
whenever
I'm
client-side
method
is
being
invoked,
you
you
will
be
called
on
your
your.
Your
Hana
will
be
called
in
register,
accusing
on
their
own
method
all
day
on
the
client,
and
then
here
is
how
you
start
the
connection.
We
are
using
promises,
so
you
have
then-
and
you
know,
Koch-
to
cause
exception,
then
to
run
a
continuation.
C
Actually,
if
you
are
using
titrate
and
I
will
show
this
in
a
different
client,
you
can
use
async
await.
This
is
the
feature
of
typescript.
It
makes
it.
You
know
it
makes
your
code
much
easier
to
write.
It's
much
more
linear
is
very
similar
to
c-sharp
async/await
feature
what,
whereas
promises
are
actually
very
close
to
the
C++
Perl
task
library,
where
you
have
again
similar
cuz
you,
you
attach
a.
C
So
this
is
how
you
start
the
connection
and
then,
after
we
start
the
connection
we
send
we
attach
to
the
clinic
and
whenever
a
user
clicks
you
know
right
now,
my
subscription
click,
the
send
button
will
invoke
the
server
and
then
the
method
on
the
server
side,
and
it's
pretty
much
it.
So
this
is
my
this
is
my
brother
client,
but
I
also
wrote
the
note.
C
That,
because
with
the
removal
of
jQuery,
we
are
now
able
to
make
to
take
the
client
outside
the
browser
browser
and
one
of
the
one
of
the
I
think
you
know
environments
people
were
interested
in
running.
The
client
was
no
js',
so
I
just
I've
got
this
small
client.
Now
and
again,
like
I
I
used
typescript
I
personally
wrote
it
in
JavaScript
and
then
converted
the
JavaScript
to
typescript
and
again
I
know
the
post
about
that.
C
C
And
he
you
can
see
that
the
try,
the
don't
client,
receive
the
chrome
message,
so
things
were
meant
to
and
I
actually
yesterday
debug
react
native
up.
Someone
had
problems
with
running
the
client
in
react
native
and
was
running
in
an
iOS
emulator
on
on
mark
and
I
was
able
to
make
it
work,
so
define
the
can
work
outside
the
outside
the
browser.
C
One
thing
one
important
thing
that
when
using
note
is
that
the
client
does
not
have
core
definition
jQuery
or
on
the
browser's,
but
it
C
uses
some
some
libraries
that
typically
are
available
in
browser
browser,
but
not
nothing.
Now,
for
instance,
we
need
to
send
like
a
HTTP
request
or
if
you
have
WebSockets,
these
are
not
available
by
default,
but
you
can
polyfill
them
so
in
this,
in
my
case,
I
just
I
just
turn
on
the
global
object
and
then
they
they
this
way
they
become
available.
C
We
are
thinking
about
changing
this
because
it's
it's
a
bit
right,
so
we
are
thinking
how
we
can
I
know.
Maybe
we
can
use
some
dependency,
injection
or
constructor
injections,
or
you
can
set
some
of
these
in
your
in
the
options
when
you
start
the
connection-
and
this
is
what
we
use
so
that
you
don't
have
to
stick
things
on
the
global
object,
so
this
was
the
child
application.
Now,
let's
take
a
look
at
the
stock
ticker.
C
C
B
Music
jQuery
back
in
the
day,
but
then
Brandon
has
updated
it
now
to
not
use
jQuery
and
believe
he's.
I
asked
him
to
use
CSS
animations.
Believe
that's
what
he's
doing
now.
We
tried
say
it
as
transitions,
but
it
wasn't
powerful
enough
to
get
the
effect
we
have
here.
So
we
are
doing
full-on
CSS,
animations,
Wow,
yeah
I.
Guess
we
could
have
done
an
SVG
to
go
really
all
out,
do
an
actual
graph
and
have
a
hairdo
pretty
right.
B
Want
to
do
a
live
version
of
this
I.
There
should
be
a
button,
it's
like
connect
and
you
have,
but
you
have
to
be
more
in
the
demos
like
if
they're
like
put
in
a
yahoo
key
or
something
like
I'm
assuming
most,
those
api's
would
require
you
to
have
a
authentication
of
some
sort,
but
it'll
be
nice
to
actually
have
a
live
one
rather
than
this
canned
one
that
we
do
assets
I
under
the
random
number
generator.
C
C
We
take
a
few
seconds
to
start
alright
and
there
you
go.
You've
got
the
stock
prices
being
elevated.
Like
so
I
think
you
know,
we
have
all
the
samples
people
can
start
and
play
and
ask
questions.
I
created
a
new
tag
on
Stack
Overflow
signaler
core.
It
makes
it
easier
because
api's
are
similar
and
sometimes
sometimes
I
was
not
sure
where
people
were
asking
about
the
the
old
version
or
the
new
version.
C
So
if
anyone
is
asking
questions
on
Stack
Overflow,
please
your
signal
underscore
for
the
new
similar
and
the
similar
for
the
for
the
previous
version
file
issue.
Try
it
and
file
issues
on
github
I'm,
like
we
are
looking
into
these
issues,
because
we
want
to
make
it
really
solid.
It's
much
easier
to
use
much
as
you
understand
conceptually
how
it
works
it
may
need.
It
may
require
more
work
on
the
user
side
to
get
support
for
some
features
that
we
decided
to
remove.
Yeah
I
think
it's
pretty
much.
What.
C
B
We
basically
want
to
enable
people
to
add
things
on
top
of
the
new
base
functionality,
and
that
means
that's
why
we
really
that's
why
we
went
to
this
work
to
put
now
four
out
onto
our
rather
than
waiting
for
the
two
one
wave
like
a
lot
of
this
requires
now
that
we
have
a
strict
protocol.
That's
documented,
and
we
have
multiple
implementations
that
protocol
have
to.
A
B
Our
connection
would
be
perfect
for
that,
because
signal
or
isn't
point
isn't
peer-to-peer
signal
is
very
much
client-server
or,
and
you
know
we
have,
we
have
symmetry
now
the
the
protocol
is
bi-directional,
whereas
it
wasn't
fully
bi-directional
before
some
features
are
only
available
in
one
way,
but
the
protocol
now
supports
basically
all
features
of
both
directions.
No
matter
who
establish
the
connection,
which
means
you
can
do
things
like,
have
the
server
call
a
method
on
the
client
and
get
a
response
which
we
never
supported
before
now.
B
That
said,
it
doesn't
mean
it's
a
peer-to-peer
technology,
because
that
requires
like
support
in
the
browser.
Now
is
it
possible?
We
could
build
a
web
RTC
transport
such
that
you
could
basically
start
a
signal.
A
client
in
one
browser
have
go
to
the
server
negotiate
with
the
other
client
that
you're
actually
trying
to
address
and
then
kind
of
do
the
link-up
for
you
all
transparently,
so
that
you
know
you're
just
using
the
signal
or
API
you
end
up
with
a
stream
to
the
other
browser.
Possibly
we
could.
We
could
certainly
look
at
there.
B
Things
like
that
for
now.
I
think
what
you'll
see
us
do
is
we'll
at
some
point,
we'll
put
together
an
example
of
what
it
means
to
use
signal
log
with
WebRTC
to
build
a
video
chat.
App
like
this
or
you
know,
just
an
audio
chat,
app
or
something
like
that,
but
they're
different
technologies
for
the
different
purposes.
Right
now,
what
was
the
other
one?
Okay,
yeah.
A
B
B
So
authorization
is
exactly
the
same.
You
use
the
authorize
attribute
on
your
hub
method
or
on
your
hub
class,
and
we
it
results
in
that
thing
challenged
or
requiring
authentication.
Depending
on
what
policy
you
provide
that
we're
still
discussing
in
issues
around
how
you
actually
do
authentication,
because,
if
you're
not
using,
if
using
cookies,
it's
all
pretty
straightforward
and
you're,
not
using
cookies,
which
is
you
know,
often
best
practice
for
when
doing
sparse
or
any
type
of
JavaScript
access
from
the
browser.
B
Things
are
a
little
more
complicated
because
WebSockets
doesn't
allow
you
to
send
anything
in
the
header
any
in
custom
headers
from
the
WebSocket
JavaScript
API,
like
it's
just
not
possible,
there's
literally
no
way
to
set
a
header,
and
so
the
only
mechanism
you
have
for
sending
data
is
in
the
query
string
of
the
URL
or
over
the
WebSocket
channel
itself.
Once
it's
been
established,
so
we
are
exploring
both
of
those
the
query
string.
One
is
pretty
well-known.
B
Like
you
know,
you
should
be
using
HTTP
anyway,
regardless
of
this,
but
you
should
be
using
HTTPS
once
using
HTTP.
The
entire
connection
is
encrypted,
which
means
that
the
query
string
is
is
opaque
to
anyone
between
the
browser
and
the
server
like.
No
one
can
see
the
token
that's
going
through
the
query
string,
because
the
query
string
is
part
of
the
encrypted
channel.
B
That
said,
the
query
string
itself
will
get
logged
in
the
server,
because,
if
you
have
web
server,
logging
turned
on
the
full,
URL
will
often
get
logged
and
so
the
token
will
leak
into
logs
up
there.
And
but
this
is
not
a
unique
problem
for
signal.
This
is
a
WebSockets
issue
in
general.
So
the
the
token
in
the
query
string
approach
works.
B
The
sending
the
token
is
the
first
payload
over
the
actual
WebSocket
once
is
established
would
work
in
theory,
we've
never
actually
written
that
sample
I've
often
talked
about
us
doing
it.
In
fact,
they've
brought
it
up
again
in
this
issue.
I
think
we
should
do
that
and
just
demonstrate
whether
it
if
I
figure
out
whether
it's
even
possible
and
if
it
is,
is
that
some
type
of
a
boilerplate
that
we
could
codify
a
little
better
into,
maybe
not
first
class
but
at
least
have
a
good
example.
That
shows
you.
A
E
A
A
E
C
B
On
the
server
side
of
the
client
side,
so
on
the
client
side,
you're
limited
by
whatever
the
transport
it
is
that
you're,
connecting
with
on
the
server
side,
you
could
put
middleware
in
front
of
the
8-minute.
You
know
the
signal,
our
sockets
middleware
and
fiddled
with
the
request
before
we
get
it,
but
yeah
that
doesn't
really
change
but
like,
as
we
just
said,
WebSockets,
you
can't
change.
Headers
like
this
is
not
available.
It's
nothing!
You
can
do
a
bench
source.
You
can't
change
headers.
B
B
0
7
right
now,
none
we
did
a
couple
of
investigations,
a
couple
of
sort
of
experiments
on.
Could
we
just
get
rid
of
hubs
completely
and
do
everything
in
controllers
and
they
fell
flat
for
a
few
reasons.
That
said,
there's
a
lot
of
subsystems
of
MVC
like
model
binding
and
input
validation,
and
those
type
of
things
that
would
you
know
obviously
would
make
sense.
B
Don't
think
you'll
see
that,
but
maybe
in
some
super
future
version
of
a
spinet
core,
where
more
of
the
MVC
isms
become
more
of
the
core
like
dispatching,
which
we're
talking
about
doing
four
to
one
which
is
kind
of
routing
in
the
core
and
the
idea
of
RPC
bought
model
binding
and
those
type
of
things
being
in
the
core.
Then
we
would
be
able
to
reuse
them,
but
probably
not
for
now
great.