►
From YouTube: IETF103-T2TRG-20181106-1610
Description
T2TRG meeting session at IETF103
2018/11/06 1610
https://datatracker.ietf.org/meeting/103/proceedings/
A
A
So
this
is
the
thing
the
thing
research
group
I'm
casting
woman.
This
is
re
Carolyn
and
we
are
operating
under
the
IRT
F
guidelines
fear
for
what
they
call
intellectual
property
rights,
and
these
happen
to
be
the
same
ones.
We
use
in
the
IETF
and
oh
I
didn't
include
the
note
words
like
sorry,
so
you
can
find
the
the
information
on
this
link,
and
the
most
important
thing
to
keep
in
mind
is
that
if
you
are
talking
about
certain
technology-
and
you
know
about
patent
claims
to
applying
to
that
technology,
you
have
a
choice.
A
A
A
Can
you
do
it?
Okay,
Francesca
I
will
try
I
mean
there's,
that's
the
best
effort
service.
Oh
okay,
thank
you.
So
the
agenda
on
today
has
a
number
of
reports
from
our
own
activities
and
from
from
other
organizations
like
you're,
at
least
in
my
org
and
in
w3c.
Where
are
things
and
then
we
want
to
talk
about
one
particular
aspect
which
is
the
subject
of
hyper
medium
in
IOT
for
half
an
hour,
and
then
we
will
talk
about
Friday's
work
meeting.
A
There
will
be
a
meeting
on
Friday
here
in
this
building
for
things
within
research
group,
and
then
we
will
do
our
wrap-up
so
just
to
remind
people
what
I
think
you
think
Weesa
fume
is
about.
We
have
all
these
IOT
standards
being
created
by
the
IETF
and
that's
great.
These
are
nice
blocks,
Lego
blocks
of
interoperability.
A
But
what
is
the
big
picture?
How
can
we
we
turn
a
true
true
Internet
of
Things
into
reality,
an
Internet
where
low
resource
nodes
can
participate
and
I
can
communicate
among
themselves
and
with
the
wider
Internet?
That's
the
subject
of
this
research
and,
of
course
the
focus
here
is
on
issues
that
have
opportunities
for
Standardization
in
the
ITF.
So
we
start
at
the
irritation
layer.
We
occasionally
look
a
little
bit
at
the
radio
layer,
but
not
much,
and
we
end
with
the
user,
the
user
experience,
the
application
layer
and,
of
course,
security.
A
A
Of
course,
there
are
other
IETF
working
groups
that
are
doing
I
actually
related
things,
but
putting
the
whole
picture
on
a
slide
would
probably
not
work
and
basically
the
ideas
that
the
research
group
is
on
the
side
of
open
research
issues
that
have
IETF
potential
are
not
yet
ready
for
carrying
into
the
IGF,
and
the
working
groups
are
actually
doing
engineering.
For
instance,
the
car
working
group
is
doing
the
protocol
engineering
for
restful
environments
in
the
IOT
and
other
groups.
A
A
We
have
calls
with
OCF,
we
hope,
finally
being
able
to
set
up
a
call
with
I'm
a
speck
marks,
the
guardians
of
lightweight
m2,
MN
TFC,
if
so,
objects,
and
we
certainly
will
have
some
activities
at
the
Prague
ITF
meeting.
So
we
probably
will
continue
the
reishi
hackathon
and
might
have
other
activities,
like
maybe
another
work
meeting
on
Friday.
A
One
is
the
state
of
the
art
and
challenges
for
the
out--he
security
document
that
is
still
ready.
There
has
been
a
snag
in
in
the
IES
reprocessing
that
is
required
to
get
a
document
published
as
an
RFC
is
she
looks
at
we
certificate
procurements
and
decides
whether
this
is
actually
an
attempt
to
work
around
some
IETF,
conscious
consensus
and
so
that
they
have
to
look
at
the
document
and
and
well.
She
is
very
busy
and
and
that
process
didn't
move
forward.
Yet
the
other
one
is
restful
designed
for
IOT.
A
One
is
the
the
hypermedia
area
where
we
have
a
nice
submission
of
the
corpse
document
that
I
think
it
has
now
it's
eight
version
and
the
the
correlate
specification
we'll
talk
about
that
in
a
moment,
and
there
is
also
a
draft
about
internetwork
coexistence
in
IOT
that
got
a
lot
of
attention
in
some
of
the
previous
meetings
and
that
certainly
something
we
don't
want
to
lose.
But
we
are
not
much.
Activity
has
happened
in
the
last
few
months.
C
One
thing
we
were
contemplating
quite
some
time
is
this:
what
should
we
do
with
the
core
abstract?
We
are
previously
considered
in
decorating
that
as
a
part
of
the
restful
design
craft,
however
they're
having
a
lot
closer,
look
at
it,
it's
it.
Documents
on
its
own
is
quite
extensive
and
it
has
a
lot
of
good
information
that
it
wouldn't
really
do
a
service
for
that
graph
to
be
part
of
another
craft,
it's
better
to
have
that
as
a
standalone
draft,
and
then
we
could
be
referring
to
that
craft
from
from
this
document.
C
C
So
if
you
have
any
good
insights
on
that
or
would
be
interested
in
discussing
on
that,
please
do
approach
us
as
co-authors,
we'll
be
very
interested.
Have
a
chat
with
you
on
your
experience.
Is
that
what
we
could
actually
distill,
then
in
this
document
like?
Why?
Is
it
good
to
be
using
restful
technologies?
What
are
the
kind
of
things
you
have
to
be
aware
of
what
makes
sense,
also,
as
usual,
more
reviews
are
very
welcome.
C
So
please
go
ahead
and
read
the
document,
then
we're
also
considering
getting
a
more
outside
of
ETF
and
I,
hardly
ever
use,
for
example,
from
the
for
the
micro
services
community,
and
hopefully
all
things
go
well.
This
could
be
ready
for
publication
requests
around
next
summer.
Ietf
100-105
anyway.
I
really
encourage
you
to
have
a
have
a
read
on
it.
Please
and
your
review
comments
to
the
list
or
straight
to
the
authors.
C
C
We
have
been
discussing
this
topic
of
how
we
add
semantics
to
existing
piece
of
information,
and
they
want
to
because
the
semantics
style
shades
how
you
can
use
styles.
It
kind
of
an
approach
for
our
next
piece
of
data
and
telling
here
are
the
semantics
that
are
part
of
that
data
and
how
they
can
they
could
be
used
to
achieve
a
semantic
interoperability.
C
C
Also,
one
of
the
topics
was
this
lightweight
MDM
integration
using
the
web
of
Things
technologies
and
IOT
schema
or
semantics.
That
says
a
similar
topic
that
we've
been
already
working
on
in
the
past
hackathon
and
also
on
this
hackathon,
and
also
in
general,
how
the
ID
schema
org
can
be
used
together
with
if
so
and
like
with
emblem
and
also
hoe
CF
models.
How
can
we
be
breaching
bit
from
these
different
ecosystems
using
cell
vocabulary
using
shared
anthologies?
C
And
finally,
we
are
going
to
start
this
note
serious
if
you
wish
and
and
one
of
those
nodes
that
we
already
started
on,
is
this
semantics
and
engineering
principles.
So
the
idea
is
that
we
are
gathering
some
of
those
thoughts,
a
bit
more
structured
way
to
the
wiki
in
the
beginning
and
then
will
from
the
based
on
the
wiki
will
see
if
some
of
that
information
should
be
made
into
an
an
internet
draft,
but
this
may
be
the
one
that
is
currently
preferred
is
the
way
on
talking
about
the.
C
C
So
that
was
the
Whiskey
activities
between
the
IETF
and
then
we
had
a
session
in
the
hackathon
Saturday
and
Sunday.
So
this
was
the
first
time
we
have
we.
She
was
participating
in
the
IETF
hackathons.
We
had
8
participants
of
two
of
them
remotely
and
as
an
overarching
theme
in
the
hackathon
we
had
is
connecting
things
from
different
ecosystems
and
how
can
use
shared
semantics
and
hypermedia
to
achieve
that.
One
of
the
things
that
we
were
playing
around
quite
heavily
is
the
lamp
that
you
can
see
here
on
the
slide.
C
So
what
did
we
do?
Well,
our
key
achievements.
We
did
manage
to
turn
that
lamp
on
quite
a
few
times
and
also
off
using
using
programmatic
methods
and
being
able
to
counter
the
lamp
from
device
coming
from
very
different
ecosystems.
So,
for
example,
what
we
had
is
semantic
interoperability
for
data
and
actions
between
light
with
anthem,
clients,
philips.
You
liked
that
you
saw
in
the
picture
and
then,
for
example,
like
oh,
my
toaster,
so
using
these
management
interfaces
based
on
coop,
we
have
some
challenges
with
the
comb.
C
I
thought
somebody
was
using
sea
boar
and
recipe
imperceptible
using
JSON,
but
still
at
least
on
the
interaction
level,
we
were
able
to
do
new
commands
like
read:
read
temperature
set
light
and
not
not
to
having
to
worry
about
the
underlying
protocol
details,
not
time
to
worry
about
whether
it's
HTTP
or
co-op
or
MQTT,
underneath
also
one
thing
we
did
was
this
new
thing
directory
implementation,
tiny
thing
directory
so
theme
directory?
Is
this
entity
in
the
network?
C
We
can
store
your
theme
descriptions,
the
web
of
things
in
between
descriptions
and
the
existing
implementation
had
some
issues
or
stability
as
such.
So
of
course,
then
you
implement
a
new
one
and
one
learning
that
we
saw
in
that
one
actually
was
pretty
easy.
Given
the
kind
of
infrastructure
we
have,
we
have
co-op.
We
have
to
have
nice
frameworks.
Sitting
up
a
thing
directory
was
pretty
straightforward.
In
the
end
also,
we
were
working
on
some
of
the
reality
implementations
in
particle
op
research
directory,
improving
the
implementations
that
we
have
and
then
being
a
research
group.
C
It
was
not
only
a
new
code,
but
we
also
had
a
bunch
of
breakouts
during
the
weekend.
So
we
had
very
good
discussions,
for
example,
on
this
adding
semantics
to
binary
data
in
particle
looking
at
the
Modbus
way
of
representing
data
and
having
discusses
how
those
would
be
addressed,
how
the
hell
could
apply
semantics
there,
how
we
can
then
bring
that
kind
of
information
as
a
part
of
the
bigger
web
web-based
ecosystem.
C
Also,
we
discussed
hypermedia
safety
for
IOT.
So
how
can
you
tell
some
hypermedia
action
is
safe
and
not
in
the
HDP
sense,
but
safe
as
in
human
cells,
for
example.
If
you're
you
have
a
form
that
is
able
to
open
a
window,
it
makes
a
big
difference
if
the
living
room
window
or
an
airplane
window
that
it
doesn't
feel
high.
C
So
how
can
we
have
that
kind
of
information
presented
as
part
of
the
hyper
media
that
even
a
machine
could
be
making
a
conscious
choice
based
on
some
of
the
safety
aspects
and
also
we
discussed
the
cement
example
and
engineering
principles
that
I
mean
summer
earlier
and
in
particle.
One
thing
around
that
area
was
this
semantic
uncertainty,
so
we
classically
as
soon
as
semantics
are
pretty
clear-cut.
C
Different
endpoints
agree:
what
at
semi-desert
accent
but
in
real
life
I
mean
real
citizens
that
can
be
pretty
hard,
so
we
may
need
to
be
able
to
deal
with
cases
where
we
don't
have
quite
hundred
percent
certainty.
What
are
the
same
and
is
of
the
other
end
that
how
do
we
deal
with
that
kind
of
situation
and
also
one
interesting
observation
with?
It
is
usable
semantics
so
just
like
with
our
UT
security,
if
the
security
is
not
usable,
it's
useless
so
also
semantics
need
to
be
usable
for
developers
start
using
it.
C
C
So
few
quick
learnings
that
we
learnt
there
well
the
semantics
stuff
actually
is
harder
than
you
think.
I
mean
we've
been
doing
this
forever
for
a
while
now
I
still
with
some
struggles.
So,
yes,
how
do
you
more
usability
for
the
semantics
is
very
useful
and
we
have
a
book
different
views
on
that
on
the
area.
So
that's
why
one
thing
why
we
are
not
trying
to
document
our
views.
We
have
better
shared
understanding.
What
do
we
mean
actually
with
all
of
this?
C
So
it's
almost
meta
semantics
of
our
own
work
and
when
it
comes
to
hackathons
and
work
less
and
such
yes
setting
up
and
testing
stuff
even
before
the
event
helps
a
lot.
We
did
a
bit
of
that
already.
This
time
we
have
stuff
running
online
etc,
but
even
even
more
of
that
is
needed
for
the
future
hackathons
and
we
did
discover
a
bunch
of
potential
research
topical.
It
ended
in
Archie,
something
we
could
build
in
closer
and
if
any
of
you
are
interested
on
any
of
these
topics,
please
go
ahead
and
join
the
discussions.
E
Thanks,
it's
a
moral
reflection
when
you
were
talking
about
the
semantics,
a
similar
use
case,
you
would
have
seen
in
the
oma
DM
mailing
list
on
the
from
David
on
this
topic.
Probably
it
is
good
to
interact
and
then
see
what
we
are
going
to
solve
in
1.21
is
coexisting
in
the
semantic
solution.
Yeah,
that's
a
good
point.
We
should
have
a
closer
look
at
that
together.
Let's
put.
B
B
Right,
okay,
so
I
want
to
talk
about
sort
of
what
we're
currently
doing
with
IOT
schema.org
and
then
some
examples
of
the
work
we're
doing
and
then
hopefully,
I
can
sort
of
wind
up
with
a
sort
of
elevator
pitch
sort
of
what
the
message
is
that
we're
using
going
forward
so
next
slide.
Please
we
had
participated
in
a
workshop.
B
Can
you
yeah?
We
participated
in
a
workshop
that
was
held
in
conjunction
with
the
semantic
web
conference.
That
was
an
SSN
workshop.
I
have
summarized
the
presentation
at
the
end.
It's
also
I
think
another
teleconferences
folder
of
IOT
schema.org
and
really
what
we
learned
was
that
that
the
terms
were
using
for
action
that
in
property
are
are
overloaded
that
they
already
have
other
meanings.
We
took
care
to
explain
what
we
meant
in
terms
of
these
being
types
of
affordances
unconnected
things.
B
Then
they
understood
that,
but
we
need
to
sort
of
resolve
the
terminology
issue,
which
is
a
good
thing.
People
wanted
to
know
only
when,
when
things
are
going
to
be
available
to
use
and
how
how
they're
going
to
create
and
use
definitions
and
what
tools
are
available
for
that.
Also
that
there
was
a
quite
a
bit
of
interest
in
using
the
definitions
with
existing
ecosystems,
as
Ari
mentioned,
and
some
has
talked
previously.
B
Great
so
other
people
presenting
had
some
automotive
and
building
management
and
and
Home
Care
Aging
in
Place
sort
of
use
cases
and
they're,
really
all
a
lot
of
them
mentioned
web
of
things
and
a
lot
of
mention
some
similar
concepts
about
what
we're,
what
we're
focusing
on
and
what
we're
missing
in
terms
of
feature
of
interest,
as
well
as
some
of
the
other
gaps
like
the
observable
property
tax
on
amis.
Like
you
know,
air
temperature,
you
know
water
pressure,
things
like
that
that
we
want
to
be
able
to
express
the
sensor.
B
Actuator
vocabulary
is
really
what
we're
working
on
with
IOT
schema.org
and
then
there's
sort
of
a
need
to
express
processes
and
procedures
which
I
would
say
commonly
called
also
rules
and
behaviors
and
scenes,
and
things
like
that,
so
we
there's
quite
a
bit
of
agreement
on
what
we
need
to
focus
on
going
forward
next
slide.
Please,
yes!
Well!
That
was
the
SSN
workshop.
A
B
I,
don't
think
so.
Let
me
try
to
get
ahead
of
it,
a
little
bit.
Okay,
so
where
we
are
in
terms
of
organization,
we
have
a
charter
for
community
group,
which
is
since
we
don't
really
have
our
own
way
of
having
a
legal
policy
where
org
and
the
WBP
community
group,
who
created
a
leaner
and
some
introductory
material
and
we're
working
on
immigration.
What
schema.
D
B
The
idea
is,
we
want
to
try
to
have
there
not
be
a
difference
between
the
IOT
products
schema.org
and
the
other
part
in
terms
of
you
know
having
to
have
a
subdomain.
We
also
mean
that
you
unify
the
way
we
we
do
the
definitions
and
there
are
some
things
there
with
using
RDF
shape.
You
won't
really
want
to
hold
on,
but
it's
also
a
kind
of
a
big
change
and
a
big
learning
curve,
so
we're
working
on
that
again
and
and
and
other
folks
to
try
to
figure
out
how
to
bring.
B
A
B
We're
developer
tools,
basically
what
people
use
to
create
definitions
and
then
what
people
use,
how
people
use
definitions
and
deployed
systems,
and
this
is
where
we
overlap
a
lot
with
the
wish
you
work
in
the
plug
fests,
and
you
know
there
are
some
examples
here
of
where
we
want
to
integrate.
They
don't
have
to
read
through
them,
but
they're
all
basically
having
to
do
with
recognizing
that
that
the
existing
definitions
really
fall
into
two
categories.
B
One
of
device
ecosystem
is
like
ocf
and
OMA
in
other,
is
more
along
the
lines
of
features
of
interest
such
as
the
Genevieve
ESS
that
describes
parts
of
an
automobile
or
an
haystack
and
brick
ontology
that
described
HVAC
system
connected
buildings
and
things
like
that,
a
bunch
of
other
api's
that
are
no
dedicated
product,
api's,
like
the
like,
so
that
that
are
interesting
to
to
annotate,
also
and
for
working
on
over
these
next
slide.
Please,
yes,.
F
B
Right,
quick,
quick
example:
basically
what
we
want
to
get
the
existing
definitions,
machine,
readable!
We
want
to
annotate
those
definitions
and
then
use
those
annotations
next
slide.
Please,
yes,
in
this
format,
is
sort
of
generate
thing,
descriptions
or
whatever
we
have
in
the
runtime
instance,
can
hyper
media
controls
for
instances
of
things,
and
this
is
roughly
the
process
and
I
think
it
matches
up
with
what
what
Aria
is
working
on,
and
some
of
the
other
folks
like
mike
mackool
on
was
the
augmentation
next
slide.
Please.
B
B
Right
next
slide,
please,
yes,
so
some
of
the
others
have
been
working
on
the
API,
automation
and
I.
Think
I
already
talked
about
that.
The
idea
is
that
the
software
applications
should
be
able
to
use
our
abstractions,
which
are
the
interactions
like
read
and
write
property
and
zouk
actions,
subscribing
them
to
unsubscribe
from
events
that
could
be
the
API
fanatic,
abstract,
a
piane.
B
Also
there's
some
ID
building
templates
around
red.
So
here's
some
examples
next
slide.
A
semantic
API,
for
example,
could
could
sort
of
assign
variables
based
on
matching
semantic
capabilities,
and
the
idea
is
when
you,
when
you
get
something
in
response
to
a
query,
then
that
itself
can
also
be
queried,
and
so
you
can
build
this
chain
of
next
slide,
a
semantic
API
that
would
take
a
P
I
that
that
basically
has
get
me
a
light.
B
B
Those
automatically
through
these
these
adapters
and
the
next
slide
please.
So
the
idea
is,
you
can
build
these
things
up
with
recipes
as
recipes
and
and
do
your
discovery
at
runtime
and
just
provide
these
rules
and,
as
you
know,
of
course,
then
we
need
to
semantically
describe
what
these
do
and
things
like
that,
so
that
machines
plug
them
in.
B
But
this
is
sort
of
important
API
automation
right
next
slide,
I'm
drawing
taller
the
organization
where
we're
setting
up
the
community
group
so
that
people
can
contribute-
and
we
have
a
bunch
of
contributions
ready
to
go
from
you
know
from
from
our
company
and
from
some
others
that
want
to
look
at
bringing
bottles
and
also
this
idea
to
create
some
test
beds.
You
know
their
plugs
house
and
I
think
the
idea
was
brought
up
to
work
with
them.
I
see
on
this.
The
industrial
internet
consortium
who
already
creates
test
beds.
B
Ok,
so
next
slide
the
upcoming
teleconferences
that
for
IOT
schema.org
we
have
a
dr.,
emily
shear
are
coming
to
talk
about
this
great
survey
that
they've
done
on
all
of
the
existing
definitions
for
devices
and
and
definitions
that
are
out
there
for
both
devices
and
features
of
interest.
And
so
that's
it's
a
great
sort
of
everything.
That's
been
done.
The
wave
and
ZigBee
and
back
in
that
and
great
thing
in
there
and
so
that'll
be
interesting.
Oh
Bruce
Norton
is
working
on
energy
month.
I
come
talk
about
some
use
cases.
B
B
They
did
everything
from
the
video
all
about
to
application
layer,
but
we're
really
trying
to
partition
things
out
so
that
they,
you
know
more
choice
and
more
composability
and
more
modularity,
and
the
thing
that
we're
focusing
specifically
in
our
message
about
what
we're
doing
next
slide
23
is
that
we're
we're
basically
providing
a
way
to
to
connect
stuff
that
already
exists
in
the
semantic
world
as
well.
We're
not
inventing
new
quantities
or
units
we're
not
inventing
new
features
of
interest,
but
our
definition
work
around
the
software
affordances,
so
that
next
slide
lasts.
B
Why
Michael
do
you
want
to
have
questions
no
or
in
the
end
we
have
one
in
the
cube.
I'm,
almost
done
and
I
want
to
take
questions
after
I
really
make
this
last
point:
okay,
thanks,
Kela,
org
and
the
way
we're
solving
this
problem
is
that
we're
we're
basically
enabling
these
software
affordances
that
are
unconnected
things
like
door
locks
and
light
brightness
can
and
we're
enabling
them
to
be
connected
to
the
real
world.
B
So
we
can
say
you
know
so
lock
the
security
doors,
and
we
have
enough
semantic
description
to
to
make
that
part
of
the
API.
So
we
can
say
that
in
the
API
instead
of
having
to
worry
about,
you
know
all
of
the
protocols,
so
those
blows
I,
basically
our
message
out
to
the
community
and
and
that's
how
I
got
the
feedback
that
we
got
okay.
So
that
said,
it
now
is
a
good
time
to
take
questions.
I
think
we're
pretty
much
okay
on
schedule
right.
G
Could
you
could
go
back
a
few
slides
on
this
one?
The
stars
like
you,
don't
see
it
here,
but
not
this
one,
the
one
that
you
just
had
yep
so.
G
Michael
you're
saying
you're
not
adding
a
new
standard
which
it's
just
an
adaptation
layer.
You
know
if
I
would
put
like
weight
into
them
in
the
middle
of
the
box
and
would
say
maybe
every
instead
of
it
maps
that,
like
the
temp
time,
is
probably
the
wrong
the
wrong
comparison
here,
because
we
would
have
to
talk
about
the
data
model
or
the
ocf
data
model
and
then
map
anything
else
to
this.
G
But
they
are
not
yet
another
new
standard,
the
adjuster
new
star,
and
that
that
sort
of
bothers
me,
because
it
creates
this
unfortunate
situation
that
we
and
like
you,
had
in
your
in
the
in
the
comic
that
we
are,
of
course,
adding
a
new
standard
to
a
new
modeling
language
for
describing
things
which
unfortunately,
fragments
the
ecosystem
and
the
ecosystem.
That
is
focused
on
standardized
based
solutions.
I
think
there
should
be
more
collaboration
among
the
companies
working
on
the
standards,
because
then
I
think
the
committee
order,
the
enemy
is
not
the
other
standard.
G
G
I
know
that
this
is
very
great,
like
everyone
likes
to
work
on
new
stuff
and
create
yet
another
new
thing,
but
if
I
believe
it's
better,
if
we
actually
use
what
we
have
and
then
go
from
there
and
try
to
make
the
best
out
of
that
call
me
weird,
but
I
think
the
standards,
ecosystem
and
IOT
many
of
the
companies
here
who
are
in
this
room
have
been
working
on
on
their
products
for
many
years
and
I.
Don't
know.
If
then,
needs
to
be
a
point
in
time
where
we
say
ok.
This
was
now
enough.
G
Now
we
haven't
created
so
many
things,
so
many
different
variants,
and
now
we
actually
need
to
make
use
of
them
like
there's
a
long
list
of
different
data.
Modeling
standards
that
nobody
ever
uses
and
doesn't
use
today,
they're
just
on
paper.
They
sound
nice
and
cool
and
do
all
sorts
of
great
stuff,
but
they
are
not.
E
Iii
Michael
Potter
here
hope,
you're
doing
fine.
The
my
general
comment
or
question
is
now
you're,
making
one
semantic
interoperability
definition
with
your
experience
in
all
these
hackathons
etc.
Do
you
see
the
need
for
splitting
into
two
or
three
different
types,
depending
on
what
all
is
coming
through
and
going
out
of
it
rather
than
making
a
one
monolithic,
semantic
interoperability
definition.
B
Yeah
I
would
agree
with
that,
and
and
really
we're
not
really
trying
to
do
a
monolithic
definition
and
I
think
maybe
one
of
the
things
that
didn't
really
I
didn't
really
talk
about.
That.
Much
was
that
the
idea
is
that
people
from
different
application
domains
can
really
bring
their
own
definitions.
What
we're
trying
to
first
standardize
on
is
just
the
deserialization
languages
and
the
processing
tools
so
that
we
can
have
a
common
set
of
things
there
and-
and
that
also
means
a
common
set
of
semantic
categories.
B
So
we
want
to
talk
about
capabilities
and
interactions
and
data
types
and
and
so
in
in
a
sense
that
that
we
want
to
find
some
things
that
are
common,
so
I
guess
to
the
last
part
of
the
answer
to
that
is
that
we
we
have
discovered
that
all
of
these
different
standards,
like
you,
look
at
ZigBee
and
lightweight
into
em,
and
all
of
that
you
look
at
how
a
light
bulb
is
controlled
and
they're
really
all
doing
the
same
thing.
They're
just
providing
different
interfaces
and
different
realizations
of
of
the
information.
B
That's
needed
to
do
that.
So
change.
The
brightness
of
a
light
bulb
turn
it
on
turn
it
off.
What's
the
current
temperature
set,
the
temperature
of
the
thermostat
these?
These
are
all
common
that
nobody
really
does
anything
different,
and
so
these
are
really
the
try.
The
things
that
we
hope
to
normalize
in
terms
of
the
semantics
and
the
other
thing
that
we
didn't
really
you
know
talk
about
a
great
length
was
that,
as
Hana
said
at
the
workshop,
we
had
these
these
stars
and
part
of
that
was
we
were
trying
to
decide
between.
B
B
So
this
is
part
of
really
trying
to
bring
things
together
and
and
really
trying
to
add
another
layer.
Instead
of
trying
to
build
another
standard
to
compete
at
the
same
layer,
and
so
in
the
sense
of
does
another
layer
compete
well,
I
don't
know,
did
IP
networks
did
compete
with
token
ring
and
did
compete
with
x.25.
H
I'm
gonna
be
a
little
bit
controversial,
so
we're
all
Internet
engineers.
We
love
to
completely
define
our
problem
and
be
able
to
exactly
control
and
speak
and
understand
everything
and
all
the
semantic
model
about
every
piece
every
bit,
but
recently
I
started
working
with
data
scientists.
We
have
team
data,
scientists,
unarmed
and
on
they're,
all
Millennials
they're,
a
little
crazy.
You
guys
know
Millennials
right.
We
have
some
windows
in
this
room
and
they
were
there,
their
math
people
and
they
work
with
Python
and
they
they
look
at
that.
H
A
completely
different
way
than
we
do
and
I
think
I've
started
to
see.
Some
warning
bells
go
off
for
myself,
but
I
don't
understand
how
the
people,
who
actually
have
to
make
sense
of
the
data
coming
out
of
our
things
that
produce
information
over
the
Internet
are
going
to
make
use
of
that.
How
they
understand
the
data.
H
What
are
the
tools
they
need
to
interpret
it
and
on
machine
learning,
algorithms
on
it
generate
useful
results,
because
in
the
end,
what
matters
in
IOT
is
that
a
business
or
a
consumer
can
generate
value
right
from
these
systems.
It
does
something
useful
and
that's
going
to
involve
a
lot
of
big
data
and
a
lot
of
data
scientists.
So
does
it
matter
what
I'm
starting
to
realize
working
with
data
Sciences?
Is
they
don't
care
about
semantics
of
your
data?
Dump
it
all
in
a
big
table
and
they
will
figure
it
out.
H
They
need
some
guidance
to
be
useful
to
have
some
some
documents
that
explain
what
the
semantics
of
this
stuff
is.
Where
did
it
come
from?
Is
it
trustable
device
at
the
station
comes
into
play,
but
actually
they
don't
care
about
knowing
every
little
bit
of
information
about
the
semantics
or
that
ontology
doesn't
matter,
I
think
there's
something
we
just
want
to
keep
in
mind
when
we're
working
on
this
now
I
get
it
for
control
and
a
lot
of
this
talking
about
control.
B
One
of
the
things
that
has
come
out
in
the
review
of
these
semantic
categories
is
that
it's
good
to
have
that
the
data
plane
in
the
control
plane
separated,
which
was
feedback
I
got
from
your
team's
acted
exactly,
was
that
it
was
good
for
people
who
are
just
working
on
data
to
be
able
to
deal
with
the
semantics
of
the
data
and
yeah.
This
is
temperature
data.
B
Just
to
have
some
simple
hints
about
the
data,
like
you
said,
not
the
whole
ontology,
but
in
terms
of
the
definition
to
it's
useful,
to
have
an
IRB
standard
was
the
feedback
where
they
don't
have
to
worry
about
the
interaction
model
and
can
deal
with
just
just
the
data.
So
maybe
there's
some
ways
of
sort
of
taking
this
use
case
into
account
and
building
out
that
part
of
it.
Yeah.
H
Thanks
Mike
I
think
that's
a
good
point
and
maybe
that's
something
to
take
into
account
and
the
work
you're
doing
here,
that
kind
of
architecture,
the
difference
between
control,
plane
and
control
and
and
just
data
gathering
and
as
an
example,
I
started,
throwing
some
of
our
models
and
tools
we
have
at
the
IETF
towards
data
scientists
and
when
I
showed
them
sin
ml
there
were
mind
blowing.
How
can
you
have
this
much
information
about
the
data?
You
actually
know
the
unit
at
a
time.
H
You
know
this
is
like
already
a
huge
improvement
from
what
they
have
today.
What
people
just
dump
lots
of
stuff
into
a
json,
random,
json
format,
and
they
have
to
like
shift
through
it
and
figure
it
out,
so
we
might
want
to
might
not
want
to
put
the
bar
and
the
complexity
level
too.
High
people
already
stuck
the
value,
the
simple
stuff
that
we
do
so
control
versus
data
pen.
That
might
be
a
useful
tool
actually
for
the
researcher.
I
H
B
H
Has
to
understand
the
relationships
more
than
it
having
to
be
machine
interpretable
at
runtime,
so
yeah
I
see
there's
a
new,
and
this
is
a
new
thing.
We
have
to
take
into
account
when
we're
when
we're
doing
work.
Here's
take
into
account
the
big
data
processing
needs
and
what
people
are
trying
to
achieve.
I,
don't
know
the
answer,
that's
why
this
is
really
a
good
thing
for
the
research
group
to
look
at.
J
J
But
they
in
the
end
have
small
pieces
of
the
same
kind
of
information
and
they
annotate
it
in
the
right
way
and
different
search
engines
can
understand
this
and
can
make
sense
of
this,
and
this
key
idea
is
also
kind
of
reflected
in
the
IOT
schema,
awk,
world
and
I.
Think
a
big
part
is
that
it's
this,
this
closed
world
assumption,
so
we
don't
describe
everything
and
then
have
a
complex
ontology
to
really
understand
everything,
but
just
to
identify
and
know.
A
Yeah
I
would
like
to
that.
There
are,
of
course,
many
different
things
you
can
do
with
IOT
and,
and
one
is
data
Gareth
gathering
and
in
particular,
if
the
the
things
actually
do
would
the
result
of
the
data
gathering
are
kind
of
inconsequential.
So
you
care
about
the
the
overall
statistical
likelihood
of
your
conclusions
being
right,
but
it's
it's
not
a
disaster.
A
I
would
be
in
weird
places
at
weird
times.
So
in
that
case
the
data
quality
is
not
very
hi
and
it
requires
human
intervention
to
actually
make
useful
results
from
that.
I'm
still
happy
that
they
do
this,
because
some
some
people
don't
know
how
to
generate
ICS,
mysteries
and
so
on,
but
I
think
the
direction
we
want
to
move
in
is
we
want
to
make
it
easier
for
developers
to
actually
generate
data
that
can
be
used
for
processes.
The
outcomes
of
which
have
a
high
consequence.
A
J
Okay,
so
yeah
I'm
part
of
the
ITF
I'll
participate
here,
but
I'm
also
co-chairing
a
working
group
at
the
w3c,
which
is
about
about
things
we
have
been
around
for
almost
two
years
now
and
yeah
I
have
some
updates
on
what
we
did
recently
for
giving
you
the
recap
what
we
are
doing.
It
would
be
nice
to
have
two
slide.
J
D
J
J
So
what
are
the
interactions
that
are
around
there
and
we
try
to
to
to
collect
some
pieces
of
technology
from
from
the
World
Wide
Web
that
worked
there
that
helped
you
to
have
some
convergence
in
on
these
different
applications
that
we
have
on
the
web
and
adapt
and
in
such
a
way
that
they
work
for
for
IOT,
and
the
working
group
now
has
the
following
deliverables.
So
there's
a
document
on
the
overall
architecture
like
how
should
these
different
pieces
come
together?
J
The
central
one
is
the
fing
description,
so
this
is
a
representation
format
where
you
can
collect
all
this
metadata
and
annotations
for
existing
systems.
We
have
an
informative
document
on
binding
templates
that
basically
just
explains
you
how
you
can
use
the
finger
description
to
describe
an
own
ecosystem
or
device
of
an
own
ecosystem,
so,
for
instance,
this
is
how
you
would
describe
an
o
CF
device,
and
then
we
have
an
optional
building
block
a
scripting
API,
because
there
was
a
big
demand
for
kind
of
a
common
runtime.
How
do
you
develop
a
UT
application?
J
So
this
finger
scription
is
a
JSON
based
format,
that's
just
because
of
the
popularity
for
developers
and
also
data
scientists
and
so
on.
So
it's
basically
made
out
of
three
features.
So
one
is
that
we
can
provide
you
semantic
annotations
that
we
just
heard
from
from
Michaels.
So
it's
about
controlled
vocabulary
and
you
can
annotate
specific
parts
yeah
with
birds
that
a
group
of
people
agreed
on
this
is
where
we
collaborate,
for
instance,
with
the
IP
schema
org
activity.
J
Then,
overall,
the
document
is
built
in
such
a
way
that
you
can
parse
it
with
the
json-ld
tooling.
So
the
JSON
OD
is
something
that,
let's
you
parse
JSON
document
and
create
ripples
out
of
it,
so
that
you
can
use
the
Semantic
Web
tooling,
which
is,
for
instance,
quite
powerful.
If
you
want
to
have
complex
queries,
that
includes
the
semantics
about
something.
J
So
the
sparker
queries
is
something
that
is
done
quite
often,
and
one
of
the
most
powerful
tools,
I
would
say
with
good,
tooling,
behind
and
there's
also
reasoning
capability,
so
that
you
can
in
fear
some
new
knowledge.
If
you
have
it
in
this
triple
format.
And,
however,
we
got
a
lot
of
feedback
that
they
should
also
be
in
alternative
paths,
so
that
you
can
take
a
thing
description.
J
The
second
aspect
is
to
be
able
to
describe
data
model
that
is
in
the
different
devices.
So
for
that,
we
adopted
a
JSON
schema,
because
it's
a
widely
used
standard
for
that.
What
we
provide
is
basically
a
link
data
version
of
that.
So
we
take
the
central
vocabulary
and
transfer
it
willing
take
of
vocabulary
so
that
it
can
be
plugged
into
the
finger
scription
and
a
nice
part
is
that
these
data
schemas
are
fully
compatible.
So
you
can
take
them
from
the
finger
scription
feed
them
to
a
JSON,
schema
validator
and
those
already
existing
implementations.
J
Work
for
for
that
purpose,
and
the
last
part
is
where
we
leverage
hypermedia
controls
so
work.
That
was
also
done
in
the
t2
TRG
to
describe
the
interactions
between
things.
So
one
aspect
is
that
we
have
web
linking
that
yeah.
We
can
express
the
relation
between
one
thing
to
other
things
like
sub
components
of
the
thing
or
what
is
controlled
by
the
thing,
but
also
point
to
classic
document
so,
for
instance,
additional
metadata
for
thing,
which
can
even
be
just
a
manual
for
the
human
reader
that
that
you
can
discover
this
way.
J
The
other
half
is
this
hyper
media
forms
that
were
discussed
a
lot
in
this
group.
It's
kind
of
a
more
extensive
way
to
describe
how
to
construct
a
request
that
will
be
understood
by
the
origin
search
and
with
that
we
can
basically
have
the
model
of
the
thing
we
understand
on
the
high
level.
What
is
the
semantics
based
on
this
kind
of
controlled
vocabularies?
We
can
understand
the
data
model
used
on
the
data
schemas,
and
then
we
also
know
how
to
construct
a
request.
J
F
for
specific
protocol
kind
of
the
common
denominator
here
is
that
you
must
be
a
your
I
scheme
for
the
protocol
that
is
being
used
and
the
starting
point
is
having
HTTP
queue
up
in
there
and
we
are
working
on
getting
some
MQTT
your
eyes
so
that,
finally,
these
topics
become
a
bit
more
usable.
Let's
say
that
you
can
also
address
them
in
this
wet
way
that
there
is
this
yeah
uniform
interface
for
this
yeah
not
to
be
ignore
about
ecosystem
in
the
IOT.
J
The
fingers
capture
provides
a
lot
of
extension
points.
I
mean
it's
kind
of
the
first
piece
that
we
are
standardizing
and
we
need
a
lot
more
experience
from
the
field
for
that
to
be
included
a
lot
of
extension
points.
One
is
that
you
can
plug
in
your
domain
vocabularies,
so
it
could
start
like
bottom
up
that
some
existing
ecosystem
has
some
specific
semantic
definitions
that
you
create
a
link
data
vocabulary
out
of
this
and
using
json-ld
context
mechanism.
J
You
can
plug
this
in
and
then
annotate
if
you're
understanding
what
your
device
is
offering
and
then
that's
already
a
good
starting
point
for
others
who
want
to
understand
that,
because
they
have
some
clear,
unique
identifiers
stea,
what
what
is
the
meaning
of
the
individual
pieces
and
the
other
part,
is
these:
what
binding
templates
where
we
started
already
describing?
Okay,
if
you
have
an
HTTP
server
somewhere
that
behaves
in
that
and
that
way.
J
Good,
a
quick
update
on
the
recent
changes
so
feature
wise.
We
revisited
the
event
interaction
pattern,
and
what
we
saw
is
that,
for
instance,
for
webhooks
often
you
need
some
kind
of
input
formats,
so
you
have
to
construct
a
message
that
you
sent
there,
where
you
can
often
also
define
like
filters
or
need
to
specify
some
details
that
you
can
actually
subscribe
to
in
the
event
and
coming
back
to
the
web.
J
Hooks
often
as
existing
services
need
a
special
format
for
the
cancellation
message,
and
yet
those
parts
can
now
also
be
described
next
to
the
actual
data
that
is
then
transmitted
to
you
when,
when
an
event
occurs,
the
second
part
is
something
that
has
been
kind
of
on
the
back
burner.
We
knew
it's
required
your
eye
templates
and
yeah.
We
are
finally
kind
of
resolving
this.
We
had
a
lot
of
other
things
to
do.
That's
why
it's
it's
late.
We
had
a
few
alignments
of
the
terminology
that
we
are
using.
J
One
was
that
we
started
with
the
term
called
writable
to
identify
properties
yeah
that
you
can
write.
We
are
now
aligning
with
the
JSON
schema
term.
Read-Only
one
was
that
we
got
feedback
from
others
that
by
default,
their
properties
are
writable.
So
it's
a
good
default
to
express
it.
This
way,
something
that
we
noticed
is
that
the
world
writable
is
terrible,
because
there
is
no
e.
B
J
You
need
kind
of
the
full
flexibility
that
you,
for
instance,
can
include
the
char
set
for
text,
plain
media
types
or,
for
instance,
for
cozy.
You
also
need
parameters.
We
find
that
json-ld,
for
instance,
also
new
user,
that
a
lot
to
define
the
profiles.
Basically,
what
context
is
applied
to
a
certain
document?
J
And
the
last
point
is
so
originally
we
discussed
here
about
forms
and
kind
of
the
natural
term
that
that
flowers
used
was
formed
relation
times,
because
it's
really
related
to
the
link
relation
types.
We
got,
however,
so
much
feedback
that
we
kind
of
gave
this
up.
Rattle
is
kind
of
relations
links.
Express
relations
to
other
resources
forms
are
more
proactive,
so
we
changed
it
to
up
for
operation
and
hope
that
there's
just
less
discussion
around
this.
This
wording
and
we
added,
if
you
know
new
terms-
and
maybe
the
most
interesting,
is
this
unit
term.
J
We
also
want
to
use
this.
You
come
system
that
this
was
already
used
by
lightweight
m2m,
it's
so
half
layer,
seven
and
so
on.
It's
pretty
powerful
I
also
learned
that
there
is
an
implementation
for
Java
or
maybe
even
included
in
an
upcoming
Java
version.
We
can
then
automatic
conversations
between
two
different
units
that
only
have,
for
instance,
a
different
weight
like
Millie
and
eager
and
so
on,
and
can
resolve
this,
which
is
pretty
nice.
Yes,
I
can
also
provide
a
link,
maybe
I'll
catch
it
in
for
the
uploaded
slides
to
some
recent
work.
J
That
shows
how
you
can
even
do
then
semantic
queries
that
ignore
kind
of
what
unit
is
your
original
data
in
it
can
basically
automatically
convert
to
match.
Whatever
you
write
in
the
query,
so,
for
instance,
give
me
all
the
things
that
are
five
meters
away
and
if
it's
in
the
express
in
kilometers
or
in
inches
doesn't
matter
this
engine
can
can
come
compensate
for
that.
J
So
what's
the
road
map,
so
we
started
around
Christmas
2016.
So
of
course
we
only
started
beginning
of
2017
of
because
of
this
break
and
we
had
two
groups
running
in
parallel.
The
interest
group
was
mainly
for
the
liaisons
and
outreach,
so
there
we
try
to
actually
talk
to
most
of
the
other
standards
organizations
that
are
out
there
and
most
of
them
try
to
solve
the
same
issue.
J
So
this
is
where
we
try
to
cooperate
and
find
better
virgins
and
we
contact
conduct
so-called
flak
vests,
which
is
basically
interrupt
testing,
where
the
participants
already
have
implementations
and
be
basically
yeah
running
code
as
we
use
it
in
the
ITF
and
the
working
group.
We
are
focused
on
on
the
deliverables
and
then
something
that
happened
about
here
is
that
we
got
a
lot
of
feedback,
that
we
need
a
nicer
format
for
the
finger
scription
and
the
json-ld
1.1
working
group
started
their
work.
J
They
had
something
pretty
stable
from
a
community
work
already,
and
we
said
we
adopt
this
because
it's
a
way
more
idiomatic,
JSON
format
that
you
see
json-ld
1.0,
is
really
quite
ugly.
This
adoption
this
change
and
so
on,
however,
caused
us
to
require
an
extension
I
guess.
Everyone
in
Standardization
knows
that
it
always
takes
a
bit
longer
and
the
kind
of
tight
schedule
that
we
have
now
is
that
in
a
January
end
of
January
next
year,
we
want
to
have
a
candidate
recommendation.
J
That
means
this
is
what
working
through
proposes
and
basically
has
to
freeze
the
document,
and
then
we
have
to
go
into
testing
phase.
You
have
to
show
that
there
are
at
least
two
different
implementations
for
each
of
the
features
that
we
are
defining
this
recommendation
track
document
and
then
around
April
May.
We
want
to
have
the
so
called
proposed
recommendation.
This
is
when
the
the
candidate
was
successful.
J
So
that
all
the
tests,
and
so
on,
provide
enough
evidence
that
it's
implementable
and
then
there's
some
process
where
the
AC
representatives
of
the
member
companies
can
can
comment
on
that
and
then
basically
end
up
the
extension.
We
want
to
have
the
recommendation
out
there
and
then
look
in
to
reach
our
Turing.
What
exactly
that
will
be
is
quite
open
for
that.
J
We
plan
to
have
another
double
if
receivable
things
workshop
around
may
probably
happening
in
Munich,
to
connect
to
kind
of
the
community
out
there
to
industry
and
so
on
and
see
what
the
new
requirements
are.
The
last
one
is
was
four
and
a
half
years
ago.
It
was
quite
successful.
It
was
a
broad
audience,
so
we
hope
to
repeat
that
to
really
understand
what
should
be
the
next
features
we
are
working
on
and
in
parallel,
as
Michael
announced
there,
they
will
be
in
I
to
schema
or
community
group.
J
Good.
That
brings
us
to
a
couple
of
duze
kind
of
the
most
worth,
maybe
is
what
we
now
have
to
do,
so
we
adopted
features
from
json-ld
1.1,
and
it
really
makes
the
document
much
much
better.
An
issue
is
that
they
won't
complete
their
work
when
we
want
to
go
to
recommendation,
so
we
cannot
have
a
reference,
a
normative
reference
to
that,
and
in
particular,
because
there's
one
feature
that
is
not
stable
enough.
Yet,
however,
quite
important,
it's
basically
if
you
have
a
resource
structure
with
SAP
resources.
J
Usually,
this
is
converted
by
many
standards
into
a
JSON
structure
that
then
has
a
sub
object
and
then
the
Supriya
sources
as
members
in
there
at
the
moment.
They
cannot
provide
the
your
eyes
that
are
useful
in
data
in
that
way
that
you
basically
construct
a
path
like
that.
You
go
a
bit
deeper
into
this
structure
at
the
moment.
Basically,
if
you
have
something
that
is
called
the
same
way
overrides
the
previous
definition
of
that
linked
data
note
and
that's
really
bad.
J
We
talked
to
the
json-ld
working
group
and
they
were
quite
positive
about
this
feature,
but
it
won't
finish
in
time.
So
that's
why
we
have
to
do
the
work
around
that
our
recommendation
will
basically
define
an
algorithm
that
can
transform
our
well.
The
json-ld
1.1
features
that
are
there
and
then
do
a
J's,
nearly
1.0
processing,
and
that
way
we
have
this
kind
of
yeah
normative
document
requirement
fulfilled
and
two
features
where,
if
you
have
an
opinion
on
that,
we
would
welcome
feedback
a
lot
because
we
have
to
wrap
them
up.
J
One
is
how
to
model
material
interaction,
so
if
you
have
a-
and
they
explained
since
a
special
resource,
they
can
read
out
all
the
properties
at
once
or
there's
another
resource
that
allows
you
to
use
patch
to
write
multiple
resources
at
the
same
time.
What
would
be
the
best
way
to
express
this
to
mala
lists?
There
are
proposals
they
already,
but
we
couldn't
reach
conclusion
and
unfortunately-
and
the
other
thing
is
like
how
far
should
this
your
eye
template
abstraction
go?
J
It's
a
bit
small
in
here:
it's
not
meant
for
reading.
Basically,
we
define
an
ID
field
and
then
you
can
put
any
IRI
in
there
of
it's
your
ends
that
are
used,
but
you
can
also
use
your
else
there.
That
basically
gives
you
the
unique
identifier
on
the
global,
unique
level
that
is
also
used
in
in
the
Semantic
Web.
J
J
So
that's
where
the
web
of
things
is
different
from
the
normal
web,
so
on
the
normal
web
usually
use
really
the
URL,
where
you
can
really
dereference
and
get
the
representation
of
what
what
you're
talking
about
here
in
in
the
web
of
things.
We
often
use
you
our
ends,
so
names
that
cannot
be
automatically
would
be
resolved
and,
for
instance,
there's
this
draft
on
device.
Your
ends
by
a
re
arco,
which
is
one
of
the
best
candidates
to
do
so,
but.
K
J
To
sound
yeah,
so
it's
only
the
identifiers,
it's
not
the
locator,
where
I
can
reach
the
thing,
the
the
way
you
can
reach
the
thing.
There
is
basically
these
form
fields,
and
they
have
also
href
entries
so
yeah
your
eyes.
That
then
point
to,
for
instance,
the
current
IP
address
and
there's
a
mechanism
that
is
pretty
similar
to
the
core
resource
directory.
That
mobile
devices,
for
instance,
can
refresh
and
update
a
registration
so
that
you
can
also
find
mobile
devices
kind
of
the
exact
way
how
you
discover
the
famous
shion's
is
actually
not
defined.
J
J
Yes,
so
it's
again,
it's
not
it's.
At
the
moment
we
don't
plan
to
have
like
the
global
system
and
everything
is
connected
there.
The
problem
that
we
are
solving
is
that,
for
instance,
a
Siemens.
We
do
a
lot
of
professional
building
automation
and
if
you
have
a
building
like
this
or
an
airport
on
hospital,
you
have
so
many
different
systems
that
you
all
need
to
integrate,
especially
now
that,
for
instance,
the
energy
domain
is
combined
with
the
automation
domain.
J
You
have
electric
cars
that
somehow
mingle
up
in
there
and
so
on,
and
you
need
some
consistent
view
over
all
these
systems
and
and
be
able
to
also
then
to,
for
instance,
that
gnostic
queries
to
figure
out
where
something
goes
wrong
and
for
this
integration
step.
This
is
a
very
good
solution
and
then
we
have
to
see
just
like
the
world
wide
web
took
20
years
or
longer
to
actually
evolve
to
effective
application
layer
there.
We
have
to
figure
out
what
is
needed
and
how
to
get
there.
J
K
C
Ok,
thank
you,
mother.
We
are
slightly
behind
the
schedule,
but
we
have
next
to
discussing
on
the
core
applications
and
coral,
so
I'm
going
to
give
a
very
brief
intro
on
what
is
core
applications
and
how
we
are
planning
to
handle
it
in
the
research
group.
So
you
all
know
core
the
constant
restful,
no
iowans,
however,
using
web
technologies
for
the
very
constrained
devices
and
core
applications
are
seen,
applications
that
are
built
in
that
kind
of
environment.
C
So
this
draft
in
picross
Hartke
is
basic
invention
and
template
for
these
current
applications
that
were
a
special
application
designers
are
then
build
high
per
minute
event,
applications
and
interfaces
in
a
structured
way.
So
you
can
think
of
it
as
a
guidance
guidance
document
on
that,
and
the
goal
of
this
document
is
to
have
four
inter
implementers
to
build
interoperable
solutions
for
clients
and
servers,
but
also
be
able
to
reuse
things
more
simply
and
easily,
because
you
have
a
similar
way
of
describing
your
applications.
C
The
next
thing
is
a
representative
for
months,
so
indirect
media
types
you
are
using
for
exchange
in
representations,
and
then
you
have
relation
types
for
links,
but
also
for
forms
and
the
corns
widows
also
mentioned
by
Matias
his
presentation
type
of
things
fun.
You
have
template
of
links,
so
you
may
have
links
that
you
are
putting
information
based
on
variables
during
runtime
and
you
can
have
templates
for
that
and
in
a
similar
fashion
you
can
have
a
form
field
names
and
finally,
in
some
it
is
an
optional
feature
to
have
is
well
known
locations.
C
So,
for
example,
if
you
need
an
API
into
connect
for
how
you
are
able
to
discover
your
application
or
to
interact
a
well-known
location,
can
be
very
useful
for
this.
But
all
in
all
these
artists
are
inbound
instructions.
How
the
coin
can
be
interfacing
with
a
given
to
an
application.
Taking
this
information,
the
client
should
be
able
to
interact
with
hypermedia
controls
that
your
application
is
providing
telemedicine,
that
there
is
a
template.
C
So
the
template
is
pretty
much
a
description,
a
human,
readable
information
about
the
API
containing
information
about
the
seven
components
that
makes
the
previous
slide
and
then
some
other
useful
information
like
application
names.
What
are
some
considerations
for
interoperability
and
security
and
who
are
the
persons
to
contact
if
you
want
to
be
having
some
information
about
this
location
or
perhaps
wanting
able
to
change?
Who
was
using
change
control
and
that's
really
what
the
whole
graph
defines
the
structured
way
of
describing
your
hypermedia
different
applications
and
you
will
be
using
in
an
IOT
environment.
C
So
this
is
the
document
we
are
now
referencing
in
the
restful
design
for
IOT
traffic
as
an
MSN
guidance
that,
if
you
are
doing
an
application,
is
using
hypermedia.
It's
good
idea
to
do
it
in
this
kinda
way
so
and
to
have
this
restful
design
up
with
source
code.
We
will
have
a
reference
distal,
and
so
this
document
would
also
be
very
good
to
be
published
as
a
research
group
document
as
a
result.
So
at
this
moment
of
course,
would
like
to
have.
Is
your
reviews
on
this?
A
About
architecture
and
how
it
did
it
concerns
implementers.
It
concerns
the
particular
engineering
a
bit,
but
it
must
be
actually
about
how
to
use
the
mechanisms
we
have.
So
it's
reasonable
to
work
on
this
in
the
research,
but
for
the
next
couple
of
minutes,
I
want
to
talk
about
one
other
thing
that
we
are
looking
at
about.
A
B
A
That
we
were
trying
to
achieve
so
we
were
moving
away
from
that
compatibility,
but
maybe
it's
actually
a
good
idea
to
look
at
this.
This
current
approach
of
representing
the
same
kind
of
data
and
I
want
to
spend
some
minutes
talking
about
that.
So
the
kernel
has
been
presented
at
a
number
of
in
terms
of
the
research
group,
but
not
never
really
at
a
summary
meeting
at
as
far
as
I
understand
so
I'm
going
to
use
slides
that
Klaus
has
used
at
an
interim
meeting
and
try
to
give
a
very
quick
overview.
A
A
So
once
the
call
of
current
it's
really
about
links
and
forms,
so
the
the
links
we
already
had
in
the
link
forward,
obviously
forms
really
is
an
idea
that,
where
we
have
links
that
point
to
resources
that
actually
require
some
input
to
do
their
job,
we
also
need
to
describe
how
this
input
input
needs
to
look
like
and
recalling
it
form,
because
that's
how
the
equivalent
structure
is
called
in
HTML.
In
HTML,
we
have
a
form
which
is
an
element
that
has
a
link
pointing
to
some
resource,
plus
a
description.
A
What
the
import
data
to
that
resource
would
be
usually
with
a
post
operation.
The
description,
of
course,
is
meant
for
humans
to
be
understood,
so
the
form
has
presentation
aspects
to
it
as
well.
In
HTML
we
don't
have
that
here.
We
just
describe
what
what
are
the
data
and
what
are
the
semantic
components
of
that.
A
So
that's
the
main
thing
that
curl
is
trying
to
do,
but
there's
also
another
aspect.
A
career
really
is
a
way
to
do
composition,
so
you
can
put
things
together
into
a
single
instance
and
it
turns
out
when
you
actually
want
to
use
hyper
media.
You
often
have
the
situation.
You
have
really
small
things,
so
you
have
one
two
byte
integer.
A
You
don't
really
want
to
give
somebody
else
20
by
URI
to
to
get
this
two
byte
integer,
but
really
you
really
just
want
to
provide
this
integer
so
something
that
has
been
hacked
into
HTML
using
the
data,
your
eyes.
Of
course,
we
could
be
using
data
equals
4
for
all
these
data,
but
this
again
would
be
very
inefficient
and
really
the
whole
idea
about
Carol
is
to
make
it
simple
and
obvious
and
efficient
to
put
things
together
into
a
single
instance,
and
one
very
important
aspect
of
this
is,
of
course
it
shouldn't
cause
pain.
A
It
should
because
cognitive
dissonance
and
the
most
representation
formats
have
to
do
something
complicated
with
data
before
you
actually
can
can
include
them,
India
and
Curly.
You
can't
just
dump
them
in
there
and
then
use
them
as
they
are.
So
we
can
put
representations
of
objects
into
a
coroner
presentation
and
the
size
of
the
whole
representation
is
reasonable.
A
Links
and
forms
are
also
encoded.
In
a
compact
format.
We
use
a
lot
of
numbers
instead
of
strings.
We
use
sensible
default
values,
so
usually
you
come
up
with
with
pretty
concise
results
and
I'm.
Not
talking
about
compression
here
compression
is
always
an
issue
for
smaller
devices,
because
it
requires
a
lot
of
resources.
It's
it's
a
concise
format
from
the
outset.
A
So
when
you
put
something
down
it's
already,
pretty
compact
yeah
I
talked
about
the
idea
to
embed
a
representation
into
a
current
document
and
some
of
the
the
generations
you
need
to
go
through
when
processing
a
traditional
Jason
style
document
are
already
taken
care
of.
So
you
in
Korea
you
get
ready
to
munch
data,
they're
cooked
you
don't
have
to
take
them
apart
and
pause
and
take
out
the
bones
from
the
fish
and
so
on.
A
You
can
include
what
you
want
to
include
and
it's
it's
simple
to
do
so.
What's
in
their
data,
of
course,
some
some
form
of
support
for
interaction
models
and
we
actually
have
two
formats.
One
is
the
the
interchange
format,
which
is
the
compact
binary
format,
but
it's
really
hard
to
write
it
on
a
whiteboard
because
well
it's
binary
and
therefore
it
probably
makes
sense
to
have
a
texture
followed.
Yes,
some
discussion
between
the
users
of
coral
is
about
how
well
we
actually
have
hit
that
mark.
A
B
A
The
texture
format
is
a
bit
more
more
of
an
experimental
part
of
coral,
but
that's
okay,
because
it's
not
the
thing
we
actually
interchange.
We
interchange
the
binary
form,
so
one
other
way,
of
course,
would
be
to
say:
well,
the
binary
format
is
in
SIBO.
So
why
don't
we
just
use
seaboard
diagnostic
notation?
A
Well,
as
I
said,
we
are
using
numbers
who
to
represent
a
lot
of
the
structure
and
that
gets
pretty
tedious
writing
down
quickly,
so
people
are
used,
for
instance,
to
the
way
we
are
writing
your
eyes
with
double
slashes
somewhere
and
so
on
and
yeah.
It's
nicer
to
be
able
to
use
the
usual
texture
conventions,
but
there
is
also
a
danger
with
having
a
separate
extra
format.
Actually,
there
are
three
dangers.
A
One
is
that
you
start
thinking
about
the
format
as
if
it
were
the
texture
fault
in
particular,
if
you
make
the
texture
format
convenient
for
writing
things
down
when
generating
stuff,
you
might
be
starting
to
think
in
terms
of
how
do
I
make
this
look
good.
It's
the
texture
format
or
something
like
that.
But
that's
not
the
point.
You
really
want
the
data
to
be
useful
and
to
reprocess
very
easy.
A
There's
also
a
certain
danger
that
these
niceties
you
come
up
with
for
describing
the
texture
format
requires
some
some
syntactic
processing
on
the
way
from
the
texture
format
through
the
binary
format
that
you
don't
actually
have
in
the
binary
format.
So
in
the
binary
format
you
have
committed
to
something
that,
in
the
texture,
format
is
still
lays
about.
So
that
also
can
confuse
your
thinking
a
little
bit
and
more
generally.
Texture
formats
are
great
handmade
examples,
but
handmade
examples
are
a
big
problem
and
we
discussed
this
at
length
in
India.
A
She
phone
calls
and
it's
really
hard
I
mean
on
one
hand
you
need
examples,
there's
no
way
to
design
something
without
good
examples,
but
handmade
examples
of
data
that
actually
are
meant
to
be
generated
by
machines.
Often
don't
have
the
actual
properties
of
what
you
would
get
out
of
a
machine.
So
there
may
be
some
structure.
The
human
has
in
mind
that
that
the
human
actually
transfers
into
the
handmade
example
that
would
not
be
present
in
a
binary
machine
generated
example.
A
But
it's
not
the
thing
that
that's
actually
being
interchanged,
that's
important
to
keep
in
mind.
Okay.
So
the
the
examples
on
the
next
couple
of
slides
are
going
to
be
in
their
texture
format
and
just
to
give
an
example
that
you
know
from
html5
and
html5.
We
can
describe
links
with
a
link
element
which
has
two
important
attributes
well
and
ATF,
and
this
describes
a
link
that
goes
out
from
the
current
document
from
where
you
are
describes
the
link
relation
and
describes
URL
reference.
Actually
that
points
to
some
other
things.
A
So
in
an
HTML
document,
you
might
find
a
pointer
to
a
site
leader,
pointer
to
an
icon
and
a
pointer
to
a
license
that
applies
to
this
document.
Writing
down
the
same
thing
in
Carl,
looks
like
this
in
the
text,
area
forward
becomes
they're
very
compact,
then,
in
the
binary
form,
the
actual
you
are
eyes
in
current
IR
eyes,
so
we
fully
embrace
utf-8.
Here
they
are
in
the
binary
format.
Actually,
Cir
is
our
series
for
short,
but
we
confuse
with
a
product
of
this
name.
A
So
a
serious
just
hide
it
doesn't
have
all
this
decoration
on
its
pre
past.
It
comes
to
you
in
a
place
where
you,
in
the
form
where
you
immediately
can
use
it,
but
you
don't
see
that
in
the
texture
form.
So
if
we
want
to
describe
Robbie
the
robot
that
might
have
an
IDE
a
name
and
some
links
to
other
places
or
other
resources
and
tinnitus.
The
thing,
for
instance,
is
the
name
can
actually
be
written
in
here,
which
in
leap
forward,
we
wouldn't
really
be
able
to
do.
A
We
would
have
to
point
to
another
resource
that
carries
the
name,
so
the
link
targets
can
be
literal
or
they
can
be
real
links
again,
and
what
you
also
can
see
here
is
that
we
are
able
to
supply
a
resource.
So
we
know
about
Nicky
that
that
Nicky
actually
likes
Chris.
So
we
can
include
this
information
here
and
we
can
save
the
receiver
of
this
information
from
the
need
to
actually
follow
that
link
and
obtain
the
data.
A
A
So
yeah,
let's
get
more
more
divisive
here,
so
Susie
Frances
has
two
power
legs
and
if
status,
LED
and
a
headlight,
so
we
have
the
links
for
the
power
and
sale
estates.
We
have
the
league
for
the
headlight
and
there
is
also
a
forum
relation
here
which
tells
us
to
actually
change
the
headlight.
You
can
do
a
put
and
the
put
accepts
a
certain
media
type
water
in
in
this
case
it's
example:
/
bouillon.
You
want
to
ask
your
question
now
or
what
happened
yeah.
We
found
that
the
the
microphone
stands.
H
It's
a
microphone
stand
Union,
the
Union
Union
Union
is
actually
armed.
So
this
is
interesting
why,
when
I
was
looking
through
coral
and
I
stumbled
across
this
text?
For
my
thing,
I'm
just
going
like,
oh
god,
another,
yet
another
text,
format
like
why
can't
we
just
use
html5
links
and
I
know
what
your
answer
is.
Gonna
be,
and
it's
gonna
be
that
while
we
added
this
great
forms
thing-
and
you
can't
do
that
in
html5
rings,
I
actually
don't
know.
If
that's
the
right
answer,
you
might
be
able
to
do
that.
H
L
H
A
One
of
the
the
submissions
to
the
IOT
workshop
that
Oreo
was
mentioned
before
had
the
title
semantic
noise
hurts
and
since
the
the
textual
language
is
only
for
talking
about
examples,
it
makes
sense
to
try
to
optimize
it
for
this
purpose.
So
all
the
various
json-based
formats
are
earlier
in
the
90s.
The
xml-based
formats
for
talking
about
xml
had
this
problem
that
you
you
couldn't
really
use
them.
So
you
always
need
a
tool
to
actually
work
with
it,
which
was
great
for
the
true
vendors.
A
But
then
at
some
point,
when
the
language
relaxed
angie
was
defined.
The
developer
of
that
burst
the
pipe
and
decided
I'm
not
only
going
to
define
an
XML
index
I'm
actually
going
to
define
a
compact
sentence:
the
rnc
cindex
flex
and
rekon
compact,
and
that's
a
model
that
that
we
often
have
in
mind
and
that's
the
model
that
guided
this
texture
link.
But.
H
You
still
don't
understand,
answer
my
actual
question,
which
is
why
couldn't
we
use
an
existing
link
format
to
represent
what
you
would
represent
in
coral
and
have
an
actual
machine
convertible?
You
know
make
it
useful,
rather
than
inventing
a
format
only
for
text
representation
I
mean
engineers
interpret
all
kinds
of
crap.
We
recode
too
right.
E
A
But
actually
I'm
fine,
if
html5
has
a
lot
of
other
problems
and
it's
really
a
presentation
language
and
not
to
date.
Our
language
but
I,
think
that's
a
really
valid
research
question.
Can
you
come
up
with
something
that
looks
a
lot
like
html5
and
that
solves
this
problem
in
any
way
that
you
still
would
want
to
write
this
on
a
whiteboard
and.
H
The
question
can
you
convert
between
html5
links
and
coral
and
vice
versa?
So
how
are
you
moving
in
from
the
constrained
world
of
links
and
representations
to
the
web
world,
because
when
we
worked
on
66
90,
that
was
the
that
we
were
into
so
much
effort
and
energy
to
align
with
web?
Linking
yes
and
you
remember
how
hard
that
was
right
and
we
wanted
to
make
sure
you
could
move
between
the
worlds.
I,
don't
really
see
them
as
separate
I
mean
the
the
web
world
and
the
IOT
world
should
be
converging
right.
H
J
Yes,
so
just
to
add
to
this
so
I
had
big
hopes
that
for
the
finger
scription
for
the
links,
part
I
could,
for
instance,
use
the
link
for
my
Jason
in
there
that
it's
compatible
that
just
like
the
json
schema.
I
can
use
existing
other
implementations
and
kind
of
all
fits
nicely
together.
I
now
hear
that
it
will
be
kind
of
our
own
format.
I
mean,
I
guess,
for
the
timelines.
J
We
need
something
like
this
anyway
to
be
separate,
but
then
there
will
be
some
json
format
that
describes
its
linking
and
models
basically
web
linking
RFC
in
link
data,
and
we
also
have
these
forms
in
there.
So
somehow
they
is
something
popping
up
that
will
exist
anyway.
That
is
a
json
representation.
To
have
like
this.
This
compatibility,
that's
Zack,
mentions
that
they
are
converters,
then,
between
those.
What
would
be
really
nice
yeah.
L
A
L
Thing
that
that
is
kind
of
in
a
proposal
in
the
queue
is
to
make
sure
that
all
that
can
be
expressed
in
coral
can
also
be
expressed
in
rdf.
So
you
could
round-trip
to
anything
that
can
encapsulate
rdf.
So,
for
example,
that
would
be
HTML
was
it
called
HDR
rdfa
in
html5
or
turtle
for
possible
a
different
representation
of
the
text.
A
J
A
quick
comment:
so
yeah,
that's
nice
over
there.
If
the
fingers
good,
should
we
try
to
kind
of
combine
this
linked
data
representation
with
the
raw
JSON
or
kind
of
this
intuitive
the
developers,
monter
json
representation
and
yeah?
It's
it's
really
hard
to
close
this,
the
full
circle.
So
that's
that's
one
big
takeaway
from
the
working
on
whether
things
like.
J
A
J
I
think
they're
two
camps,
so
one
may
be,
expect
Jason
ot
to
be
a
full
representation
of
of
tripled,
so
to
be
some
full
fledged
solution
like
like
turtle
or
rdfa,
I'm,
not
sure
about
that.
What
I
expect
from
it
that's
a
way
that
I
can
attach
meaning
to
an
existing
Jason
format
that
I
can
convert
this
to
something
that
then
can
go
into
the
semantics
pipeline
or
the
machine
learning
or
whatsoever.
So.
A
J
Also
have
impedance
compatibility
is
that
it's
really
directly
feed
Apple
into
a
json-ld
1.1
processor,
and
then
you
heard
me
earlier
that
one
key
feature
is
still
missing,
so
there's
still
some
adaption.
So
we
have
to
see
how
this
works
out
and
this
alignment
is
a
big
challenge,
because
it's
many
different
groups
that
use
it
for
different
purposes
and
there's
a
lot
of
potential
to
have
a
nice
solution.
But
it's
also
very
hard.
A
Okay,
I
think
that
that
was
a
useful,
shortest
discussion
here.
I'm,
not
sure
whether
I
need
to
go
into
these
descriptions
here,
much
more
so
here,
here's
another
formulation,
example
yeah
I
think
I'm
going
to
skip
this
again.
Please
do
read
the
internet
draft
because
that's
very
concise
and
it
contains
the
information
that
you
want
to
use.
So
thank
you
for
for
the
discussion
again.
A
If
the
Cobra
decides
to
pick
up
curry,
we,
the
normative
part,
will
be
the
finally
forward,
and
it
will
also
be
be
of
interest
to
the
Cobra
group
to
understand
how
existing
applications
like
resource
directory
and
pops-up
fit
into
a
world
where
the
current
format
is
available.
As
one
of
the
media
types
you
can
use
in
these
applications.
So
this
is
probably
what
the
COG
working
group
is
going
to
work
on
and
what
the
research
group
probably
should
work
on.
A
This
look
at
the
wider
use
of
color
and
how
can
we
use
it
for
new
applications
and
also
do
these
translations,
for
instance,
try
to
understand
how
it
works
with
equivalent
functionality
that
is
already
in
w3c
darĂo
team.
So
I
think
we
have
a
pretty
reasonably
defined
division
of
work.
The
the
only
thing
that
that
maybe
is
a
little
bit
difficult.
A
The
one
part
of
color
that
is
not
yet
fully
defined
is
the
form
relations
part,
and
maybe
the
car
button
will
first
define
something
that
would
have
a
very
simple
form
of
that
or
it
may
not
have
it
at
all.
And
then
it
would
be
the
job
of
the
research
group
to
maybe
look
at
further
development
of
the
formulation
idea.
A
C
C
Here's
the
full
agenda
for
this
meeting.
So
you
are
all
very
welcome
to
join
and
we
will
have
next
a
couple
of
quick
lighting
talks
from
the
presenters
from
from
that
session.
To
give
you
a
bit
of
a
hint,
what
is
there
gonna
be
in
the
plenary?
So
do
we
have
you
Mahoney
recruitment
tools
and
dom
here
excellent?
C
M
The
title
of
disrupt
is
the
problem.
Statement
of
IOT
integrated
with
adds
computing,
and
this
document
is
describing
a
new
challenges
for
IOT
services.
We
entity
from
the
changes
in
the
IOT
environment
so
to
address
these
newer
challenges.
The
as
computing
is
an
emerging
technology
in
IOT,
so
I
will
show
two
short
demo
videos
as
a
use
case,
what
we
have
developed
in
our
department.
So
one
is
the
smart
constructor
constructions.
M
F
So,
as
you
all
know,
computing
is
rapidly
heading
towards
the
edge,
as
you
can
see
in
the
picture,
and
so
that
looks
very
interesting.
So
in
we've
talked
in
this
research
group
and
elsewhere
about
edge
computing
to
some
extent
and
what
I
wanted
to
do
here
is
sort
of
turn
things
around
and
even
those
this
is
a
networking,
an
internet
crowd,
sort
of
look
at
it
from
there
vacation
perspective.
What
a
current
applications
actually
use
when
they
think
about
a
network
if
they're
running
as
a
VM
or
a
container
in
the
cloud.
F
What
does
that
mean?
If
you
want
to
go,
bring
those
things
to
the
edge
or
if
you
want
to
think
about
okay
in
the
future,
are
we
going
to
deploy
micro
services
at
the
edge?
Well,
what
are
those
applications
look
like,
and
what
do
they
assume
about?
What
a
network
is,
so
some
of
this
stuff
I
think
is
sort
of
more
engineering,
but
but
I
think
that
there's
some
things
we
can
talk
about
that
sort
of
touched
upon
research
in
this
space
as
well.
N
So,
in
a
nutshell,
Security's
hot,
so
let's
automate
it
and
get
it
out
of
the
way.
While
we
drive
it
is
draft.
As
actually
do
we
want
to
introduce
two
protocols
to
provision
IOT
devices
securely
and
then
manage
them
over
their
lifetime
securely,
basically
making
sure
that
whatever
vulnerabilities
exist,
any
contracts
us
that
operator
and
manufacturers
and
users
have
a
way
of
handling
them
and
protecting
themselves
on
any
chain
against
that
might
actually
evolve
out
of
having
you
know
something
smart
in
your
living
room
or
in
your
new
company.
A
Thank
you.
So,
if
would
have
put
it
differently,
if
your
security-
and
it's
not
automated,
you
are
not
secure,
but
I
think
we
agree
on
the
basic
principle
there.
Yes,
it's
a
necessary
condition,
not
a
sufficient
condition.
Okay,
so
these
these
are
three
of
the
four
talks
that
we
will
have
at
the
start
and
the
fourth
talk
doesn't
have
a
pep
talk
right
now,
because
the
SEC
Dispatch
meeting
was
put
on
top
of
this
meeting.
So
there
are
no
security
people
in
this
room,
hello,
Hannes,.
A
Okay,
Oh
Jimmy
Cheska's
there,
okay,
not
quite
sure
anyway,
so
we
want
to
have
these
talks
to
to
prime
our
minds
and
then
at
9:40.
We
want
to
discuss
what
what
a
good
break
outs
to
have.
So
we
are
not
going
to
sit
in
plenary,
we're
going
to
divide
ourselves
in
two
or
three
breakout
and
do
these
from
10:00
to
12:00
and
then
at
the
end,
sit
together
and
pull
together.
A
The
information
that
we
have
learned
and
one
of
the
the
breakouts
we
forgot
to
put
in
its
life,
one
of
the
breakouts-
is
going
to
be
the
the
coin
side
meeting
computing
in
the
internet,
so
that
that
is
certainly
also
relevant
to
the
edge
computing
issue.
So
I
think
the
people
who
are
interested
in
edge
computing
will
probably
decide
whether
to
run
their
own
break
out
on
IOT
edge,
I'll,
go
to
that
side
meeting
and
two
other
breakouts.
A
That
might
happen
about
security,
because
we
have
several
talks
about
security
as
input
and
there's
a
lot
to
do
there
and
also
about
hypermedia.
We
are
I
think
most
of
the
work
on
hypermedia
that
we
will
do
in
the
next
few
months
is
not
going
to
happen
in
the
meeting
room,
but
it's
going
to
happen
in
interrupts,
so
the
the
next
step.