►
From YouTube: IETF 105 Hackathon Montreal Project Presentations
Description
IETF Hackathons encourage developers to collaborate and develop utilities, ideas, sample code and solutions that show practical implementations of IETF standards. These are the presentations by the projects undertaken during the IETF Hackathon preceding the IETF 105 meeting in Montreal.
A
Well
from
the
Chromebook,
so
if
you
have
it
in
PowerPoint,
well
we'll
try
to
make
it
work.
It's
just
with
mine.
It
didn't
work!
So
well,
so
it's
safer!
If
you,
if
you
use
the
PDF
and
if
you
have
both
the
PDF
and
the
PowerPoint
up
there,
we'll
just
choose
the
the
PDF
when
it
comes
to
return
all
so
what
we're
going
to
do
is
download
from
the
repo
all
the
files.
So
we
have
them
locally
here.
A
If
you
have
not
uploaded
your
presentation,
yet
don't
panic
once
we
get
through
presenting
all
the
ones
that
that
we
do
have
we'll
go
back
and
get
ones
that
we
missed.
So
hopefully
we'll
give
everyone
a
chance
to
present
and
if
your
files
up
there
and
you
decide-
you
don't
want
to
present
at
the
time,
we
call
you
you
can
just
let
us
know.
A
A
A
A
Barry's
here
he's
going
to
be
helping
me
with
going
through
this
these
presentations
and,
like
I,
said
we
have
the
shared
Chromebook
up
here
that
we'll
all
be
using
we'll
give
you
a
little
guidance
on
how
to
use
it.
It's
fairly
straightforward
and
bear
with
us
as
we're
pulling
in
each
of
the
presentations.
Hopefully,
we've
got
it
working,
so
it
flows
pretty
well.
B
D
C
C
C
F
F
F
We
implemented
two
drafts
of
these
lost
measurement
bits
and
we
are
currently
developing
sort
of
reporting
of
loss
measurement
events
in
our
tool,
we're
also
integrating
this
into
some
testing
environments
using
it,
for
instance,
mininet
test
vm
that
we
can
use
to
test
a
lot
of
different
networks
scenarios.
Basically,
we
also
did
a
bunch
of
bug
fixes.
F
This
is
a
list
of
how
we
are
handling
different,
quick
versions.
So
previously
we
had
kind
of
nasty
structures
where
different
behaviors
based
on
different
quick
versions.
Basically,
we
had
go
into
every
function
and
and
and
check
which
person
it
is
now
we
have
generalized
this
quite
nicely
so
so
that
we
can
add
new,
experimental
versions
with
new
support
for
different
header
formats,
etc
and
and
yeah
make
it
much
more
dynamic.
Nice.
F
F
So
we
have
a
bunch
of
proposals
in
there.
What
did
we
learn
was
that
supporting
all
quick
versions
is
quite
demanding
it's
quite
demanding
too,
especially
when
we
have
a
protocol,
that's
evolving,
and
we
have
a
lot
of
experimental
proposals
to
have
a
nice
structure
of
handling.
You
know
all
of
these
different
cases.
F
We
see
that
both
these
loss
detection
proposals
have
measurements
in
real
networks
and
we
hope
to
be
able
to
to
facilitate
more
measurements
of
this.
But
yeah
problem
is
that
we
only
have
two
reserved
bits
and
to
reserve
bits
for
two
proposals
is
quite
not
that
much
so
this
was
done
with
me:
Marc
seller,
yari,
Arcos
investor,
Fabio,
Maru
and
Alex
Andre.
You
can
find
our
tool,
the
spin
dump
at
at
github
and
the
new
measurements
proposals
you
can
find
at
these
links.
So
yeah.
C
G
My
name
is
Sachin
vishwaroopa
I'm
from
Cisco
system
and
myself
and
of
us.
We
worked
on
the
PTP
notification.
I
am
for
the
first
time
for
ITF,
as
you
can
see,
as
you
can
see,
I
have
not
used
the
format
and
maybe
next
time
we'll
follow
the
same
thing
so
essentially
in
Cisco
I
work
on
IP
fabric,
as
some
of
you
may
or
may
not
be
aware.
But
these
days
the
paradigm
on
the
media
also
is
changing.
G
It's
moving
away
from
the
standard
SDI
to
IP
based
fabrics
and
that's
what
we
work
on
one
of
the
key
things.
There
is
the
PTP
as
the
synchronization
between
the
your
media
gateways
endpoints,
as
well
as
the
video
audio
sync
is
very
critical
and
the
accuracy
needs
to
be
less
than
500
nano.
Second,
and
that's
the
reason
we
use
PDP
with
the
PDP.
Today
we
actually
have
as
I
notice.
We
have
the
standard
for
the
yank
already
defined
like
RFC
85-75.
G
But
what
is
more
critical
for
us
to
is
to
get
the
notification
and
that's
because
of
the
number
of
syncs
which
are
involved
in
the
PTP
in
the
PTP,
like
in
the
precision
time
protocol
in
a
second,
we
typically
think
8
times.
So
we
cannot
expect
network
management
system
to
sync
and
find
out
the
deviation
from
those
samples,
because,
if
you
think
about
one
day
for
a
single
switch,
we
generate
around
700,000
the
sample
points,
and
so
we
want
to
do
it
in
a
distributed
fashion.
G
G
Okay,
this
slide
again
talks
about
the
synchronization
I
mean
earlier
when
we
star
on
the
audio
video
right.
If
you
are
using
a
lower
signal
or
maybe
think
about
like
Ultra
HD
HD
4k
8
K
now
the
buffer
cannot
be
that
big
right.
So
that's
reason:
synchronization
is
critical.
I
put
some
more
things,
but,
more
importantly,
you
can
think
like
audio
and
video
needs
to
be
insane
and
that's
what
we
have
been
working
on.
G
So
these
are
the
use
cases
what
we
wanted
to
address
it
in
the
hackathon,
so
essentially
for
the
live
event.
We
wanted
to
monitor
and
monitor
why
a
notification
again
be
depending
upon
the
media
profile,
the
the
duration
and
the
state,
all
those
parameters
need
to
vary
and
that
second,
we
wanted
to
do
the
configuration
as
well
as
generate
the
notification
sure.
G
So
in
the
hackathon
we
have
the
deliverables.
We
defined
today
take
a
PTP
egg
notification
model.
Again
we
need
to
remove
with
the
team
we
develop
a
third-party
application
on
Cisco
switch,
so
the
real
deliverable
here
was
a
Python
script
which
will
consume
on
the
switch
and
push
it
as
a
young
notification
to
the
existing
product.
We
have
like
a
network
management
solution
and
we
extended
that
to
introduce
a
new
REST
API
to
consume
that
notification
and
overlay
the
PTP
information.
G
On
top,
so
I
mean
it's
kind
of
a
chart,
but
I
am
sharing
the
slide,
so
you
can
see
the
example
payload
as
well
as
notification,
and
this
is
how
the
user
interface
looks
like
here.
What
you
are
seeing
is
a
swine
leaf
topology
with
Cisco
switches
and
based
upon
the
PTP
offset
threshold.
The
switches
at
the
runtime
are
color
coded,
so
based
on
the
notification
which
WebSocket
it
dynamically
updates
the
screen
so
based
on
the
number
of
sample
which
has
deviated,
we
actually
color
code,
those-
and
this
was
just
idea
just
to
demo.
G
That
part-
and
this
is
the
back
end
where
we
introduced
like
a
new
application
on
the
back
end
with
the
Python
script,
which
completely
integrates
with
the
cisco
CLI.
So
it's
as,
if,
like
a
original
part
of
the
cisco,
it's
coming
from
Cisco
and
you
can
monitor
and
control
the
notification
part
of
it.
So
that
was
the
idea.
The
whole
idea
is
to
take
the
notification
and
integrate
into
the
PTP.
Thank
you.
C
H
This
was
a
project
to
do:
IO
am,
which
is
in
situ
operations
and
management.
Basic
idea,
if
you're
not
familiar,
is
to
have
an
ipv6
extension
header
hop-by-hop
option
that
contains
an
IO
am
option,
which
is
information
that
the
router
fills
in
as
the
packet
goes
along
its
path,
so
the
ideas
were
taken,
metrics
and
performance
measurements
from
routers
in
a
path.
So
the
goal
we
had
today
in
yesterday
was
to
implement
something
and
show
some
interoperability.
H
There
was
a
couple
of
drafts
on
the
IOM.
One
is
on
the
specific
option.
One
is
on
the
data
format
and
what
we
did.
We
brought
up
UDP,
paying
just
a
little
program
to
do
a
UDP
ping
that
sets
the
extension
header
and
the
IOM
option,
and
we
had
a
client-server
one
router
and
we
were
able
to
follow
the
path
and
have
the
information
filled
in
the
kernel
implementation
or
the
router
was
provided
by
Justin.
That's
at
this
github
and
separately.
The
client
in
the
server
code
was
a
different
implementation.
H
H
So
the
way
this
works
for
what
we
do,
we
ping
a
remote
host
to
add
a
few
options
and,
as
you
can
see,
we
got
some
response
back
and
we
parse
the
IOM
message
that
we
got
back
and
sure
enough.
The
router
filled
it
in
so
more.
Interestingly,
as
the
note
information,
this
is
directly
from
the
IOM
draft
various
pieces
of
information,
so
I
have
the
egress
interface
ingress
interface,
time,
stamps
transit
delay.
Things
like
that,
so
there's
quite
a
bit
of
information
that
we
could
potentially
gather
from
the
network
in
this
fashion.
H
So
we
did
learn
a
few
things
particularly
trying
to
to
get
things
done
or
operate
getting
the
lengths
right
when
we're
parsing
fields,
particularly
fields
that
hold
lengths
that
correlate
to
other
lengths
that
was
kind
of
interesting
bit
fields.
Don't
make
things
easier
in
this
regard,
especially
when
they're
split
across
byte
boundaries,
and
we
also
have
a
few
suggestions
to
eye
ppm,
particularly
in
some
of
the
data
formatting
Paik
data
format,
for
instance,
it's
a
lot
easier
to
deal
with
fixed
fields
than
variable
length
data.
H
I
Okay,
so
just
some
background
information
on
Island
P,
we
had
the
first
demo
of
what
will
eventually
be
a
public
release
of
the
code
at
the
last
IETF,
and
we've
just
been
developing
that
especially
trying
to
fix
some
bugs
that
we
found
in
a
tie
T
of
1:04,
which
was
very
useful
to
to
know
about
so
the
plan
here
was
really
to
make
sure
that
Island
P
could
work
over
a
real
network.
That's
the
idea
eventually,
and
so
what
we
had
was
a
network
that
consisted
of
some
low-end
rooters,
but
they
are
just
commercial
rooters.
I
They
run
ipv6.
Only.
The
idea
is
that
Island
P
works
completely
end
to
end,
so
the
core
rooters
just
think
you're
running
ipv6,
whereas
actually
you're
running
Island
P
and
the
other
thing
that
came
through
fortuitous
conversation
with
Stefan
BOTS
mayor
was
some
DNS
improvements,
help
with
DNS
in
general
and
I'll,
say
a
little
bit
more
about
those
in
a
slide
coming
up.
I
So
these
the
key
things
that
we
managed
to
work
out
today,
we
did
some
test-
runs
with
TCP
over
Island
P
running
over
these
commercial
rooters,
between
two
boxes
that
were
running
an
island,
P
modified
Linux,
kernel
and
but
running
over
these
commercial
rooters,
and
we
had
some
discussions
on
fixing
a
possible
issue
with
DNS
additional
information
processing
and
that
was
actually
fixed.
So
that
was
a
good
outcome.
I
spoke
to
Stephan
BOTS
mayor
and
after
I
uploaded.
These
slides
I
should
also
thank
so
I
didn't
put
his
name
in,
but
Peter
spat
chick.
I
She
did
the
coding
to
put
this
fix
into
one
of
the
the
DNS
servers.
So
thank
you
for
that
as
well.
This
is
the
demo
that
we
had
running.
We
had
the
it's
not
very
easy
to
see,
but
you've
got
two
boxes
at
the.
What
is
your
right
hand
edge
running
the
island
P
code
and
in
the
middle
we've
got
four
little
edge,
router
boxes,
those
are
r1,
r2
r3
marked
in
the
logical
diagram,
and
we
emulated
a
mobile
node
moving
across
them.
I
The
individual
throughput
on
the
network
shown
on
the
top
three
facets
of
the
graph
and
on
the
bottom
graph
is
just
the
aggregate
throughput
you
see
at
the
correspondent
node.
So
that
was
pretty
good.
We
got
a
consistent
TCP
flow
running
across
those
commercial
Reuters,
running
Island,
P
and
to
end
they
were
just
running
unicast
routing,
but
we
had
a
mobile
node.
This
was
work
that
was
done
mainly
by
my
PhD
student
who's.
I
D
J
Hi
I'm
Theresa
I'm,
presenting
for
the
e
taps
table,
which
is
for
transport
services,
just
a
quick
recap.
What
taps
is
so?
We
are
developing
a
sort
of
an
abstract
API
for
different
transport
protocols
and
those
are
just
the
transferred
protocols.
Our
current
PI
tabs
implementation
supports.
Of
course
it
will
be
nice
to
have
quicken
there
as
well.
J
So,
of
course,
those
are
not
really
equivalent,
but
if
we
have
transport
protocols
that
are
sort
of
provide
the
same
features,
then
we
can
try
them
at
the
same
time
and
sort
of
go
happy
eyeballs
on
them,
and
we
are
working
on
that
right
now.
Also,
we
are
working
on
getting
multicast
to
work,
which
is
kind
of
work
in
progress.
Also,
we
have
a
nice
interesting
concept
called
framers.
J
So
the
idea
is
you
get
a
byte
stream
from
TCP,
but
then
you
have
a
sort
of
a
delimiter
that
limits
your
byte
stream
into
messages,
and
this
is
a
concept
that
has
been
added
to,
or
that
has
been
expanded
in
the
recent
draft,
and
so
we've
been
discussing
framers
a
lot
and
there's
also
going
to
be
a
more
discussion
on
this
concept
in
the
working
group.
So
we
have
some
feedback
because
in
our
implementation
we
have
implemented
it,
and
some
parts
were
unclear.
J
Also
we're
going
to
discuss
how
much
we
of
this
we
have
to
specify
from
the
tests.
We
could
fix
some
box
in
our
implementation,
obviously,
but
also
we
are
sort
of
modeling
the
input
that
we
get
from
the
application
and
maybe
also
we're
going
to
model
the
output
sort
of
the
resulting
connection.
So,
let's
see
where
this
leads
in
terms
of
comparing
different
implementations
and
don't
also,
we
have
some
other
minor
additions
to
the
draft,
so
the
people
who
were
there
the
entire
week
and
are
mostly
Jake
Max
and
me
also.
K
K
K
You
can
see
security
on
air,
so
we
approved
our
three
interfaces
on
top
of
this
commercial
platform
and
also
we
demonstrated
the
security
policy
translator.
It
works
well.
So
this
is
a
building
block,
and
so
this
shows
that
our
internet
draft
at
Aitu
and
as
a
working
guru,
this
is
a
poster.
So
this
is
our.
During
the
weekend
we
work
together,
Tim
Porter,
so
this
figure
shows
I
and
SF.
So
this
is
a
nice
I
to
NSF
framework
or
project.
So
so
you
may
be
familiar
with
this
one.
K
So
this
time
we
embarked
with
commercial
fiber
NSF.
So
here
we
inspire
and
also
we
used
previously
I
will
actually
cut
up
open
source
the
web
filter.
So
this
time
we
combined
the
commercial
power
and
open
source
ricotta
for
web
filter,
together
on
top
of
a
commercial
public
cloud
system
developed
by
the
a
tiara
in
Korea.
K
So
to
slide
a
demonstrate,
a
couple
of
yeah-
you
can
see
demonstration
here,
so
the
register
to
NSF
of
features
and
also
consumer
interface
used
to
deliver
the
security
policy
in
the
high
level
point
of
view,
and
then
security
controller
translate
halep
policy
into
logger
policy.
So
this
is
a
see
you
can
see.
A
one
you
see
is
one
you
get,
so
we
provide
the
user
interface
to
easily
configure
that
talk
security
functions
using
this
test
board
yeah.
Okay,
so
we
provided
two
or
scenarios
filtering
and
a
filter.
So
this
time
we
prove
our
concept.
K
L
K
M
This
is
my
co
and
about
introduced
hack
project
of
I
sr
basics
with
in
configuration
unity
module.
Yes,
this
is
our
hack
plane
and
we
know
we
already
departments
about
sixty
repent
and
the
configure
I
saw
a
six-week,
serenade
him,
a
sorry
six
unit
module
and
the
sender
as
a
v6
model
is
under
development
by
ITF.
M
So
we're
looking
forward
pass
to
support
its
operators
to
controller
use,
a
TF
Yamato
to
interact
with
vendors
native
young
to
and
that
to
debridement
and
lacks
a
device,
and
so
the
project
here
is
we
using
ansible
people
can
I
have
200
models
to
configuration
to
config
as
our
v6
repair
and
implements
our
key
features
in
I
have
as
our
risk
model.
Also.
We
want
to
develop
event.
Also.
We
want
to
development
and
plug
in
to
support
standard
llamada
to
translate
to
native
module.
M
Ok,
they
said
what
we
can.
We
can
work
on
what
we
got
known
and
then
we
implement
history
and
support
applies
one
full
as
a
recyclable
and
as
a
service
6
and
as
a
wrist
6
will
be
involved,
and
we
also
develop
opened
up
to
allow
equipment
ITF
model
to
the
vendor
native.
Your
motive,
you
can
improve
it.
M
Is
that
the
wonder
that
laxative,
wise
may
be
only
support
until
model
and
the
operator
or
controller
may
want
to
deploy
it
ICF
standard
model
as
common
interface,
to
interact
with
multiple
wonders?
So
we
the
one
who
are
apt
to
addresses
issue
and
it
will
feel
if
I
know.
Okay,
if
you
like
to,
if
you
are
interested
in
the
topic,
you
can
join
tomorrow's
happy
hours
and
we
all
shows
a
demo
and
discusses
a
detail.
Ok,
this
is
our
team
number,
since
everyone's
contribution.
Thank
you.
N
N
N
N
So
yeah,
what
we
learned
is
that
it's
easy
to
diverge
on
such
projects
when
you
have
contributors
overseas
that
you
quite
don't
know
beforehand,
we
also
want
we
really
want
to
lower
the
adoption
barrier
to
this
project
so
that
newcomers
can
get
used
to
it
without
draining
too
much
of,
and
the
resources
of
the
old-timers
and
also
yeah.
We
want
to
provide
complete
examples
and
we
want
to
become
the
reference
implementation
for
check
and
that's
our
team.
N
C
K
This
is
a
poor
job,
so
I
want
to
share
out
the
experience
I
py
project
basic
product
protocol
project,
so
the
goal
is
to
want
to
prove
the
IP
version
6
over
8
to
that
Alabang,
OCB,
wave,
I,
Triple,
E,
wave
or
logical
Inc
elaire.
The
second
one
is
a
big
hello,
neighbor
discovery
with
the
address
of
restoration
and
multi-hop
da
d,
and
also
we
take
advantage
of
intermediate
of
occurs
in
Bennett
to
reduce
the
ad
time.
K
Also
it
can
short
the
initialization
of
a
TCP
UDP
transmission,
so
we
prove
the
to
trapped
or
she
beat
and
also
be
cooler,
neighbor
discovery
trapped.
So
this
is
a
poster.
This
is
the
Porter
the
team.
So
this
is
a
figure
is
of
the
vehicle
and
a
tall
architecture.
So
you
can
see
beaker
can
communicate
each
other
using
b2b
also
communicate
the
p2i.
So
our
idea
is,
you
can
see
the
beaker,
even
though
it
is
not
a
communication
range
of
lotus-eyed
unit.
K
This
is
a
providing
internet
connectivity
to
beaker,
so
it
can
initiate
the
ad
using
intermediate,
beaker
and
register
using
multi,
RTD
and
also
it
was.
It
are
configured
with
the
October
IP
address.
It
can
start
the
TCP
UDP
connection,
so
we
are
probably
using
simulation.
This
figure
shows
a
sumo,
pilota
simulator
and
also
we
use
the
OM.
Therefore,
the
truck
simulator.
So
you
can
see
we
using
a
three
hub
multi-hop
dat,
to
reduce
the
tid
delay
and
also
we
can
start
the
quickily
or
TCP
connection.
So
this
is
a
protocol
stack.
K
The
left-hand
side
is
that
you
can
see
waiver
protocol
stack.
This
is
IP.
This
is
a
web
server
message
protocol
for
safety,
so
we
implemented
for
our
logical
link
on
layer
and
ipv6
over
to
the
Lublin,
also
neighbor
discovery.
So
so
the
simulation
result
is
our
neighbor.
Discovery
can
lead,
use
the
legacy
our
neighbor
discovery,
so
yeah,
okay,
so
we
during
the
weekend
we're
all
on
the
probe
concept,
IP,
wave
or
CB
and
pickle
neighbor
discovery.
K
K
L
User
and
then
the
user
can
play
the
game
again
and
we
can
learn
more
about
the
user.
So
for
the
outcomes
we
have
begun,
organizing
our
system
to
take
into
account
these
user
preferences
and
there's
a
lot
more
discussion,
a
lot
more
data
needs
to
be
generated
before
we
can
implement
any
of
this,
and
we
have
some
questions
going
forward
and
I'm
happy
to
speak
with
anyone
who
wants
to
know
about
this
project.
Ok,
thank
you
very
much.
C
L
P
P
This
is
a
mechanism
by
which
manufacturers
and
network
administrators
can
learn
whether
or
not
their
devices
are
actually
putting
out
policy
recommendations
that
are
useful
to
those
devices
or,
if
there's
a
miss
configuration
some
work
on
mud
maker,
which
generates
the
Jason,
the
the
guys
from
cearĆ”
labs,
completely
redid
the
code,
which
was
nice
because
it
was
in
PHP
and
my
PHP,
which
is
really
bad,
and
now
it's
all
in
Python.
Thank
you
guys.
P
There
was
the
PP
mud
integration
that
was
going
on.
There
was
a
verification
mechanism
that
was
being
developed
by
the
folks
at
NCC
OE,
and
then
we
had
some
grass
work
and
discovery
work
going
on
and
let's
see
here,
what
did
we
plan
to
solve?
Actually,
we
just
plan
to
all
get
together
and
figure
out
what
to
solve
and
that's
what
we
did
so,
as
I
mentioned
a
lot
I
think
it
covered
a
lot
of
this
ground
already
on
mud,
rip
on
mud
reporting.
P
So
we
had
a
lot
of
some
interoperability
testing
going
on.
We
had
a
couple
of
guys
here
from
c-calm
who
went
and
actually
implemented
mud
right
on
the
spot
in
our
devices
and
tests
against
a
number
of
mud
managers
in
generating
themselves
a
mud
file
that
was
appropriate
and
tested
their
acts.
We
can
now
test
their
access,
and
then
we
had
some
additional
integration
going
on
in
terms
of
filters
for
east-west
versus
north/south.
In
terms
of
the
verification
code
and
yeah,
we
got
a
lot
of
work
going
on,
so
we
know
also.
P
P
This
is
the
the
thing
that
will
generate
mud
files
in
terms
of
the
verification-
and
here
you
got
here-
you
have
dark
and
our
gentleman
from
c-calm
and
in
terms
of
them
bringing
their
hardware
that
implemented
mud
are
there
in
DPP
or
directly
using
things
and
here's
the
long
list
of
people
who
actually
did
a
lot
of
work
and
thanks
to
a
bunch
of
organizations
who
are
supporting
them.
Thank
you.
Q
Okay,
so
hi,
this
was
a
spontaneous
project,
as
you
may
have
known.
There's
HPV
6
PD
on
the
heck
of
the
network
and
I
were
chatting
with
people
and
I
put
together
code
for
a
fair
outing
to
capture
those
packets,
pick
up
the
appropriate
routes
and
install
them
that
wasn't
previously
possible.
Now
it
is,
and
that's
it.
C
R
Hi,
everybody
I'm,
sorry
didn't
use
the
the
format
in
Quebec.
We
call
that
being
a
distinct
society.
This
is
the
coin
RG
p4
hackathon,
and
this
was
our
first
one
as
you
can
see,
because
we
didn't
know
about
the
format
who
are
we
we're?
Actually
a
proposed
research
group,
we're
still
waiting
to
be
a
real
one,
but
we
want
to
look
at
everything
that
works,
that
deals
with
computing
and
the
network
and
investigating
this
whole
continuum
of
putting
computation
from
the
data
center
all
the
way
to
the
edge.
We
want
to
look
at
architectures.
R
We
want
to
look
at
protocols
and
want
to
look
at
real
world
use
cases,
and
this
is
the
reason
that
we're
having
this
hackathon,
because
there's
a
bunch
of
people
invented
a
language
is
called
p4
which
is
currently
being
used
to
do
some
specific
programming
and
switches,
and
we
wanted
to
look
at
this
ID
of
this
cloud.
2
edge
computing
continuum
and
p4.
We
didn't
have
a
specific
project
except
our
remote
participant.
R
Most
of
us
were
pretty
much
new
users,
and
because
of
that,
we
have
to
really
give
a
shout
to
the
company
Montreal
company,
who
sent
us
two
engineers
for
two
days
to
help
us
setting
up
our
environments
and
developing
the
code.
That
is
actually
at
the
end.
We
ended
up
doing
real
work,
which
is
like
yay,
so
what
we
did
and
yes,
we
me
and
PL
we
are
gone
but
hey.
Thank
you
guys.
We
did
the
basic
examples.
R
We
had
actually
one
very,
very
proficient,
sadly
remote
participant
who
actually
implemented
and
started
implementing
an
ipv6
v6
switch
machine
learning
in
NP
4.
He
checked
his
code
in
the
in
the
github
and
it's
related
to
a
work
that
was
done
before
in
ipv4.
We
had
actually
we
actually
poached
people
from
other
tables
that
you
joined
us.
R
We
had
12
participants
at
the
end,
so
that
was
actually
pretty
surprising
for
us
and
the
people
who
we
poached
included
people
who
started
looking
at
p4
to
golang,
and
this
morning
we
did
packet
filtering
and
we
gathered
a
ton
of
information
and
I'm
always
done,
and
so
our
next
steps
we
want
to
continue
gathering
projects.
We
think
that
you
know
we
have
a
good
chance
to
become
a
real
research
group,
so
we
would
like
to
have
a
coin
interim
and
we
want
to
have
another.
R
S
Good
afternoon,
everyone,
so
the
measurement
analysis
for
protocols,
Research
Group,
participate
in
our
third
hackathon.
This
time
and
I'll
tell
you
what
we
were
up
to
the
problem
that
we
were
attacking
on
at
this
meeting
during
this
hackathon,
rather
was
to
produce
a
reference
implementation
for
doing
IP
address
aggregation.
S
Two
applications
of
this
are
doing
address
space
anonymization,
where
we,
where
you
a
granade,
say
you're
at
before,
address
2/24.
What
do
you
do
with
ipv6?
Another
application
of
it
is,
for
instance,
to
find
homogeneous
populations,
for
instance,
for
content
delivery
networks
to
do
matchmaking
between
the
users
and
the
content.
The
specific
problem
to
solve
was
how
do
we
take
something
like
a
Patricia
tree?
If
you
use
Python
or
Perl,
you
know
this
as
net
patricia
or
in
python,
pi
radix
or
patricia.
S
How
do
you
use
a
data
structure
like
that
to
represent
all
the
activity
in
the
entire
internet?
It's
too
big
when
you
have
tens
of
billions
or
hundreds
of
billions
of
v6
addresses,
so
so
the
the
to
solve
it.
We
decided
to
take
an
existing
code
base
in
see
the
agree
tree,
which
is
an
implementation
of
patricia
tree
and
make
portions
of
the
tree
immutable
and
I'll
show
you
why
that
solves
the
problem,
but
basically
it
allows
you
to
solve
the
problem
by
partitioning
it.
You
can
partition
the
set
of
addresses
arbitrarily
into
small
sets.
S
You
can
put
them
on
a
cluster
and
you
produce
an
intermediate
result
where
you
can
capture
the
state
of
the
tree
as
you're
performing
some
operation
on
it
and
then
do
it
iteratively.
So
so.
Well,
what
were
the
new
ideas?
And
what
did
the
team
agree
on?
Well,
the
team
it
turns
out
today
was
just
me,
so
we
agreed
on
everything
and
we
agreed
to
use
the
agree
tree,
and
we
agreed
that
this
this
partition,
this
partitioning
problem,
could
be
solved
by
making
portions
of
the
tree
immutable.
S
So
that's
the
new,
the
novel
design
idea
in
a
patricia
tree,
the
github
upload
is
pending
and
I'll.
Show
I'll
just
show
you
exactly
what
it
was
because
we
managed
to
get
it.
We
managed
to
get
it
done
in
just
a
day.
So
what
we
got
done
so
he's
imagine
you
have
a
set
of
active
addresses,
here's
10
high
56
/
64
s,
and
you
can
punch
them
up
into
one
of
these
trees
that
are
commonly
used,
it's
kind
of
like
a
routing
table.
So
we
put
the
tree.
We
put
him
in
the
tree.
S
To
give
you
an
example
why
this
is
important.
You
probably
think
in
night
before
you
know
what
a
slash
24
is
in
ipv6,
even
with
this
small
data
set
of
180,000
active,
slash,
64's.
This
shows
that
about
half
of
them
reached
this
sufficient
aggregation
at
slash
56,
but
another
half
of
them
needed
to
be
aggregated,
slash,
40
and
today
in
the
v6
internet.
A
lot
of
people
use
slash
48,
which
is
right
in
the
middle
and
a
horrible
compromise,
because
you
could
have
a
better
answer
or
you're,
not
not
aggregating
enough.
S
So
what
we
learned
is
is
that
this
is
a
can
of
best
practice
and
will
carry
it
to
the
working
group
and
I
made
a
couple
design
other
design
decisions
again
that,
were
you
know,
man
unanimous
so
with
just
me:
I've,
based
on
publicly
available
open
source
code
from
some
colleagues,
including
Condor
Ocho,
and
we're
gonna
meet
on
Friday
and
I'll,
go
over
some
more
of
the
results
so
join
us
on
Friday
at
mapper
G.
If
you
can
in
the
morning
Thanks.
T
T
T
T
Everybody
knows
how
busy
that
can
be,
and
an
additional
access
types
were
made
possible
by
our
volunteers
that
joined
and
I
just
want
to
mention
that
you
know
all
the
names
here:
Ryan
Hoffman
from
Telus
and
Ryan's
gonna
speak
a
little
bit
about
his
results
and
Timothy
Karlin
Marian
Dylan
and
Kyle
Kyle
wet
all
from
UNH
at
the
interoperability
lab
thanks
so
much
for
joining
this
ok.
So
here
we
go
so
we
ran
the
tests.
We
iterated
some
measurement
parameters,
we're
gonna
revise
the
tool
based
on
what
we
learned
and
compared
with
a
commercial
tool.
T
Everybody
knows
what
that
commercial
tool
is
its
okhla
s--.
So
we
we
ran
from
here
side
by
side
for
the
tests
that
I
ran
to
the
UDP
server
in
Middletown
New
Jersey,
both
servers
and
clients
on
the
same
machines
and
here's
a
quick
representatives
set
of
results
with
the
UDP
speed
test.
You
know
we're
seeing
the
effects
of
the
traffic
here
we're
only
getting
into
the
800
I
mean
it's
a
it's
a
gigabit
per
second
access,
we're
getting
an
800,
650
Okuma
measuring
a
lot
lower.
We
go
back
and
measured
with
you,
DPS
T
you.
T
U
So
I
wanted
to
include
non
congested
links
so
set
up
a
connection
between
our
Telus
lab
at
Hamilton
Alberta,
with
owls
New
Jersey
lab
to
perform
the
same
kind
of
test,
but
in
bulk,
so
I'm,
using
two
servers
here
in
New
Jersey,
just
to
be
able
to
get
the
bulk
of
tests
that
we
needed.
Unfortunately,
the
server
in
New
Jersey
only
had
a
GUI,
so
this
shows
the
comparative
results.
U
A
consistent
near
gig
speed
result
with
the
UDP
speed
test,
as
opposed
to
the
TCP
test,
which
was
highly
variable,
really
important
information
for
us,
because
it's
difficult
for
a
technician.
That's
going
into
a
home
selling
a
service
and
using
that
test
to
reveal
to
the
customer
what
they're
achievable
speed
is
and
it
being
subpar.
D
T
Unh
folks
walked
in
this
morning,
got
this
test
running
and
and
and
resolved
a
problem
with
their
router
screening
in
the
firewall
on
UDP
traffic
and
and
made
it
work
properly
right
after
that.
It
was
a
great
effort
in
just
a
few
hours
here
this
morning
and
we
learned
a
lot
of
stuff
for
potential
development
and,
and-
and
you
know
you
can
learn
a
lot
from
testing
different
access
types.
That's
for
sure
thanks
very
much.
C
V
Hello
I'll
make
this
really
fast,
so
we're
here,
working
on
making
discovery,
work
with
less
use
of
multicast,
because
multicast
we're
here
making
discovery
work
with
less
reliance
on
multicast,
because
multicast
is
slow,
its
unreliable,
its
wasteful
of
shared
wireless
spectrum.
There's
a
list
here
of
the
drafts.
The
discovery
proxy
is
based
on
the
hybrid
draft
which
uses
DNS
push
notifications,
which
in
turn
builds
on
DNS
stateful
operations.
V
V
We
did
a
bunch
of
work
with
integration,
open,
wrt
package
management
dealing
with
asynchronous
change
notifications
with
you
bus
to
really
polish
this
code.
This
is
all
available
on
the
ITF
hackathon
github
and
we
now
have
pre-built
packages.
You
can
download
it
yourself
and
run
this
and
in
about
five
minutes,
have
your
own
discovery
proxy
running
at
home.
Thank
you.
C
P
F
L
W
Will
represent
the
team
here
about
web
out
is
here
about
this
is
a
technology
to
bring
real-time
communication,
audio
video
and
data
to
the
web,
and
it
has
a
ITF
pendant,
which
is
RTC
web
for
all
the
protocols,
the
encryption,
the
security,
the
codecs
and
so
on.
The
last
missing
piece
is
called
simulcast,
which
is
the
capacity
to
send
a
different
resolution
of
audio
and
video
simultaneously
over
the
wire
to
finish
this
back
at
w3c.
W
W
The
two
others
were
excused
for
visa
reason
and
other
things
we
had
free
media
server
represented
to
give
feedback
on
implementation,
which
is
also
very
important
and
finally,
free
application.
Vendors
that
were
using
both
browsers
and
media
servers
to
help
communicate
about
the
needed
and
missing
functionalities
and
different
bugs.
W
W
We
went
through
ten
different
bugs
in
different
browsers,
and
we
also
helped
different
vendors
implement
similar
cast
in
their
media
server
or
at
least
made
progress
there
and
provide
feedback
to
to
the
missing
pieces,
so
all
in
all
very
efficient
session
and
we're
very
happy,
and
we
made
a
lot
of
progress
in
two
days
that
would
otherwise
not
have
been
possible
without
the
opportunity
to
have
a
face-to-face.
The
agathon
gave
us
so
thanks
to
the
sponsor
and
things
too
charged.
X
X
As
we
know
there
are
already.
There
have
already
been
defined
for
data
types
in
ITF
draft
IOM
data,
including
to
type
treat
reason
to
treating
type
when
beauty
and
the
luster
is
a
h2h
type.
Now
we
will
define
another
new
one,
treating
type
called.
We
call
it
post
a
card
base
at
elementary.
So
what's
the
different
between
the
post
card
based
elementary
and
I
am
tracing
type
at
first
we
separates
that
elementary
instruct
instruction
header
and
the
metadata
so
like
the
like.
X
X
X
X
X
X
X
This
page
show
this
project
in
hexa
at
first
there
are
network
domain
include
for
Reuters
and
a
tester
will
send
to
test
of
flows
and
and
also
receive
this
to
test
of
loss
e
IG
v6
transport,
as
the
transport
protocol,
the
Rooter
for
as
the
inquest
node
to
encapsulate
the
I
feet,
header
and
the
Luther
three,
as
as
a
quest
node
to
Inc,
they
capture
list
as
I
feet,
header
and
Rooter.
Six
and
the
root
of
5
has
the
transit
knows
the
yellow,
yellow
one
is
a
matter.
Data
is
collected
to
the
collector.
X
So
we
collect
all
the
metadata
and
and
program
to
show
the
following
three
case
at
first
is
a
delay,
delay
monitor
for
each
node
and
link
and
into
end.
We
can
see
from
this
black
pen.
Oh
yeah,
on
the
right
of
the
black
pen.
Oh
and
kiss
kiss
is
a
show
us.
The
packet
lost,
monitor
just
the
file
Peck
his
loss,
and
the
last
case
is
a
path
tracing
in
sir.
Is
the
left
side
yeah?
That's
all.
C
E
E
Stand
like
this,
keep
it
tight
the
Floridian,
so
the
floor
is
Dina
steams,
so
the
the
Dina's
table
was
quite
eclectic
group
of
people.
It's
like
the
the
DNS
protocol.
Probably
so
we
did
something
about
Dina's
privacy,
dinner,
support
for
specific
networks,
provisioning
and
miscellaneous
stuff,
the
catch-all
so
to
Dina's
privacy
work.
We
worked
on
was
zone,
transfers
of
TLS
sort,
and
so
you
want
to
protect
your
zone,
it's
encrypted,
etc.
Salt
is
the
push
model,
certain
kind
of
subscription
model-
I'm.
Sorry,
yes,
a
subscription
port,
no
proxy
plugin
for
any
web
server
by
pitter.
E
It's
far
CGI
plug-in
interface
and
means
the
preparations
for
dot
Sandow.
Invite
so
there's
a
lot
been
discussions
on
Dow
Indian
s
community
and
about
beside
it,
and
we
think
that
choice
for
end-users
and
deployment
are
important,
so
I
think
there's
a
good
work
that
we
include
this
dough
support
in
different
pieces
of
software,
good,
the
DNA
support
for
specific
network,
so
DNS
is
kind
of
the
Swiss
Army
of
the
Internet.
Of
course,
I'm
working
dinner,
so
I'm
I'm
have
some
specific
view
on
this,
but
so
for
IDL
and
P
presented
already.
E
There
were
some
collaboration
between
Stephan
and
the
ILP
group
to
extend
part
of
the
implementation
of
DNS
to
work,
with
an
identify,
locator
split
and
in
some
other
situations
in
ipv6
only
setting,
but
you
had,
you
asked
for
a
quad,
a
there's,
only
a
a
records.
It
has
to
be
some
middle
box
that
has
to
do
some
translation.
E
So
does
the
DNS
prefix
this
coffee
by
mark
implemented
in
bind
again
DNS
as
visioning
tool
here
so
for,
if
you
want
to
do
something
with
any
cost,
and
you
don't
want
to
create
and
plus
my
gun
for
DDoS
attacks,
you
want
to
have
an
any
cost
open
resolver
with
something
like
a
DNS
server
cookie.
So
you
protect
your
open
REE
cursor
for
DDoS
attacks
with
spoof
addresses.
E
This
is
implemented
in
bind
and
inbound
and
is
D.
Another
provisioning
thing
is
temporary
records
in
the
DNS.
Sometimes
like
the
let's
encrypt
ACM
of
the
Acme
protocol,
you
want
to
publish
some
information
for
a
short
time
in
your
dinner
zone,
so
you're
the
owner
of
a
domain
name
for,
gets
your
certificate.
You
have
the
timeout
resource
records.
After
that,
the
information
is
removed
from
your
zone.
Another
important
thing
is
the
HCP
s
SVC
this
kind
of
a
service
records
and
it
has
been
a
long-standing
well
problem
to
solve.
E
Actually,
so
how
do
you
provision
your
web
surface
and
how
do
you
address
them
in
the
DNS
has
been
a
number
of
solutions
over
the
years
by
the
DS
community
by
the
HCP
community,
and
this
proposal
seems
to
be
received.
This
wrist
proposes
receives
positive
feedback
from
both
working
groups.
So
it's
a
lot
of
interest
here
and
this
entry's
sorry
there's
an
implementation
in
Burma
in
unbound,
the
miscellaneous
gets
all.
We
did
some
work
on
llamo
format
in
DNS
packets.
E
The
original
RFC
is
actually
about
Jason,
but
the
original
author
of
the
receive
site
as
well
jemelle
is
fine,
it's
readable
and
it's
already
in
use
in
the
proof
of
concept
of
root,
server
measurements
framework.
That's
also
wrapping
up.
We
did
a
lot
of
Interop
between
ourselves
between
different
groups.
The
ILP
group,
the
web
community,
I
think
we
have
done
some
good
work.
That's
all,
and
these
are
yeah.
Y
Y
This
is
l4
s
going
on
in
the
transport
area
and
tcp
MN
TSP
WG
right
a
bit
of
background
here,
but
I'm.
Looking
with
dwell
on
it.
There's
the
where
our
code
is
all
linked
from
and
the
specs
we're
working
to
I
have
got
a
number
of
people.
We
actually
expected
to
have
more
nearly
all
remote
and
hardly
anyone
here,
but
it
worked
out
the
other
way
around.
Y
Something
like
seven
newcomers,
which
was
pretty
good
and
quite
a
few
projects.
We
didn't
expect
I'll
jump
to
the
next
slide
and
then
I'll
come
back.
We
did
plan
something
something
that
didn't
happen
with
a
bunch
of
people
remote
that
were
all
new
just
it
became
impractical,
it's
time
in
India,
basically
and
didn't
quite
get
to
finishing,
but
going
back
quite
a
few
projects
to
brought
a
testbed
with
us
God
they
all
set
up
found.
Y
There
were
problems
with
like
this
Linux
kernel,
screwing
up
what
we
had
the
intended
to
do,
etc
had
to
rebuild
things
blah
blah
blah
Richard
got
on
well
with
Michael
tooks
and
implementing
accurate
ecn
in
FreeBSD
with
Michael
tooks
and
helping
there
was
also
I.
Suppose
the
highlight
really
was
the
l4s
testbed.
We
had
the
SC
people
come
over
and
give
us
their
Flint
work.
Well,
they
wanted
us
to
evaluate
on
it
and
we
started
working
together
that
which
will
probably
continue
during
the
week.
That's
right
and
I'll.
Now
come
on
to
that.
Y
We
started
the
first
scenario
and
we've
got
the
others
to
do.
Also
the
ns3
implementation
fast
start
was
added.
Richard
made
good
progress
on
the
FreeBSD
implementation
which
didn't
exist
before
this
got
the
handshake
and
the
feedback
working
out
of
the
protocol
to
packet
packet
drill,
and
we
built
a
good
relationship
with
the
STS
ee
team.
That's
we,
the
elf
Rose
team,
but
now
we're
we're
the
elf
rose
and
SCE
teams
and
what
we
learned
well.
Y
Y
We
now
question
one
of
the,
although
the
most
recent
change
you
made
to
the
spec
having
tried
to
implement
it,
so
we
may
go
back
on
that,
but
we
really
think
it
and
discovered
that
a
counter
that
crosses
a
byte
boundary.
Obviously
we
knew
it
crossed
byte
boundary,
but
just
made
it
started.
Thinking
about
cross,
compiling
and
stuff
made
it
a
bit
more
challenging
to
make
sure
that
would
compile
correctly
and
also
learned
that
remote
attendance
of
newcomers
that
a
hackathon
doesn't
really
work.
Z
Thank
you.
So
this
is
a
report
from
the
wiki
hacking
activity
here
at
the
IETF
hackathon.
So
we
see
I
work
on
IOT,
semantics
and
hypermedia.
Interoperability
is
a
long-running
activity
at
the
IETF
is
already
our
sixth
hackathon.
We
are
in
the
engineering
research
group
but,
of
course,
spanning
work
across
multiple
organizations
and
individuals.
Z
Z
So
we've
been
working
actively
on
the
one
data
model,
simple
definition,
format
and
then
also
data
models
from
other
organizations
in
part
on
omae's
back
works
like
with
M
2
m
and
e
p--.
So
models
on
the
data
model
convergence.
So
we
use
that
one
data
model,
simple
exponential
format
to
do
data
and
model
interchange.
Z
Z
One
activity
on
the
data
models
was
this
binary
data
extraction.
So
if
you
have
something
that
is
not
an
easy
useable,
JSON
format
or
such
you
can
now
use
these
tools
for
extract
json-ld
from
it.
We
have
playground
deployment
available
on
that
that
you
can
post
post
your
data
and
get
json-ld
representations
back
and
the
other
big
one
was
proving
coffee
with
hypermedia.
So,
of
course,
from
the
days
of
hyper
hyper
media,
hypertext
coffeepot
control
protocol
times
will
be
wanting
to
do
this.
Z
Now
we
have
modern
tools
and
protocols
for
this
purpose,
so
you
have
a
carrier,
crate
coffee
machine
reference
scenario,
also
known
as
Karstens
coffee
machine.
You
can
discover
and
describe
your
coffee
machine,
discover,
menu
options,
make
coffee
selections
and
finally
get
get
some
coffee
brewed.
We
have
now
two
open-source
implementations
that
use
coop
and
coral
to
achieve,
especially
the
first
three
steps.
The
last
one
we're
still
working
on.
Z
And
this
is
the
set
of
people
who
are
working
in
our
team.
This
time
we
have
one
new,
first-time
member,
mike
mackool,
and
we
had
two
remote
participants.
If
you
want
to
see
more
information
links,
open-source
implementations,
etc,
you
can
go
to
our
wiki
page
and
L.
The
information
is
there.
Thank
you.
C
AA
Hi,
this
is
the
report
from
the
quick
table
where
the
big
table
in
the
middle
somewhere.
We
are
also
the
htv3
table
because
that's
kind
of
the
same
thing
this
is
our
regular
interrupt
spreadsheet,
it's
getting
pretty
crowded,
so
we
had
19
implementations
that
we're
tracking
most
of
them
are
both
client
and
server.
Each
letter
is
a
test.
That's
either
passed
or
not
passed.
AA
We
now
have
three
lines.
The
first
one
is
sort
of
the
table
stakes
basic
protocol
stuff.
Second
row
is
quote-unquote
advanced
features
that
should
really
be
part
of
the
first
row,
but
they're
not
sufficiently
widely
deployed,
yet
that
we
can
do
that,
and
the
third
row
is
new,
which
is
a
bunch
of
new
tests
that
specifically
test
htv3
compatibility.
AA
You
see
a
bunch
of
white
compared
to
what
I
showed
in
previous
hackathons.
That's
because
the
22
drafts
only
dropped
like
maybe
10
days
ago,
so
a
bunch
of
implementations
basically
didn't
have
time
to
update
yet
so
this
should
this
should
change.
But
this
is
the
most
remote
nation
we've
ever
had.
We
keep
adding
new
ones.
So
it's
looking
pretty
good.
AA
AA
Amongst
you
probably
know,
NS
3,
which
is
a
network
simulator
and
Jonna
and
Martin,
have
worked
on
allowing
you
to
define
an
NS
3
simulation,
so
you
can
define
well-defined
TCB
cross
traffic
or
topologies,
and
then
you
can
plumb
in
actual
quick
implementation
into
that
topology
and
you
can
do
congestion
testing,
for
example,
repeatable.
So
it's
kind
of
nice,
it's
kind
of
cool,
it's
it's
early
days
is
the
first
time
we
tried
this.
We
plugged
in
nothing
two
or
three
different
ones.
AA
This
is
a
sequence
number
of
plots
of
the
trends
where
people
will
be
very
excited
because
now
quick
starts,
it
look
like
TCP.
You
can
look
at
this
graph
and
you
see
what's
going
on
which
was
hired
before
because
it's
all
encrypted
so
with
endpoint
cooperation.
You
can
generate
plots
like
this.
This
is
from
the
simulator
with
one
of
the
stacks
we're
using
Robin
Marx's
tool.
AA
There's
the
login
form
it's
being
defined,
called
cue
log.
He
has
tools
to
visualize
cue
log
into
something
like
this.
So
on
the
bottom,
you
see
like
how
the
RTT
changes
that
quick
things
it
has
over
the
path,
and
then
you
see
that
a
regular
sequence
number
AK
plot.
So
this
is
exciting
because
finally,
it
means
you
don't
have
to
be
like
the
look
at
the
bits
anymore
in
order
to
understand
what's
going
on
in
terms
of
congestion
control,
so
this
is
very
cool.
Thank
you.
C
O
Thank
you
very
much
so
breathing
it's
Logan
from
Mauritius
from
the
southwest
home
team,
so
we
are
based
in
Russia.
So
we've
done
a
bunch
of
work
on
TLS
1.3,
SSH,
SC,
Venu,
dscp
code,
point
and
ITF
mobile
up
next
slide.
Please
Sotiris
1.3!
Our
aim
was
to
get
more
applications
running
on
TLS
1.3,
dscp
ID,
it's
a
new
code
point
but
was
just
I
just
became
an
RFC
and
we've
been
working
on
in
to
integrating
but
into
open
source
projects
that
does
the
ITF
mobile
app.
O
But
we
started
working
on
previous
ITF
when
B
is
the
SCE
drop
but
came
up
recently
and
when
the
last
thing,
but
we
work
on
was
on
duplicating
Asif
or
in
SSH.
So
next
slide,
please
so
I'm
Terrace
1.3
we've
worked
mostly
with
go
long
base
software
packages
so
matter
moves.
It
says,
like
slack
alternative,
so
the
PIO
was
sent
check.
Sm
TP
is
another
good
run
package,
but
still
working
progress
and
mi
niƱo,
which
is
for
Amazon
s3,
it's
still
written
in
golang.
O
We
added
the
we've
added
various
one
from
free
support
and,
lastly,
we've
got
TLS
1.3
api
integrated
into
PHP
7.4,
and
the
last
thing
is,
but
we
are
developing
c-sharp
library
for
TLS,
1.3
called
TLS
Rob
and
it
got
refracted
and
it
has
some
support
for
hello,
retry
and
things
like
that.
40S
1.3
in
C
shop,
so
the
other
stuff
that
we've
been
doing
working
on
is
dscp
early.
When
you
code
point,
we
integrated
the
patch
we
integrated
it
into
net
birth,
repeal
was
sent
to
OpenSSH
and
it
was
also
sent
to
enough
tables.
O
The
other
thing
that
we
worked
on
was
we
go
by
it
up.
As
I
said,
there
are
links
to
a
screenshot
and
it's
it
has
improved
compared
to
loss,
ITF,
resin
versus
shop,
implementation
of
SSH,
but
still
running
with
aqua,
and
we
duplicated,
but
mostly
we
work
on
an
SV
implementation
for
F
to
curdle
in
freebsd,
based
on
paragraph
but
Rodney
and
gelatin
were
published.
It's
still
very
basic,
but
it's
enough,
but
we
can
see
SC
packets
on
the
wire
on
Wireshark.
O
So
next
slide,
please.
So
what
we
learned
basically
was
open
source
project,
then
to
want
to
wait
for
new
dscp
code
points
to
become
RFC
before
accepting
patches.
That's
the
case
for
SSH,
so
we
wanted
to
wait.
Our
c4
in
SSH
is
mostly
fading
away.
It's
mostly
going
away.
We've
not
seen
that
many
cases
of
open
source
projects,
still
shipping
with
SCE
is
just
starting.
So
it's
worth
looking
more
into.
That
was
also
overworked.
What
was
going
on
with
over
SC
developers
and,
lastly,
go
long.
O
1.12,
ships
with
TLS,
1.3,
P
I
so
expect
more
TLS
1.3
in
software
packages,
returning
Goa,
so
lost
site.
So,
first,
basically,
yes,
we
are
whole
team.
Here
from
Mauritius,
we
were
grateful
to
my
sponsor
business
cos
Venu,
who
hast
adjust,
and
this
possible
leaks
as
well
to
to
our
ripples
where
we
are
some
our
results
of
over
SC,
as
well
as
the
code
and
for
the
ITF
mobile
app.
We
have
it
via
over
that
link
and
we
also
included
for
TLS
shop
library.
So
thank
you
for
everybody
for
listening
to
what
we've
done.
C
A
A
A
We
want
to
continue
to
make
this
a
great
experience
for
newcomers
to
not
just
for
those
of
us
who
have
been
working
on
the
standards
for
a
long
time
so
appreciate
those
of
you
who
did
have
new
people
in
your
team
when
you
helped
them
get
started,
that's
just
fantastic!
So
and
thanks
for
you
just
paying
attention
to
all
the
presentations
they
were
recorded,
we'll
have
them.
They
were
live
streamed
also,
so
if
you
missed
something,
you
can
go
and
get
it
afterwards.
A
Lastly,
if
you
have
you
didn't
present
anything,
but
you
still
have
some
useful
results
to
share.
Please
do
upload
your
presentation
to
the
github
org
or
if
you
want,
you
can
just
send
it
to
me.
I'll
all
upload
it
for
you.
If
you
want
to
put
your
PowerPoint
presentation
there
or
some
other
format,
that's
fine
now,
just
for
up
here
we
wanted
the
PDFs
and
I
think
that's
it.
Thanks!