►
From YouTube: IETF99-CBOR-20170717-1550
Description
CBOR meeting session at IETF99
2017/07/17 1550
https://datatracker.ietf.org/meeting/99/proceedings/
A
A
C
C
C
Okay,
great
police,
taking
minutes.
Thank
you
Paul.
First
of
all,
the
note
well
as
you're
all
the
way
you're
being
recorded,
and
this
is
a
IDF
contribution
and
you're
supposed
to
follow
the
rules
defining
these
two
RC,
so
yeah
I
mean
if
they're
taken
this
meeting
is
recorded
and
your
presence
is
logged
and
I'm
gonna
start
passing
the
blue.
Those
sheets,
yes,
and
also
we
need
the
jabber
scribe.
C
Meet
Eko,
you
can
get
me
Tico,
the
okay
Michael,
the
other
Michael
thanks
so
yeah,
just
to
remind
you
that
we
have
a
working
group
github
right
now.
It
contains
the
sea
boar
and
CDL
documents,
as
well
as
other
extensions
documents.
The
authors
are
welcome
to
put
the
draft
there
if
they
want,
but
again
significant
discussion
has
to
go
to
the
main
list.
D
C
E
E
Okay,
thank
you.
So
we
wanted
to
minimize
the
amount
of
swapping
so
yeah
kind
of
cut.
We
need
to
lead
those
slots,
but
that
of
course
doesn't
mean
that
that
my
coffers
won't
run
to
the
microphone
and
fix
what
I
said
so
so
Hank
is
already
very
close
to
the
microphone
okay,
so
the
first
one
is
specification
status
and
before
I,
get
to
that.
I
just
want
to
relate
an
impression,
just
very
subjective
impression.
E
E
So
this
is
not
good
audio
quality.
How
do
I
do
this?
I
need
a
space
on
it
that
keeps
constant
distance
from
my
face,
so
we
had
some
8/7
organization
there,
and
it
was
interesting
to
see
that,
of
course,
everyone
has
still
some
xml
somewhere
most
everyone
is
using
json
for
all
new
stuff,
and
it's
interesting
to
see
that
many
of
them
then
actually
interchange,
see
both.
E
So
I
think
we
have
some
acceptance,
at
least
in
these
standards
development
organizations
that
doesn't
mean
that
you're
right
switch
at
home
already
user
SIBO,
but
at
least
the
science
organizations
seem
seem
to
have
gotten
the
message,
and
one
interesting
other
observation
here-
is
that
a
lot
of
these
send
receiver
over
the
wire
but
actually
use
JSON
tools
for
doing
all
their
work,
so
they're
using
formats
like
swagger,
which
is
defined
for
JSON
and
yeah.
That
may
be
a
hint
that
we
should
be
doing
some
some
work
in
this
space.
E
So
what
do
we
have
to
do
to
get
the
Seaboard
specification
to
internet
standard?
That's
the
name
of
this
age
according
to
64,
RFC,
64
Chen.
So,
first
of
all,
we
cannot
just
move
the
existing
specification
with
the
existing
RFC
number
2
internet
standard.
We
because
we
have
have
errata.
Actually
those
errata
are
in
the
explanatory
text.
There's
nothing
really
knowledge
if
that
is
affected
by
by
the
writer.
So
if
you
read
sixty
four
ten,
we
are
kind
of
killya
here,
because
the
errata
are
just
bad
examples
but
yeah.
E
E
There
also
are
some
violations
of
the
principle
of
least
surprise,
and
we
may
want
to
do
something
on
the
editorial
front
there
as
well
explain
how
this
is
different
from
what
people
might
be
reading
out
of
the
text
and
and
yeah.
Maybe
why
that
is
so,
then
we
probably
do
want
to
revisit
the
INR
considerations
in
2013.
E
We
said,
let's
have
very,
very
liberal,
INR
consideration,
so
everybody
can
just
go
ahead
and
register
something
and
I'm
not
proposing
to
change
this
completely,
but
we
made
might
may
want
to
be
a
bit
more
conservative
with
the
spaces
we
have
and
then
finally,
we
have
to
generate
an
actual
document.
The
request
for
reclassification
and
obviously
64
10
tells
us
what
what's
in
there.
So
let's
talk
about
the
the
the
one
thing
that
we
I
think
we
really
have
to
decide
and
that
that
doesn't
have
a
clear-cut
answer.
E
So
right
now
we
have
two
registries
in
NC
book.
One
is
the
Seaboard
tags
with
a
registry,
and
one
is
the
simple
various
registry.
Now
the
simple
values
registry
hasn't
actually
been
checked
by
by
other
bodies
over
other
documents
at
all.
So
right
now
we
are
still
in
the
original
state
that
70
49
left
I
have
some
sides
at
the
end,
if
I
get
to
them,
where
I
could
show
how
that
might
change.
E
So
we
may
not
complete
want
to
completely
ignore
that,
although
we
don't
have
any
emergency
there
at
the
moment
on
the
tank
side
in
the
tags
registry,
we
already
were
careful
with
the
good
tags
checks
that
can
represent
it
in
one
bite.
So
these
have
standards
action
as
registration
policy,
but
we
have
already
consumed
fifty
percent
of
them
and
for
a
document
that
is
four
years
old
and
it's
supposed
to
last
a
little
bit
longer
than
four
more
years
that
that
is
kind
of
concerning.
But
again
we
have
standard
action
there.
E
So
we
maybe
we
just
want
to
write
a
little
bit
more.
What
we
expect
the
isg
to
do
here
when
reviewing
consuming
another
one
of
those
tags.
Now
we
also
have
a
almost
as
good
range,
which
is
larger,
a
too
much
tag,
a
tag
with
1
byte
header
and
one
byte
additional
information
and
of
that
pace.
We
have
a
two
point,
two
percent
taken,
but
we
have
several
documents
there,
which
each
another
10%
in
one
bite.
So
we
may
want
to
think
about
there,
some
more,
but
also
this
is
specification
required.
E
So
if
Joe
Sixpack
comes
along
and
says,
I
have
this
specification
and
that
needs
193
tags
in
that
space
and
Joe
Sixpack
has
a
specification.
They
will
get
the
space.
So
maybe
we
want
to
do
something
about
this
base
because
to
keep
this
space
here
clear,
we
have
to
have
control
over
this
space
and
finally,
we
have
a
lot
of
space
of
which
can
are
shaking
and
not
worry
about
about
this
part.
So
what
could
we
do?
We
could
move
the
too
much.
E
Eggs
and
maybe
why
we
do
this-
the
to
bite
range
for
simple
to
expert
review,
which
is
one
notch
up
from
certification
required
both
actually
require
an
expert
review,
because
if
Joe
Sixpack
comes
and
says,
I
have
a
specification,
which
is
that
tweet,
which
I
wrote
five
minutes
ago.
We
are
probably
not
going
to
accept
that
as
a
specification.
E
We
need
an
expert
to
make
that
decision,
so
we
are
already
doing
a
little
bit
of
pushback
in
that
space,
but
we
can
only
do
so
much
so
going
to
expert
with
you
with
some
clear
guidelines
what
needs
to
be
fulfilled
so
so
some
of
the
space
that
can
be
used.
That
would
be
one
way
how
so
this
is
just
a
strawman
of
what
might
be
in
those
gadgets,
and
we
also
can
read
retrospectively
think
about
our
own
allocation.
E
E
We
might
want
to
put
in
a
circuit
breaker,
which
means
when
we
reach
50%
usage
of
a
space.
We
actually
change
the
guidelines
by
which
the
expert
operates
and
what
we
also
might
want
to
do
just
just
as
we
need
the
second
range
to
keep
the
first
range
clear.
We
might
keep
some
of
the
third
range
a
little
bit
through
that
range
to
move
things
over
from
the
second
wrench,
like
Michael,.
F
E
Yes,
now
one
thing
is
sometimes
it's
a
good
idea
to
allocate
a
contiguous
range
and
you
may
want
to
allocate
a
contiguous
range
in
a
different
space.
Let's
think
that
of
that
good
part,
okay,
so
this
is
something
that
has
to
be
decided
and-
and
thank
you
for
the
input
to
that.
So
we
probably
want
to
discuss
this
a
little
bit
more
on
the
mailing
list
and
generate
some
text
proposals
for
that
back
to
through
the
procedure,
RFC,
64,
10,
kids,
us.
We
have
to
have
five
things
to
get
a
reclassification
request
through
one.
E
E
Even
the
second
thing
is,
you
know,
errata,
as
I
said,
we
are
going
to
have
that
in
the
new
version.
The
third
thing
is
no
unused
features
that
greatly
increase
implementation.
Complexity.
I
would
go
one
beyond
that
and
because
the
spec
is
fundamentally
pretty
simple,
maybe
we
should
look
out
whether
we
have
any
unused
features
and
number
four.
If
there
are
patent
claims,
we
have
to
show
that
the
licensing
process
works,
but
up
to
now
there
has
been
no
IPR
disclosure,
and
if
there
is
one
then
I
would
point
to
her
an
RFC
from
1978.
E
That
was
approximately
the
same
things,
so
that
will
be
difficult,
but
yeah
people
patent
interesting
things.
So
it
might
happen
at
any
time
so
for
now,
I
think
we
have
to
focus
on
these
two
items
here.
Let's
talk
about
unused
features
for
a
second.
The
best
way
to
check
for
unused
features
is
actually
to
do
an
implementation
matrix.
That
looks
a
bit
like
this.
E
E
If
it's
this
really
the
list
of
features
or
do
we
want
to
be
more
fine-grained
so,
for
instance,
and
just
enumerating
the
tags
here,
maybe
a
tag
has
two
features
in
it,
but
that's
so
comments
on
on
this
list
would
be
useful
and
then
we
should
just
start
filling
in
the
columns
so
who,
in
this
room
actually
has
an
implementation
of
Seba?
That's
always
the
problem
at
the
IGF,
the
implementers
don't
coming.
The
fan
has
half
an
implementation
in
Whitesburg
de
Provence.
E
C
E
E
E
Okay,
good,
okay,
so
the
result
of
that
list
should
be
or
could
be,
a
list
of
tags
where
we
think
well,
it's
kind
of
a
key
that
we
put
them
in
1749,
but
maybe
they
do
not
fulfil
that
part
of
64
10
requirements.
They
talk
about
widespread
deployments
and
they
do
increase
implementation
complexity.
That's
the
other
part
of
the
64
10
and
then
we
could
move
those
over
to
separate
reduction.
E
E
Okay,
good,
so
one
other
thing
we
could
do
in
in
such
a
document,
just
as
a
random
idea.
There
are
some
tags
that
have
been
registered
by
people
somewhere
with
specifications
somewhere
that
actually
are
pretty
fundamental.
So
we
might
go
ahead
and
collect
these
tags
in
a
document
to
make
the
specifications
that
are
scattered
all
over
the
internet
more
accessible,
so
people
will
find
those
tags
and
and
not
get
into
a
situation
where
they
reinvent
them,
because
they
are
not
lining
that.
E
C
I
think
maybe
the
first
step
to
fill
up
this
implementation
matrix
would
be
to
define
which
one
which
implementations
are
the
most
employed,
so
I
think
that's
not
at
least
it's
not
very
clear
to
me.
I,
don't
know
if
if
anybody
I
think
that
would
be
a
good
discussion
in
the
main
list
and
once
that's
defined
like
what
are
the
columns,
then
we
can
ask
what
people
opinion
about.
What
do
you
say?
Alex
yeah.
H
Just
sort
of
clarification
case,
it's
not
clear
for
any
feature.
You
need
to
have
two
independent
implementations.
They
don't
have
to
be
the
same
tool
for
every
feature
right
right,
so
you
know
if
you
have
four
or
five,
which
you
think
are
relatively
widespread
and
between
them
they
cover
all
the
features
with
at
least
two
for
each
feature.
That's
good
enough
right.
E
E
I
To
check
for
that,
this
happened,
so
that
was
my
question
for
Alexi.
Is
we
have
all
of
these
tags
that
are
optional
and
so
long
as
defined?
We
don't
know
if
they're
going
to
be
used
in
data
in
there.
Does
that
count?
Do
we
have
to
show
uses
of
the
tags
or
are
those
considered
those
come
under
the
that
they
did
not
increase.
H
E
H
E
E
This
is
like
the
question,
but
what
do
you
have
to
implement
in
the
first
place
to
be
conforming
with
the
Senate?
And
hopefully
we
don't
have
to
define
confluency,
because
it's
really
difficult
to
say
that
so
any
implementation
can
just
hand
a
tag
that
it
finds
together
with
the
binary
data
that
it
found
up
to
the
application
and
that's
a
way
of
implementing
it.
But
that's,
maybe
not
what
it
was
meant
you.
So,
let's
see
whether
we
find
a
little
bit
more
implementation
there.
E
C
E
C
E
Okay
and
of
course
the
other
thing
I
don't
have
a
slide
for
here
is
please
do
indicate
those
opportunities
for
editorial
improvement
that
that
other
slide
talking
about.
So,
if
you
find
some
text
that
you
think
could
be
improved
just
type
into
the
github
page,
a
comment
just
make
sure
that
this
is
captured
and-
and
we
know
you
don't
like
it
or
you
have
a
better
wording
and-
and
we
can
think
about
good
ways
to
it.
When.
I
E
Let's
expose
this
argument,
I
think
it's
important
to
think
about
this,
even
if
the
the
enemy
side
of
the
thinking
is
no
action.
The
the
Seaboard
document
currently
does
not
say
a
lot
about
what
the
Unicode
is.
You
find
in
its
utf-8
strengths,
it's
very
very
clear
that
the
utf-8
has
to
be
utf-8,
but
it
is
not
talking
about
non
characters
and
things
like
that.
So
yeah
I
think
this
is
about
the
right
level
of
specification
here,
but
people
may
have
different
ideas
about
that,
so
it
would
be
good
to
hear
those.
Thank
you.
E
Okay,
so
sweet
idea,
this
document
is
in.
Excuse
me:
it's
such
an
adoption
call
in
a
confirmation
call
for
the
adoption
decision
we
made
in
Chicago.
The
confirmation
happened
a
little
bit
later,
so
you
still
have
two
days
to
respond
to
this
confirmation
call
so
far.
Nobody
has
responded
to
it,
which
means
the
in
room,
consensus
stance
so
bye-bye
first
day
morning,
I
hope
we
have
a
group
dark
energy.
E
So
what
what's
the
status
of
the
document?
Do
you
always
think
it's
ready
for
when
group
adoption?
We
talked
about
that
in
Chicago,
so
the
objective
is
to
be
referenceable
from
standards
fake
documents
so
that
they
can
write
their
data
definitions
in
CD
DL
and
don't
have
to
copy
them
over
to
to
a
fall
off.
Stylized
English
as
well
so
normative
text
can
use
City
idea
and
there
are
two
ways
of
doing
that:
one
is
going
first,
NF
strike
the
other
one
is
going
for
informational
and
getting
some
some
down
roof
variants
there.
E
E
E
E
E
So
we
I
think
it's
a
good
idea
to
stay
with
that
initialism,
because
people
already
know
it
out
the
end.
Few
people
know
what
it
actually
stands
for
and
it
originally
stood
for
a
seaboard
data
definition
language
and
the
idea
was
to
maybe
make
it
concise
data
definition.
Language.
One
reason
for
that
is
that
the
RFC
editor
will
change
the
title
of
the
document
to
concise
binary
object,
representation,
parentheses,
CD,
C
bar
or
parenthesis
data
different
language,
and
you
will
no
longer
understand
what
the
title
is
referring
to
and
the
other
thing
is
well.
E
C
Francesca
noticed
chair
just
changed
the
Seaboard
to
concise.
If
I
can
quote
you
on
the
Google
argument,
I
think
that
the
first
like
you
sorta,
did
the
other
right
now
is
AC
bar
and
I.
Myself
have
looked
for
this
document
as
CD
DLC
board
when
I
ended
up
on
the
license,
of
course,
so
I
don't
know
I
I
I
liked
it
there,
but
I
understand
I.
Think.
E
E
Let's
do
a
little
bit
of
googling
to
find
out
what
what
the
effect
of
this
okay.
So,
since
Chicago,
we
generated
a
e
level
and
there
are
very
few
technical
changes
in
that
a
level
and
actually
I'm
quite
proud
that
that
everything
that
was
of
5c
DDL
specification
still
is
a
11
detailed
specification.
We
changed
a
lot
in
that
document,
but
for
some
reason
we
have
managed
to
say
compatible
and
we
didn't
you
try
particularly
hard.
E
You
currently
have
to
define
a
group
which
will
then
reference
from
the
first
structure
and
from
the
second
structure,
and
it's
just
a
little
bit
easier
to
just
reference,
the
the
whole
data
structure.
So
you
have
to
write
much
less
to
get
this
effect,
so
the
the
the
tilde
character
here
is
standing
for
threading
in
something
so
you're
threading.
In
the
basic
header
into
the
advanced
header,
so
these
tools
best
vacations
here
are
identical.
E
E
Oh
sorry
about
that,
but
maybe
by
the
end
of
next
week,
so
the
other
technical
change
is
the
ABN
F
was
unnecessarily
restrictive
in
some
cases,
so
you
had
to
put
things
in
parentheses
in
certain
cases
where
it
really
wouldn't
have
been
necessary
to
do
that-
and
this
is
mostly
affecting
the
control
operator,
which
is
the
new
name
of
the
annotation
operator,
but
it
shouldn't
change.
Existing
specifications
just
makes
the
likelihood
that
you
will
get
an
error
message
when
you
write
something
a
little
bit
lower.
E
We
also
made
sure
that
all
Unicode
characters
can
be
used.
Now,
that's
an
interesting
question.
Does
a
B
and
F
even
allow
us
what
to
do
what
we
did?
I
think
that
that's
currently
a
little
bit
under
discussion,
but
I
hope
that
question
is
settled
by
the
time
we
go
to
last
call
on
this.
So
why
is
that
important?
E
Well,
because
people
actually
use
constants
that
have
mineski
beyond
SP
characters
in
them
and
having
to
write
them
in
hex,
it's
just
tedious
yeah
and
the
ABF
changes
the
unwed
operator
we
added
an
appendix
that
talks
about
use
with
JSON
in
the
previous
versions
of
the
document
we
just
took
this
for
granted
now
turns
out.
There
are
a
few
points
where
you
want
to
look
slightly
closer,
and
one
of
this
is
the
the
weirdness
that
jason
has
in
its
number
system,
or
maybe
the
weirdness
that
SIBO
has
in
the
numbers.
E
E
That's
the
kind
of
representation
constraint
that
people
want
to
make
and
I
don't
think.
Cydia
is
the
place
where
you
should
be
doing
that
so
yeah.
We
might
want
to
have
some
some
global
representation
flags,
but
I
think
this
is
fits
with
the
rest
of
cydia
reasonably
well,
okay,
but
the
whole
number
system.
Let
let's
make
one
walkthrough
through
that
number
system.
One
other
thing
that
was
added
is
there
is
an
appendix
G
that
extends
the
diagnostic
notation
of
70
49.
E
Now
one
could
argue
this
should
go
into
a
70
forty
nine
this,
but
then
that
would
be
a
change
and
would
diminish
from
the
argument.
This
is
a
stable
document
that
becomes
internet
standard.
The
counter-argument
is,
we
even
say
you
are
not
using
diagnostic
notation
for
interchange,
so
this
is
a
change
that,
by
definition,
doesn't
affect
interchange
but
still
I'm,
not
sure
that
that
we
should
do
that.
So
that's
why
the
extended
diagnosed
invitation
right
now
is
in
this
document.
But,
of
course
we
could
split
it
out
into
a
separate
document.
E
We
think
this
muddies
the
waters
with
acidity,
because
really
it's
about
sea
walls
not
about
CDR,
it's
a
completely
different
syntax
and
people
do
get
confused
about
extended
diagnostic
notation
for
SIBO
and
sea,
so
yeah
I,
don't
know
we
can
do
that.
We
can
not
do.
That
would
be
interesting
to
hear
what
people
think
about
that.
So
the
specific
change
here
was
we.
We
have.
E
We
not
have
quite
a
few
documents
that
actually
encode
something
in
Siebel
and
then
put
that
into
a
byte
string,
which
is
then
in
turn
happening
in
an
enclosing
Seaborg
document
in
CD
DL.
We
have
dot
C
bar
and
dot
C
bar
sequence
as
a
way
to
specify
that
so
we
are
covered
on
the
CD
outside,
but
the
actual
examples
that
make
use
of
this
I
can't
be
very
hard
to
read.
E
So
this
just
provides
a
way
to
write
down
that
embedded,
C
bar
and
have
the
diagnostic
notation
Pazza
expand
that
C
bar
entrance
it's
bit
hard
to
generate
because
you
cannot
find
out
from
a
single
document
whether
something
is
embedded
C.
Well,
you
have
to
consult
a
schema
for
that,
but
yeah
it
seems
to
work
so
try
it
on
Seaborg
and
years.
If
you
want
to
play
with
it.
E
Yeah
there
are
a
number
of
editorial
changes.
The
main
change
that
is
kind
of
customized
affecting
is
that
we
now
call
annotations
controls,
mainly
because
we
might
actually
at
some
point
want
to
have
something
like
an
anotation
language,
first
CD
DL,
and
we
would
like
to
reserve
the
term
annotation
for
annotations.
When
we
we
started
defining
this
construct,
we
thought
we
were
going
to
use
it
for
annotations,
but
it
actually
hasn't
happened
so
right
now,
it's
it's
just
a
control
operator,
so
we
looked
for
a
better
name.
E
E
So
that's
a
place
where
we
will
see
extension,
in
particular
in
connection
with
new
tags
that
are
coming
in,
and
these
tags
may
want
to
define
their
control
operators
to
have
a
way
of
specifying
what's
in
their
generics,
which
were
in
an
appendix
called
Nursery
know
how
efficiently
drawn
up.
Just
because
we
have
reports,
people
have
used
them
and
found
them
useful.
E
We
filled
the
examples
a
little
bit
because
the
document
was
having
way
more
examples
than
definitive
text
and
it
still
has
more
examples
and
different
effects,
but
it's
getting
a
little
more
a
little
more
balanced.
So
we
kept
the
ones
that
we
think
we
are
more
useful
and
we
move
the
JSON
specific
parts
over
into
an
appendix.
So
people
who
really
want
to
use
CD
refrigeration
can
have
one
place
to
look
at
and
don't
have
to
scan
the
document
for
that
term.
Yes,
so
those
are
the
editorial
changes.
E
E
E
So
it
would
be
nice
if
other
people
were
implementing
CD
ble,
except
that
I
can't
really
tell
you
what
it
means
to
implement
Olivia,
because
there
are
very,
very
different
things
that
a
program
can
do
with
acidity
a
spec.
So
the
the
tool
that
I
wrote
does
about
five
things.
It
can
check
a
CD
das
back
and
it
does
this
by
just
generating
a
completely
random
example.
So
it
uses
every
choice,
point
that
is
in
the
specification
and
generates
a
random
result.
E
This
is,
of
course,
not
a
new
idea.
There
is
a
trick
called
a
B
and
F
gen.
Everybody
who
loves
a
B
and
F
have
used
a
B
and
F
J
and
has
been
surprised
by
what
what
they
actually
specified.
Okay.
The
second
thing
the
implementation
does:
is
it
checks,
C
power
in
senses,
against
the
spec
and
I?
Think
everybody
who
writes
examples
into
RF
sees
things.
This
is
a
useful
feature
to
help.
E
The
third
thing
is
the
tool
can
actually
pretty
print
some
C
bar
into
a
diagnostic
notation,
with
comments
that
tell
you
which
part
of
the
CDA
specification
was
being
exercised
their
this
apart
is
still
somewhat
flaky,
as
Jim
can
testify,
I
think,
but
at
least
that's
the
idea
and
the
first
one
we
can
extract
C
hefty
fines
for
all
the
numbers
that
object
in
nurse
to
DD.
I
expect
that
just
we
use
this
type
link
a
bit,
but
you
can
do
lots
of
other
things.
You
could
pretty
print
CD
L
itself.
E
That
would
be
really
useful
to
have.
You
could
have
some
application,
specific
consistency,
condition
that
you
want
to
add
to
a
standard,
CD,
DL
processor.
You
could
write
tools
for
the
management
of
number
of
spaces,
so
something
like
the
same
tool.
We
have
for
a
game.
We
might
want
to
do
something
like
that
for
CD
there
and
I
want
to
support
this
ecosystem
by
defining
a
JSON
format
for
CD
DL,
which
of
course,
is
maybe
a
contradicting
what
I'm
always
saying
you
shouldn't
use,
JSON
to
define
jason.
E
E
But
still
has
to
be
done
on
the
technical
side,
we
have
had
these
discussions
about
the
Nurik
system
in
CDL.
There
were
some
clarifications,
but
maybe
the
clarifications
are
not
enough.
So
there
were
some
discussions
on
the
mailing
list
from
a
guy
whose
company,
whose
day
job
is
to
write
a
sand
one
tooth,
and
then
he
read
this
back
and
said:
how
do
you
handle
this
case?
And
nice
comment?
E
Series
Asian
constrains
I
talked
about
that
briefly.
We
may
actually
want
to
have
a
couple
of
serialization
constraint
as
a
separate
language,
just
switches
you
can
flip
on
it
off
and
yeah.
We
may
want
to
think
about
better
error
messages.
Everybody
who
has
tried
to
check
their
their
see
bar
examples
against
the
city.
E
A
jewel
has
experienced
the
city
iho
saying
no,
and
then
you
change
something
and
says
no
and
that's
it
would
be
nice
if
we
had
a
way
to
get
better
honest,
honest
and
maybe
the
spec
writer
has
to
help
a
little
picture
on
the
editorial
side.
We
want
to
make
one
terminology
walkthrough.
We
have
noticed
some
inconsistent
use
of
terminology,
and
maybe
it
would
be
a
good
idea
to
actually
define
a
few
more
terms
why
we
do
this.
The
introductory
material
is
lacking,
so
people
always
ask
wait
a
minute.
E
D
D
As
this
CD
dl
item
with
the
current
kind
of
arrangement
of
the
spec,
that's
not
precisely
defined
it's
it's
reasonably
clear
what
it
means,
but
it
would
be
nice
if,
in
a
kind
of
a
future
version
of
the
of
the
draft,
there
were
a
very
precise
definition
of
like
where
you
go
in
the
draft
to
see
what
that
means.
So.
E
D
D
H
H
C
E
E
C
C
J
C
C
C
L
So
this
is
Hank,
so
we
have
a
set
of
preconditions
we
have
to
satisfy
in
order
to
move
to
the
question.
If
we're
going
to
standards
track,
if
I
understand
this
correctly
and
one
of
the
preconditions
is
that
we
nail
down
the
name
just
to
make
this
clear
and
if
there
are
no
objections
as
questions
on
the
jabra
I
would
think
this
is
a
precondition.
L
L
H
Yeah
Alex
email,
just
a
quick
comment:
do
you
know
the
status
of
the
document
once
it's
done?
Has
nothing
to
do
with
the
rate
of
changes.
You
know,
I,
think
that's
one
thing
is
asking
whether
it's
stable
and
unlikely
to
change
and
the
entirely
separate
decision,
whether
it's
information
or
standard
track,
I,
don't
think
they
actually
affect
each
other.
Really
it's
just
you
know.
L
H
E
Also,
users
cannot
not
to
use
those
features
okay,
so
there
are
two
more
items
on
the
Magna,
Charta
and
I
think
we
are
not
talking
about
with
one,
because
we
still
have
to
find
out
what
the
authors
actually
want.
One
to
suggest
the
other
one
is
the
array
tags
document
that
was
originally
suggested
by
Jonathan
Roche
and
so
I
just
helped
him
a
little
bit
in
making
this
turning
this
into
a
internet
draft
found
so
I
believe
this
is
pretty
much
cooked.
E
E
Typed
arrays
should
be
known
to
anyone
who
works
with
JavaScript
all
works
with
graphics
or
both,
and
this
is
just
essentially
a
way
to
transport
typed
arrays
identified
as
such
in
a
civil
action
now
typed
arrays
come
in
a
large
number
of
variants,
so
they
have
five
different
lengths.
They
come
in
unsigned,
signed
and
and
float,
and
yes,
they
come
in
big
endian
and
little-endian,
and
this
is
the
one
way
where
I
actually
do
agree
with
the
idea
of
having
a
way
to
interchange,
something
in
little-endian
of
half.
E
So
there's
this
this
guy
from
from
NASA
who
was
talking
to
me
about
their
massive
hdf5
files
and
he
wants
to
use
SIBO
not
to
replace
hdf5.
That
would
be
stupid,
but
just
to
send
indexes
of
these
files
around.
So
these
are
way
more
complicated
data
structures.
Also
hdf5
is
not
sufficient
for
that
and
he
wants
to
use
C
bar
to
represent
these
indexes
and
and
it's
just
it
helps
if
they
don't
have
to
swap
the
bytes
for
doing
that.
E
The
the
way
this
is
encoded
in
the
form
of
C.
Both
legs,
of
course,
can
be
discussed,
and
there
are
two
innovations
here.
One
is
a
tag
for
turning
a
one-dimensional
array
into
no
one,
because
it
it's
just
a
normal
thing.
You
do
when
and
your
interchange
a
largely
dimensional
array
in
JavaScript,
you
do
a
typed
array
and
then
you
will
say:
oh
by
the
way.
This
is
not
a
nine
elements.
E
It's
a
three
by
three
element
array,
and
this
is
what
this
tankers
and
finally,
there
is
a
tag
that
I
declared
an
array
as
homogeneous,
which
is
a
little
bit
unrelated
to
the
other,
because
it's
not
about
typed
arrays,
which
are
always
homogeneous,
but
it's
about
normal
C
bar
arrays
and
it
sometimes
can
help
an
implementation
terminal.
This
is
going
to
be
all
integers.
This
is
going
to
be
all
floats,
so
this
is
so
taking
a
content.
F
Comment
from
Joe
way
too
many
tags,
he
thinks
he
should
have
one
tag
with
an
array.
Tight
actual
array
should
work.
Fine,
so
I
think
he
wants
to
have
a
tag
and
then
something
some
some
sub
part
of
it
and
Shawn
Leonard
says
when
I
reviewed
this
originally
proposed
last
year,
I
was
ok
with
the
quantity
of
tags,
but
it
posed
them
being
the
two
byte
space
in
the
four
byte
space,
no
big
deal,
but
so,
let's.
E
E
E
However,
sometimes
arrays
are
pretty
short
and
one
of
the
applications
that
people
have
rubbed
under
my
nose.
A
lot
is
having
an
RGB
color
and
an
RGB.
Color
is
three
bytes
and
it
would
be
nice
if
it
was
possible
to
attack
this
RGB
color
and
have
the
whole
thing
still
be
of
a
reasonable
size.
So
the
fact
that
the
arrays
can
be
huge
doesn't
mean
they
have
to
be.
F
E
F
C
E
J
C
C
F
E
Okay,
so
the
next
couple
of
slides
are
all
about
tag:
definitions
that
have
cropped
up
in
various
environments.
Our
Charter
tells
us
we
should
be
working
on
two
tag
documents,
one
is
the
array
tags
and
one
is
the
the
object,
ID
tags
document
where
I
said
we,
the
offers
still
have
to
fight
that
one
out,
but
sure,
of
course,
other
people
are
asking
for
tags,
and
maybe
this
is
the
control
part
here,
where
we
just
go
through
these
tags
and
and
quickly
see
our
people
interested
in
in
working
on
this.
E
This
is
for
tag
one
where
we
have
a
POSIX
time
and
we
haven't
really
provided
a
way
to
do
a
POSIX
time
to
a
decimal
fraction
or
to
a
precision
that
is
better
than
about
a
millisecond
and,
of
course,
people
need
better
time,
and
we
also
haven't
done
all
the
other
things
you
want
to
do
about
time,
and-
and
you
know,
we
have
working
groups
working
on
time.
So
it's
a
difficult
thing.
E
The
posix
scale
is
non
linear
and
nonlinear
is
an
FML
from
any
control
application.
So
you
need
monotonic
time
scales
there.
So
this
is
not
all
done
in
in
this
document.
At
this
point
in
time,
one
discussion
we
had
was:
can
we
expand
the
existing
tags,
but
we
quickly
gave
up
on
that.
We
don't
really
want
to
be
shackled
by
what's
in
the
document
right
now,
so
we
defined
a
new
tag
and
we
actually
have
an
allocation
here,
because
0
is
so
allocation
friendly.
E
We
just
went
to
IANA,
hey,
give
us
an
F
CFS
tag
and
we
got
one.
So
1001
is
now
a
tag
4/4
time
and
while
we're
at
it,
we
just
got
1000
true
for
duration
and
1003
for
period
you've
filled
in
the
details,
but
what
yell?
Ok,
ok,
so
the
idea
is
to
define
these
things
as
maps
with
member
keys
and
the
numbers
of
those
keys
are
either
positive
or
they
na
negative.
The
negative
numbers
are
kind
of
additional
information
at
the
positive
ones
define
the
time.
E
So
we
have
one
for
a
POSIX
time
like
in
tag
one
for
four
decimal
fraction
and
five
for
a
big
float.
So
we
can
solve
all
the
resolution
problems
that
anyone
might
have,
but
we
also
have
specific
additions
in
the
oops.
This
should
be
millisecond,
microsecond,
nanosecond
and
so
on.
So
you
can
have
millisecond
additions,
microseconds
and
so
on.
So
this
this
is
in
the
current
document.
E
E
E
Second
thing:
the
AP
when
working
group
is
defining
compression
mechanisms
for
doing
internet
things
in
milli,
bit
kind
of
environment
where
you
have
about
a
million
per
second
of
sustained
throughput,
and
so
they
are
really
interested
in
compression,
and
one
thing
that
is
useful
is
to
define
something
like
a
template
statically.
So
you
have
a
data
structure
and
you
define
a
template
and
then,
when
you
actually
transmit
things,
you
only
transmit
the
variables
in
the
data
structure
and
then
the
decompressor
puts
this
all
together
again
in
a
way
that
can
be
processed
by
the
application.
E
So
it's
extremely
simple.
This
is
just
tag
for
the
to
is
this:
it
has
to
be
allocated,
it
hasn't
been
allocated
yet,
but
yeah,
it's
probably
a
good
idea,
because
these
templates
have
to
be
interchanged
on
the
same
milli
bit
links,
but,
but
only
initially,
it's
probably
a
good
idea
to
have
something
chart
here,
but
now
we
are
in
the
too
bad
space
again
I
think
we
have
had
this
discussion,
so
this
is
for
LP
we're
not
LW
pen.
That
would
be
also
an
interesting
work.
Item.
E
Yeah
I
think
that's
something
we
can
keep
an
eye
on
something
in
the
w3c
work
about
thing
descriptions.
A
question
came
up:
how
do
you
represent
these
things,
ascriptions
between
nodes
and
right
now?
These
are
Jason
Jason
ad
documents,
not
it's
an
LD
documents
was
late
yesterday
evening
and
these
have
lots
of
shared
structure.
E
Normally
RDF,
no
humans,
don't
have
lots
of
shared
structure
because
RDF
is
defined.
That
way,
but
Jason
Lee
idea
is
a
kind
of
flattened
out
RDF,
so
you
have
lots
of
repetitions
and
when
you
actually
interchange
these
things
and
you
compress
them-
you
compress
them
down
by
a
factor
of
five
or
so
so.
The
question
is:
if
we
want
to
interchange
these
things
that
have
shared
structure,
repeated
Springs
and
a
lot
of
Springs
with
mostly
the
same
prefixes,
is
there
maybe
a
good
way
to
do
that
in
Zeebo?
E
And
of
course,
one
way
is
to
run
conventional
data
compression
algorithm
like
deflate?
We
have
this
convenient
RFC
1951
that
everybody
has
implemented
everywhere,
so
we
might
just
use
it,
and
it's
actually
very
successful
in
reducing
the
size
of
thing
descriptions,
but
it
requires
the
receiver
to
actually
decompress
everything
before
they
can
process
it.
E
Okay,
we
take
the
original
data
structure,
but
everything
in
here
that
is
actually
used
more
than
once
is
moved
over
into
a
shared
pool,
which
is
just
an
array
of
of
centuries
and
the
data
point
to
this
array
using
some
some
new
pointer
structures
that
we're
try
and
common
string
prefixes,
which
occur
a
lot
with
you
is
those
get
their
own
pool
and
also
can
be
referenced.
But
those
references,
of
course
have
have
the
suffix
in
depth,
so
they
they
are
not
clean
references
that
they
also
have
a
suffix
in
them.
E
So
I
implemented
this
in
two
hundred
five
lines
of
code,
just
to
see
whether
it's
it's
hard
to
do
it.
No,
it's
not
hot,
and
now
the
question
is:
how
do
we
actually
represent
these
shared
references
and
these
prefix
references
in
Siebel?
And
now
this
is
probably
the
most
ruthless
proposal
for
for
spending
INR
code
points.
Let's
see
how
well
that
is,
get
accepted.
E
E
There's
lots
of
white
space
in
there.
So
this
is
not
not
a
reasonable
number.
So
if
you
take
out
the
white
space,
this
is
Jason
fry
with
1447
writes
and
you
can
see
deflate
really
lets
the
air
out
of
those
and
even
cheap
algorithms,
like
a
jet,
for
which
is
something
that
you
might
want
to
do
a
mile
on
a
microcontroller.
E
Actually,
you
still
give
you
a
pretty
good
compress
compression.
So
this
is
a
little
bit
the
benchmark
here
and
C
bar
represents
the
same.
Exactly
the
same
data
in
1210.
Bytes
deflate
actually
is
slightly
less
efficient
here,
because
the
the
Jason
stuff
really
has
a
lot
of
redundancy
that
you
can
work
on
and
the
pepped
mechanism,
using
only
semantic
sharing,
uses
793
bytes,
which
is
not
so
good,
but
with
the
prefix
compaction,
we
go
down
to
564.
E
So
that's
getting
close.
It
still
twice
as
much
as
ascending
the
deflate
version,
but
then
you
can
work
on
it.
You
don't
have
to
decompress
it
to
work
it.
So
it
looks
like
this
is
an
approach
tool
for
maintain
processability
prefix
sharing
is
good
for
working
with
urls
and
well.
I
still
have
to
fix
my
implementation
to
actually
find
all
redundancy
cases
so
that
there
are
still
a
little
bit.
E
So
the
one
thing
that
that
w3
is
probably
going
to
add
is
a
static
dictionary.
So
a
number
of
the
strings
that
are
in
here
are
going
to
be
everywhere.
So
a
Jason
ad
document
talking
about
media
types
is
going
to
have
the
spring
application
Jason
in
it.
So
you
might
as
well
put
that
into
a
static
dictionary
that
is
on
all
devices
and
bench
don't
even
have
to
represent
it,
because
the
implementation
will
know
that
thing
is
application
chase.
F
F
E
Way
Joe
did
it
requires
that
you
actually
do
the
decompression
wire
sequentially
scanning
document.
Why
this
mechanism
here
actually
can
be
used
incremental,
II,
so
yeah,
it's
it's
slightly
different.
Maybe
he
hasn't
read
the
document
yet
yeah.
So
if
the
objective
is
to
save
tag
space,
this
is
a
real
bad
proposal.
If
the
objective
is
to
represent
data
in
an
efficient
way,
this
is
a
pretty
reasonable.
E
C
C
So
I
think
he's
just
writing
in
jabbering
steps
right.
We
do
what
he
writes.
Just
a
reminder
to
the
working
group
that
there
is
a
charter
working
group
document,
the
wood
draft
form
and
support
acts
join
0-6
for
the
auto
ID
tags
and
other
identifiers,
as
well
as
other
topics.
Please,
sir.
You
the
work,
and
it
also
includes
content
about
fixing
or
better
specifying
certain
tags.