►
From YouTube: A QUIC Update - Trivikram Kamat
Description
A QUIC Update - Trivikram Kamat
The QUIC and HTTP/3 protocols are currently being developed by the IETF. While they are busy working, we've been busy working on an implementation within Node.js core. This presentation will introduce the protocol and the implementation and update on where things are at!
A
Welcome
to
node.js
interactive.
This
is
a
talk
on
STP.
Three
quick
update.
Remember
that
this
is
experimental,
so
do
not
try
it
in
production.
If
you
try
it
in
production,
do
not
blame
me.
My
name
is
Sriram
Kamath
I'm,
so
Fidelma
engineer
my
twitter
handle
is
three
week
RAM
and
data
handle
is
three
week
AR.
A
A
For
node.js
in
directive
is
hashtag,
not
this
interactive.
If
you're
active
on
social
media,
you
can
also
use
HTTP,
3
or
quick.
If
you
like
this
talk,
if
you
did
like
this
talk,
then
use
my
name
and
what's
my
name
again,
most
of
you
will
have
forgotten
so
I'll
give
like
clue.
Ok,
so
we
are
in
Canada
and
it
is
very
cold
and
you
will
be
knowing
this
drink.
It's
called
rum.
It
gives
a
lot
of
warmth.
So
imagine
a
weak
rum,
not
a
strong
rum,
a
weak
rum
and
add
3
in
front
of
it.
A
That's
my
name!
So
what's
my
history
with
not
just
I've
been
using
node.js
for
4
years
now,
I
started
contributing
to
node.js
code
in
October.
2017
helped
make
a
trip
to
stable,
write,
wrote
unit
test
and
fix
some
bugs.
You
can
do
the
same
with
STP
three
will
cover
that.
I
became
node.js
code
collaborator
in
March,
2018
and
I
organized
a
mentor
for
code
n,
LAN
events.
What
are
we
going
to
cover
in
this
talk?
We
are
going
to
cover
what
is
STB,
1.1
and
y
acp
to
was
required.
A
A
So
I
would
like
to
thank
James
Snell,
who
is
here
he's
not
just
a
technical
sharing
company
member
and
heading
the
work
on
implementing
quick
thanks,
James
and
I.
Like
also
like
to
thank
the
sponsors
for
his
work,
it
is
protocol
labs
and
near
forum
I'll
also
like
to
thank
Anna
Henningsen.
As
James
says,
she
fixes
the
books,
which
he
introduces
and
I
also
thank
Daniel,
one
young
and
many
others
who
have
contributed
too
quick
already.
I,
also
like
to
think
that's.
You
know
that's
what
your
son
for
his
awesome
work
in
NGTC.
A
A
It
was
just
one
line:
protocol,
okay,
you
get
my
page
or
HTML.
You
send
get
my
page
Waterman
and
you
get
my
beta
rest.
Raymond
awesome
right,
like
life
was
so
simple
back
in
1991,
but
things
had
to
get
complicated,
so
I
step,
II
wondered
Oh
dot
introduced
in
May
1996
and
it
will
extensibility.
Let
us
see
what
it
did.
Ok,
this
have
you
send
request.
This
is
what
the
response
you
get
so
now
you
can
send
version
information,
because
now
there
is
more
than
one
HTTP
protocol.
A
You
also
send
browser
information
because
there
are
multiple
browsers
and
then
you
send
status
code
because
not
all
requests
are
successful.
Sometimes
the
redirect
backs
sometimes
client
error.
Sometimes
your
server
error.
Then
there
are
headers
who
did
information?
What
kind
of
server
is
there?
Ok,
what
kind
of
content
type
so,
instead
of
sending
content
text,
you
can
even
send
JSON
and
other
types,
and
then
we
could.
We
could
include
multiple
resources
in
the
HTML
file,
so
in
this
HTML
file,
that
is
an
image
being
used.
A
A
So
first
improvement
was
precision,
persistent
connection
in
which
you
can
use
single
TCP
connection
to
send
and
receive
multiple
requests
and
responses
which
are
serial,
not
the
concurrent
ones
which
are
serial,
and
there
was
pipelining
in
which
second
request
can
be
sent
before
the
first
one
is
fully
transmitted
and
there
was
chum
transfer
encoding
and
there
was
additional
cache
control
mechanism.
There
is
content
negotiation.
We
will
see
what
were
the
issues
with
HTTP
1.1.
A
A
A
So
let
us
understand
this
by
going
through
the
code,
because
talking
is
boring.
So
let
us
see
the
code
if
you
attended
matias
talk
on
streams
you
mentioned
today
that
do
not
use
pipe
because
it
uses
memory
leaks
anyway,
you
use
some
framework
yeah,
but
here
we
are
just
writing
normal,
create
a
strictly
typical,
eight
server.
So
if
a
request
URL
is,
has
just
written
index,
if
it
is
style,
dot
CSS
hit
return
that
okay,
that's
it
so
I'll
just
made
it
simpler.
A
So
if
request
URL
is
the
home
page,
written
index
or
HTML,
and
otherwise
just
a
regular
expression
which
reads:
what's
the
file
name
is
and
return
that
file
name
from
the
files
folder.
Okay,
let
us
go
through
the
code
because
it
is
important.
We
will
see
how
it
works
in
STP,
one
and
two
and
three
so
index.html.
You
input
style
at
the
top
okay,
then
you
import
an
image
in
the
body.
A
A
That
it
finds
the
name
and
change
it.
It
changes
it
to
know
just
interactive
because
we
had
no
just
interactive.
So
it's
a
hello
note,
yes
interactive
and
it
will
change
the
image
and
upload
a
page
to
notice
inductive
image
cool,
that's
after
a
second
yeah
after
one
cycle
wait
for
second-
and
this
is
just
a
globe
image-
so
let's
see
how
it
looks.
A
A
So
below
I
have
a
command
telnet
command,
which
looks
for
how
many
TCP
connections
are
created.
When
you
say
that
request
is
sent
for
localhost,
only
one
TCP
connections
are
created,
it
shows
three
records,
but
only
one
is
created,
but
then,
when
it
has
to
make
three
concurrent
requests,
you
can
see
multiple
TCP
connections
I
created.
That
is
the
issue
with
STP
1.1.
A
A
You
saw
that
three
requests
a
send
for
three
resources
and
steppy
1.1
in
STP
to
only
one
PCP
connection
is
created,
although
all
three
surfaced,
so
let
us
see
how
it
works.
So
we
write
by
step
into
server,
so
you
create
a
server
and
then,
if
it
is
slash,
you
would
get
an
index
for
xtml
and
otherwise
you
get
the
regular
extra
flex.
A
So
if
you
examine
using
the
network
tab,
it
will
be
same
as
HTTP
1.1.
Only
in
the
protocol
column,
you
will
see
that
H
2
is
used.
Okay,
so
you
don't
see
that
how
many
TCP
connections
are
used
so
I
go
to
the
next
slide
and
I
watch
for
TCP
connections
using
next
read
command
and
you
will
see
that
only
one
TCP
connections
are
created,
although
three
requests
are
sent
simultaneously.
A
So
let
us
see
the
benefits
of
HTTP.
We
saw
the
one
in
benefit
which
is
multiplexing
and
concurrency,
so
different
HTTP
requests
are
sent
on
to
the
same
TCP
connection,
but
there
are
some
other
benefits
also
like
stream.
Dependencies
splines
can
indicate
to
server
which
dependents
are
important.
There
is
H
pack
header
compression
where
it
reduces
the
length
of
the
header
field
and
codings
by
exploiting
the
redundancy,
because
headers
have
lot
of
redundant
code,
so
it
can
be
encoded
and
there
is
server
push.
A
server
can
send.
A
Resources
with
clients
have
not
requested
yet,
but
you
will
not
go
through
that
in
detail.
We
will
just
see
the
issues
it
actually
p2,
because
if
there
are
no
issues
we
ship
into
a
ship
III
will
not
exist.
So
let's
say
the
first
issue:
each
pack
is
stateful,
so
the
encoding
and
decoding
tables.
How
do
we
maintain
at
the
end
point
so
because
of
which
so
what
happens
on
each
packet
is
sent
first
time
it
encodes
something
and
when
second
packet
is
sent,
it
will
use
the
encoded
content.
A
It
will
send
a
new
content
only
if
there
are
some
changes.
So
that
is
one
issue.
Delta
encoding
is
used
in
header
compression,
so
this
causes
high
resource
consumption
in
Braille,
tired.
Then
it's
not
easily
routable
along
the
network
and
the
main
issue
which
we'll
discuss
in
today's
talk
is
disappear,
head
of
line
blocking.
So
what
is
the
CP
head
of
line
blocking
when
a
single
TCP
packet
is
lost
or
corrupted?
All
subsequent
packets
are
blocked
until
the
last
one
can
be
successfully
transmitted
in
HTTP
1.1.
A
If
this
happens,
you
are
blocking
only
one
request,
because
there
is
only
one
request:
HTTP
request
sent
or
a
TCP
connection,
but
in
HTTP
2,
since
multiple
requests
and
responses
has
carried
over
a
single
TCP
connection,
all
those
request
responses
will
be
blocked.
So
let
us
understand,
understand
this
using
uh-oh,
so
yeah.
So
before
that
we
will
see
where
this
effect
is
most
very
severe
is
more
significant.
It
is
more
significant
on
high
latency
networks,
which
are
long
distance.
A
So
if
it
is
high,
latency
probability
of
packet
getting
lost
is
more
or
on
mobile
connections
where
probability
of
getting
packet
loss
is
more.
So
we
will
understand
this
using
a
chain
metaphor.
So
this
is
a
chain.
Imagine
these
a
TCP
connection
between
two
computers
and
what
I
am
done
is
I,
put
green
colors
and
red
colors.
Wear
green
color
considered
that
CSS
pocket
and
gallery
jsj
expected
wear.
Css
and
JS
files
are
requested
over
the
same
pacific
connection.
A
If
a
J's
packet
is
lost
or
corrupted,
then
the
entire
chain
is
broken,
so
the
entire
chain
posts
that
J
expected,
which
includes
a
circuits,
have
to
be
sent
again.
This
is
explained
very
well
in
HTTP,
3
explained
if
you
want
more
details,
so
what
does
HTTP
3
over
quick
does
so
this
is
a
draft
24
as
of
December
2019.
A
So
what
it
does
is
that
when
it
is
setting
up
multiple
streams
over
quick
connection,
they
are
deterred
independently,
so
that
if
any
packet
goes
missing
in
one
of
the
streams,
only
that
stream
has
to
pause
and
wait
for
the
missing
packet
to
get
transmitted.
So
to
understand
this,
let
us
see
the
chain
analogy
in
which
this
CSS
stream,
this
J's
stream,
if
the
J
stream
packet
is
lost,
the
CSS
stream
is
not
affected.
Now
we'll
say:
isn't
this
what
HDPE
one
was
doing?
Are
we
going
back?
A
A
Udp
packet
bar
box
in
did
you
get
it
now,
so
click
adds
the
volume
to
UDP.
Ok,
it
adds
error
handling,
it
adds
acknowledgment,
it
adds
flow
control,
it
adds
packet
sequencing
built
in
and
encryption
TLS
1.3
and
bi-directionally
directional
streams.
So
whatever
benefits
you
have
on
TCP,
those
goodies
will
come
to
quick,
amazing
right
and
quick,
also
reduces
round-trips.
Remember
we
saw
that
three
round-trips
per
request.
Who
has
time
for
that
so
in
UDP
it
will
take
on.
A
If
each
round
trip
takes
100
millisecond
in
quick,
it
will
take
just
hundred
millisecond
for
the
first
request
or
if
kleine
knows
the
server
already,
it
will
take
zero
millisecond.
So
before
we
write
that
step,
III
server
remember
this
quic
is
not
equal
to
HT
p3.
Ok,
this
terms
will
be
used
interchangeably,
but
they
are
not
the
same.
So
HT
p3
is
the
application
protocol
which
uses
quick
as
a
transport
protocol.
A
So
you
have
STP
3
on
top
of
quick,
then
on
top
of
UDP
and
then
IP
the
node.js
implementation
will
let
you
create
your
own
alternative
protocols
on
top
of
quick
one
place
where
we
are
considering
using
quick
is
for
inspector
protocol.
We
currently
use
WebSockets,
but
we
may
switch
to
quick
or
in
Diagnostics.
Similarly,
you
can
create
your
own
application
protocol
over
quick,
like
DNS
DNS,
might
also
use
quick.
So
let
us
say
the
STP
3
server.
A
Of
course,
when
you
request
slash
could
index.
Otherwise
you
request
the
file
name
and
you
load
the
web
page
and
you
and
you
get
this
site
can't
be
reached.
Why?
Because
it
is
experimental.
Ok,
you
cannot
use
it
in
production,
its
experimental,
but
we
have
done
lot
of
progress.
So
it
is
an
early
stage
of
development,
but
you
can
help
build
it.
You
can
help
build
it.
You
can
help
build
it.
How
go
to
node.js
with
so
these
are
progress.
We
currently
have
around
70%
done,
and
this
is
the
project
board
and
this
slightly
outdated.
A
But
you
will
be
wondering
oh,
like
I,
want
to
contribute.
I
can
see
all
the
excitement
in
each
one
of
your
eyes
that
you
want
to
contribute
to
quick,
but
you
will
be
wondering:
oh,
like
I,
don't
know
anything.
How
do
I
contribute
so
any
easy
right
test
start
with
writing
unit
tests.
It's
amazing!
When
you
write
unit
tests,
you'll
find
books
and
you'll
fix
those
books,
and
then
you
can
also
become
a
collaborator
like
me.
A
So
how
can
I
write
unit
text?
I
am
glad
that
you
asked
so
you
gotta
know
just
quick,
you
forget
and
then
you
clone
it.
Then
you
say
experimental
quick
because
it
is
experimental,
get
the
coverage
and
these
are
the
results
slightly
or
old,
but
this
is
what
we
have
for
JavaScript.
So,
if
you're
into
JavaScript,
you
can
help
writing
unit
tests
in
JavaScript
and
we
need
more
help
in
writing
C++
tests,
because
there
is
lot
of
code
in
C++
so
so
now.
This
is
how
to
contribute
to
quick
in
HTTP
3.
A
But
if
you
want
to
go
more
deep
and
contribute
to
the
protocol
itself,
then
STP.
The
protocol
is
a
ITA
IDF
draft
24
right
now,
so
you
can
join
the
meetings
and
suggest
so
we'll
just
will
still
see
an
example
web
page
on
quick
that
is
squid
dot
rock.
So
this
is
how
it
looks.
So
when
you
examine
it,
we
will
say
that
the
protocol
is
HTTP,
2
plus
quick.
So
let
us
go
through
demo.
The
node.js
did
not
build
on
my
machine.
B
So
this
is
one
of
our
tests
that
we're
using
and
I
have
debug
tracing
enabled.
Basically,
you
just
gonna
see
a
bunch
of
text
plant'
across
the
screen,
but
it's
a
client
talking
to
the
server
sending
a
copy
of
the
test
file
itself
back
and
forth.
Alright,
but
I
want
to
once
once
it's
through
I
want
to
point
out
a
few
things
that
it
are
we
seeing
the
results.
So
this
is,
you
know,
sending
all
the
UDP
packets.
B
Alright,
so
we
see
here
at
the
end
when
these
in
these
objects
and
all
this
information
is
available
to
the
JavaScript
layer,
but
we
have
here,
you
know
you
can
see
the
bytes
sent
right.
You
can
see
the
number
of
streams
that
were
created
if
you
scroll
up
here
a
little
bit
further,
we'll
see
that
you
know
how
many
bytes
were
received
on
a
particular
session
when
it
went
a
handshake
hard
to
win
it
when
it
completed.
This
is
all
information.
B
A
So,
let's
save
a
summary
of
what
we
learn
in
SCP
1.1,
multiple
TCP
plus
TLS
connections
were
required
for
concurrent
requests
in
SCP
2
added
multiplexing,
in
which
multiple
HTTP
requests
were
sent
on
the
same
TCP
connection
or
disappeared
off
line
blocking
in
which
is
is
the
one
in
which
the
entire
TCP
connection
is
brought
to
an
halt.
If
a
single
TCP
packet
packet
is
lost
and
STP
3
over
quick
treats
each
stream
independently,
so
that
if
any
packet
goes
missing
in
a
stream,
only
that
stream
is
affected.