►
From YouTube: GitHub Quick Reviews
Description
Powered by Restream https://restream.io/
B
Okay,
thank
you
more
so
I'm,
just
gonna
start
by
sort
of
giving
an
introduction
of
what
sea
bore
actually
is
so
sea
bore,
which
is
like
an
acronym
standing
for
concise,
binary
object.
Representation
is
a
binary
data
format
loosely
based
on
Jason,
which
emphasizes
small
message:
sizes,
implementation,
simplicity
and
extensibility
without
the
need
for
version
negotiation,
and
basically
this
proposal
is
to
provide
a
generalizable
reader
and
writer
as
a
public
API
which
will
live
under
the
system,
both
formats
dot,
C,
borer
namespace.
B
So
basically
a
few
words
about
the
actual
format
itself.
The
format
defines
a
data
model
that
largely
derives
from
Jason
and
slightly
extends
it
a
so
introducing
terminology
here.
A
data
item
consists
of
a
single
piece
of
seaboard
data.
The
structure.
The
structure
of
a
data
item
may
contain
zero
one
or
more
nested
data
items,
and
each
data
item
can
be
any
one
of
eight
distinct
major
types.
Again,
that's
terminology
used
by
the
spec
itself,
so
I'm
just
gonna
enumerate
the
major
types
for
the
benefit
of
the
audience.
B
Prefix
major
type
5
is
map
containing
purrs
of
their
items,
essentially
adjacent
object.
The
main
difference
from
the
adjacent
object
is
that
actually
keys
in
seaboard
can
be
of
any
major
type.
You
know
just
string
which
leads
into
some
interesting
api's.
In
this
proposal,
major
type
six
basically
defines
a
semantic
tab
tag
that
can
wrap
any
nest.
B
You
know
basic
floating-point
numbers
which
can
be
half
single
or
double
precision,
or
they
can
be
any
one
of
bite-sized,
simple
values
that
require
no
additional
content,
such
as
false,
true
and
now,
and
these
can
be
extended
via
a
simple
value
registry,
as
defined
in
the
spec.
Are
there
any
questions
so
far.
B
Yeah
so
I
have
some
notes
on
the
on
the
motivation
for
including
this.
The
primary
motivation
is
that
we
need
to
implement
the
C
tap
protocol.
C
tab
stands
for
client
to
Authenticator
protocol,
which
is
part
of
the
phyto
Alliance,
and
we
need
this
for
it's
been
at
core.
Apparently
that's
sort
of
our
only
use
case
for
now.
Yes,.
C
It's
it's
for
me,
email!
So
those
little
you
bikinis
that
you
have
that!
Allow
you
to
Hardware
off
to
github
to
your
own,
a
ad
in
the
like
they
are
using
C
bore.
Well,
the
browser
uses
C
bar
underneath
to
provide
structures
to
sign
and
validate
and
send
to
the
backend.
So
it's
for
the
phyto
to
support
that
we
want
to
put
into
asp.net
yep.
D
B
E
B
B
B
Only
generally,
the
spec
also
defines
a
diagnostic
notation,
which
basically
lets
you
render
see,
bore
values
using
a
Jason
like
syntax,
so
I've
included
an
example
here
in
the
design
dog.
So
this
basically
defines
a
seaboard
map
and
it
sort
of
showcases
a
key
containing
an
integer
value,
hex,
encoded,
byte
string,
nested
array
containing
null
and
boolean
values.
B
Key
four
in
particular,
is
sort
of
an
integer
value
containing
a
semantic
tag
and
that's
actually
representing
a
unix
time.
And
finally,
the
final
key
basically
demonstrates
that
keys
can
actually
be
of
arbitrary
type.
In
this
case,
the
key
is
a
seaboard
array
and,
as
mentioned
earlier,
like
seaboard
is
the
messaging
format
used
by
Fido
and
the
seat
up
to
protocol,
and
you
know
we
need
this
for
a
spinet
core.
B
Another
thing
is
that
RFC
70
49,
which
is
basically
just
a
simple
spec
I'm
using
this
lumber
quite
a
lot.
It
defines
three
basic
levels
over
encoding,
conformance
so
well
for
business,
which
basically
guarantees
that
the
document
is
in
fact
a
well-formed,
a
document,
that's
kind
of
a
circular
definition,
but
it
means
that
you
know
it's
syntactic,
it
syntactically
sound.
If
that's
the
right
terminology,
then
you
have
a
strict
mode
which
adds
a
few
additional
constraints.
For
example,
you
know,
Maps
cannot
have
duplicate
keys
and
you
know
any
utf-8
string
must
actually
be.
B
You
know,
well-defined
utf-8
string,
and
then
you
have
canonical
seaboard,
which
adds
additional
constraints.
On
top
of
that,
for
example,
that
you
know,
keys
in
a
map
must
be
sorted
in
a
particular
way,
plus
certain
other
canonic
ality
conditions,
and
obviously,
if
you're
interested
you
can
click
on
the
links
and
see
for
yourselves.
But
what's
more,
the
seat
up
to
spec
defines
its
own
set
of
canonical
Sieber
encoding
rules,
which
are
very
similar
to
canonical
C
bar
in
the
Seaboard
spec.
B
However,
it
contains
you
know
slight
differences,
for
example,
in
the
sorting
semantics
for
keys,
etc,
etc.
So
the
proposed
implementation
here
would
be
to
add
all
four
of
those
conformance
levels
to
both
the
reader
and
the
writer,
so
that
kind
of
concludes
sort
of
the
introduction
to
what
C
bar
is
and
what
we
need
to
implement.
Moving
on
to
the
you
know
certain
basic
examples
that
demonstrate
how
the
proposed
API
will
be
used
now.
B
But
if
I
wanted
to
actually
see
relies
this
in
in
the
Seaboard
format,
using
the
proposed
API
here
is
a
method
called
create
easy
to
Kowski
encoding
that
accepts
you
know
basic
set
of
parameters
and
performs
the
serialization
for
you.
So
you
know
in
the
third
line
it
initializes
a
new
SIBO
writer
instance
with
the
seat
up
to
canonical
conformance
level
passed
into
it,
and
then
you
know
in
the
line
after
that
it
pushes
a
definite
length
map
context
with
length
five.
B
B
So
you
know
you
see
that
the
keys
are
actually
written
using
the
write
in
32
method
and
finally,
the
the
public
key
point
is
written
using
the
byte
string
method
and
finally,
once
all
the
data
is
written,
we're
popping
the
math
context
and
returning
the
encoded
by
tray
in
zero
form.
So
that
should
be
pretty
straightforward.
Unless
there
are
any
questions
about
that.
A
B
B
A
B
Mean
for
their
conformance
levels-
yes
yeah,
so
that
is
actually
specified
in
the
third
line
like
in
the
first
line
and
the
method
body
where
the
conformance
level
is
passed,
using
the
Seaboard
conformance
level
enumeration.
So
so
that
means
a
couple
of
things.
First
of
all,
the
writer
will
ensure
that
the
conformance
is
observed
and
in
cases
where
it
cannot-
and
it
kind
of
do
this,
for
example,
because
a
user
pushes
a
duplicate
key,
then
it
will
throw
an
invalid
operation
exception.
F
So
I
kind
of
shut
in
here
and
I'm,
seeing
to
your
rights
right,
start
mop
and
the
right
hand.
Well,
my
question
is
kind
of
this
kind
of
implies
the
scope
for
writing
them
up,
which
kind
of
feels
like
there
should
be
kind
of
some
abstraction
to
kind
of
make
it
easier
for
users
to
to
kind
of
not
forget
about
the
end.
Other
things
I'm
just
kind
of
curious.
If
you
consider.
B
I'm
not
sure
I
follow
about
the
exceptions
so
I
if
I
understand
your
proposal
correctly.
Is
that
basically
right
start
map
should
return
some
kind
of
y
disposable
token
that
I
could
bind
to
a
using
declaration
so
that
it
would
pop
them
up
context
automatically
as
soon
as
the
method
leaves
the
scope
is
that
correct.
B
And
I
I
thought
about
it
and
the
reason
why
I
didn't
implement
that
is
because
an
I
disposable
will
be
executed,
regardless
of
whether
the
operation
was
successful
or
whether
it
through
an
exception,
because
I
only
would
expect
this
to
be
done
in
the
Hobby
path.
I
kind
of
feel
that
you
know
I
disposable
is
not
the
right
abstraction
before
this
kind
of
use
case.
A
Mean
much
they
made
the
decision
and
I
would
almost
say
that
probably
didn't
consider
that,
because
there's
I
disposable
for
you
know:
pairing
operations
is
kind
of
a
philosophy
or
against
a
pattern
that
has
evolved
I.
Think
after
the
v1
API
is
worshipped
but
I
grieve
of
Eric's
reasoning
like
I
mean
I,
understand
the
syntactic
appeal
of
it
but
like.
A
B
D
Conversely,
I
did
at
it
for
a
SN
reader
and
it
it
it
does
clean
up
this.
It
does
make
the
code
easier
to
read
when
you
end
up
with
a
lot
of
the
small
scopes,
but
I
can
agree
that
things
like
the
fact
that
the
meaning
of
write
in
32
changes
from
key
to
value,
depending
on
the
number
of
times,
you've
called
it,
and
that
some
things
are
not
value
valid,
as
keys
means.
You
probably
do
have
more
failure
states
here
that
are
useful
to
share,
but
we
can
talk
about
that
when
we
get
right.
A
B
So,
okay,
so
here
I
have
a
very
basic
example
that
illustrates
how
a
Sieber
map
can
be
read-
and
you
know,
for
you
know,
simplicity
reasons,
I'm,
just
going
to
assume
that
all
keys
and
values
must
be
test
text
strings.
So
here,
I
have
a
method.
Called
keyboard
read,
see
board
X
map
which
accepts
an
encoding
and
returns
a
dictionary
that
you
know
obviously
just
contains
their
key
value
pairs.
B
Where
so,
the
the
nullable
result?
Basically,
if
it's
populated
it
denotes
the
fact
that
the
map
is
actually
definite
length
or
prefix,
if
you
prefer
and
if
it
is
no,
it
likewise
determines
that
the
map
is
indefinite
length
and
therefore
I
would
have
to
traverse
through
the
entire
map
before
I
know
what
its
actual
actual
sizes.
So
here
I
have
basic
piece
of
code
that
handles
both
cases
just
for
illustrating
how
it
works.
A
A
B
H
A
A
C
Expose
it
like
this
at
all,
it'll
just
be
it'll,
just
be
me
using
it,
and
yet
it
will
be
a
pmbus
p.m.
code
sample
to
begin
with,
which
should
horrify
absolutely
everybody.
So
it's
me
that
has
to
use
it
because
we're
we're
not
entirely
sure
how
this
is
gonna
work
with
the
the
web
stuff.
Yet
it's
really
hard
for
me
to
say
if
this
is
usable
or
not,
and
of
course,
my
view
of
usability
is
mollified
by
the
fact
that
I
can
basically
demand
that
Jeremy
helps
so
yeah.
C
It's
like
the
easier
time
of
it
than
anyone
else.
Would
that
would
want
to
use
it
raw,
but
it
looks
fine
I
mean
my
my
scenario
really
here
is
I
want
to
get
a
bunch
of
signing
keys,
I
have
the
encoded
stuff.
So
if
I
just
get
decoded
thing
and
say
I
want
that
that
value
right
over
there,
that's
all
I,
really
care
about,
and.
B
So
go
so
first
of
all
provide
a
stateful
forward,
only
reader
class
that
can
read
Seaborn
coded
data
and
you
only
do
the
same
thing
for
writing.
C
Borinquen,
coded
data
yeah
I,
stated
before
both
reader
and
writer
must
support.
The
following
conformance
rule
sets
so
basic
well
for
madness,
which
will
be
calling
lacks
conformance
RFC,
70,
49,
RSC
70
49
is
just
the
Seaboard
spec,
so
strict
mode,
canonical
mode
and
seat
up
to
can
Wan
Kenobi.
B
So
these
for
the
reader
should
allow
schema
agnostic
scenario,
which
is
pertinent
to
you,
know,
email,
your
question
from
before
it
should
support,
reading
and
writing
indefinite
length,
their
items
and
optionally.
The
writer
should
allow
on-the-fly
conversion
of
indefinite
length
and
cones
into
definite
length
equivalents.
Basically
that
means
that
if
you
have
opted
into
this
behavior,
the
writer
will
also
convert
the
encoding
in
your
buffer
once
you've
finished.
Writing
your
indefinite
length
array
or
map
or
string.
B
B
The
reader
should
have
support
for
skipping
any
data
item
which
would
include
its
nested
data
items
as
well
and
just
discarding
the
result,
and
that
should
basically
provide
a
workaround
for
advancing
through
non-conforming
sections
of
the
encoding.
If
that
makes
sense,
so
the
the
scenario
is
that
you
know
you're
reading
through
a
piece
of
C
bore
and
suddenly
you
come
across
a
map
in
which
you
know
the
keys
are
not
sorted
or
something
so.
B
B
Okay,
so
I'm
just
gonna
move
to
the
things
that
we
don't
want
to
do
so
we
don't
want
to
add
support
for
automatically
sterilizing
or
this
realizing
between
C
board
data
and
donut
types.
It's
just
gonna
be
the
basic
writer
and
the
basic
reader.
There
will
not
be
a
C
or
document
each
type
that
would
be
used
to
represent.
You
know
the
Seaboard
data
model.
B
And
the
reason
like
I
would
like
to
see
system
iostream
being
added
eventually,
but
many
of
the
features
that
we
added,
for
example,
even
the
fixing
up
of
indefinite
length
fact
and
coatings.
You
know
necessitate
that
you
have
the
entire
buffering
memory
and
you
can
be
able.
You
should
be
able
to
modify
it
at
any
point
in
time.
So
we
just
dropped
this.
D
Mean
similarly
so
we
I
mean
with
asn.1
it's.
It
always
has
to
do
the
backwards
rights,
because
essentially
the
model
that
we
added
here
for
letting
you
write
an
indefinite
array
and
then
we
turn
it
into
a
definite
array
for
you
after
the
fact
is
the
way
everything
has
to
work
in
the
SN
writer,
because
while
this
model
uses
the
count
of
items,
the
SN
right
or
the
ASN
data
models
use
the
count
of
bytes.
So
you
you
seriously
didn't
know
that
until
you
were
done,
writing
everything
down.
D
So
since
the
writer
doesn't
support
streams,
the
reader
doesn't
support
streams
and
certainly
support
for
those
things
could
be
added.
On
top.
Someone
could
write
a
stream
thing
on
top,
but
they
would
lose
some
of
the
functionality
or
depend
on
fully
c
Keable
streams.
But
it's
weird
to
talk
about
doing
an
inserting
a
byte
in
the
middle
of
a
c
Keable
stream
or
require
a
lot
of
out-of-band
buffering
right.
A
You
mean
to
me
it
seems
not
deal-breaker
like
I.
Don't
even
think
it's
that
controversial
like
it
depends
on
how
big
the
payloads
are
right.
If,
if
you
expect
to
process
a
see,
boring
document
that
is
4
gigabytes
in
size,
then
not
having
a
stream
is
kind
of
a
problem.
But
if
everything
is
effectively
on
the
order
of
a
few
pages,
then
I
don't
think
it
matters.
B
A
D
D
Think
if
we
were
to
add
stream
support
for
either
of
the
let's
call
it
two
formats
libraries,
it
would
end
up
being
types
that
wrap
the
the
ones
that
work
on
buffers
so
that
it
can
drop
out
the
functionality
that
won't
work
instead
of
having
these
methods
throw
an
invalid
operation
exception.
If
I'm
sorry
use
the
stream
constructor
I'm
not
allowed
to
do
that
or
I'm.
Sorry,
you
gave
me
a
non-si
cable
stream.
I
can
only
do
forward
writing
and.
D
D
B
Okay,
so
so,
as
you
can
imagine,
there
are
two
pillars
in
the
design:
stateful
reference
type
writer,
imaginative
link
called
co-writer.
It
allocates
its
own
expandable
right
buffer.
The
writing
is
basically
done
via
a
suit
of
right
bracket
type
methods
for
common
types.
You
know,
in
the
shape
that
you
would
have
would
have
expected
from
other
you
know,
writer
classes
and
for
composite
constructs
like
arrays
maps,
etc.
The
general
convention
followed,
is
right,
start
type
and
right
end
type.
B
Likewise,
stateful
reference
type
reader
called
SIBO
reader,
it
decodes
a
user
provided
buffer.
It
exposes
again
a
suite
of
read
type
methods
for
common
types,
and
you
know
equally
read,
start
and
read
end
that
should
have
set
type
by
the
way
it
says
read
and
map
for
composite
constructs,
and
you
know,
another
key
feature
is
the
peak
state
method
which
is
used
to
determine
the
next
day
right
and
then
the
buffer
without
advancing
the
reader
state.
So
the
this
is
basically
the
design
of
being
proposed
API.
B
So,
let's
start
with
API
that's
common
to
both
the
reader
and
the
writer.
First
of
all,
we
have
the
C
word
conformance
level
enum,
which,
as
mentioned
before,
defines
the
for
supported
conformance
levels,
but
we
have
lakhs,
which
is
just
basically
validates
that
the
support
data
is
well-formed
as
specified
in
the
spec.
That
is
also
the
default
conformance
level.
So
whenever
you
don't
pass
any
arguments
in
either
the
reader
or
the
writer
pertaining
to
conformance,
that
will
be
the
default.
A
B
C
D
Mean
Eric
in
the
in
the
spec.
Did
it
really
call
that
out
as
sort
of
a
thing
I
know,
XML
does
talk
about,
lacks
versus
strict
reading
I
feel
when
I
read
the
spec,
it
talked
about
the
the
data
language
or
the
data
model
and
then
said,
and
then
there
are
two
restrictions
ones
called
strict
and
ones
called
canonical.
So
it
kind
of
didn't
really
talk
about
the
default
state.
Correct.
B
Yeah,
that's
that's
actually
a
good
point.
It
is
using
the
term
well-formed,
for
you
know
valid
Seabourn
coatings,
but
it
doesn't
define
as
such,
a
conformance
level
called
lacks.
So
maybe
maybe
that
might
have
been
the
initial
motivation
for
this.
But
well-formed
is
the
the
appropriate
term.
I
mean.
B
Well,
there
like
there
might
be
another
point
to
add
here
actually
well
form,
is
even
weaker
than
the
minimum
conformance
level
offered
by
our
implementation,
and
the
reason
is
just
because
we
want
to
be
stricter
than
what
you
know.
The
spec
allows
in
certain
cases
like,
for
example,
you
know
where
lakhs
might
actually
necessitate.
You
know
replacing
invalid
formats
with
the
undefined
tag,
or
you
know
not
throwing
errors
whenever
something
or
something
else
is
and
cow
encountered.
So
we've
kind
of
taken
the
informed
choice
to
make
it
slightly
stricter.
G
B
Yeah
I
I
was
kind
of
thinking
about
making
strict
the
default.
Although
I
wanted
to
defer
this
conversation
until
this
API
review,
what
may
be
the
discussion
about
default
should
be
made
in
the
Constructors
rather
than
in
the
definition
of
the
enum
I.
Don't
know
what
the
best
approach
would
be
here,
but
I
I
think
strict
might
have
been
a
good
choice
for
a
default.
D
I
mean
essentially
this:
it
does
I
mean
there's
a
question
of.
Does
the
reader
like?
If,
if
we
say
that
the
reader
is
reading
strict,
then
it
seems
that
the
reader
does
have
the
responsibility
instead
of
the
caller,
to
say
that
there
were
no
duplicate
items,
which
is
a
requirement
of
strict
and
it
is
it
strict
or
canonical
that
says,
integers
have
to
be
included
using
the
smallest
form.
They
can
you
it's.
D
So
strict
yeah,
like
essentially
lacs,
is
you
know
just
right
or
for
the
reader
lacks,
is,
if
you
just
went
through
item
by
item
and
just
wrote
a
method
that
says
I
can
read
using
like
this,
like
I
can
read,
you
know,
2.6
and
I
have
implemented
2.6
we're
good
to
go.
Strict
is
higher
level
stuff
and
for
the
the
current
we
put
a
little
bit
more
power
or
we
can
remove
some
checks
and
let
someone
get
performant
code
where
they
assume
correctness
lacks,
is
don't
do
the
redundant
checks.
Just
read
the
data
I
mean.
B
C
D
G
C
C
C
You
know
what,
but
you
know
if
it
is
a
performance
optimization,
then
it
should
probably
stay
there
for
people
that
already
know
that
their
validation
has
been
done.
So,
for
example,
you
have
a
couple
of
internal
API.
Is
you
know
that
the
caller
is
doing
the
right
thing?
I
could
see
a
use
for
it.
I.
A
G
D
B
D
G
D
Picking
something
as
the
zero
other
than
we
don't
have
conformance
here
is
weird,
so,
no
matter
what
it
has
to
be
in
the
I
feel
like
it
has
to
be
in
the
enum,
no
matter
what
right,
whether
we
call
it
lacks,
or
none
or
well-formed
or
well-formed
only
or
whatever.
We
could
have
a
different
argument,
which
is
that
neither
the
reader
nor
the
writer
accepts
that
value
in
their
constructors,
but
I
I
do
think
it
would
be
weird
to
say
that
defaults
of
conformance
level
is
strict.
Yeah.
A
D
I
mean
the
enum
is
not
ordered
like
I
at
least
I
feel
like
it's
not
I,
don't
think
see.
Tap
too
is
a
restriction
of
canonical
canonical
is
a
restriction
of
strict
and
see
tap
to
canonical
is
a
restriction
of
strict
but
they're?
Not
you
can't
say
one
is
more
restrictive
than
the
other
they're
differently.
Restricting
at
that
point,
yep.
B
That's
actually
brings
in
another
issue
that
conversation
we
were
having
with
Jeremy
whether
you
know
canonical
needs
to
be
further
disambiguated,
because
you
know
you
have
seat
up
to
canonical
and
just
canonical
there
was
initially
that
was
actually
called
RFC
70
49
canonical,
which
I
removed,
but
I
thought
I'd
bring.
This
up
here,
I
mean.
A
I
F
B
D
C
D
D
If
we
had
written
this
just
based
off
RFC
749,
we
would
have
called
them
zero,
strict
and
canonical,
and
everyone
would
have
thought
those
were
perfect
names
and
then
we
would
add,
support
for
C
tab
to
canonical,
and
so
this
is
what
it
would
look
like
if
it
was
an
evolved
API
instead
of
a
brand
new
API.
Now,
maybe
this
means
we
we
get
better
foresight
because
we're
actually
doing
them
at
the
same
time,
but
I
mean.
F
Enums
can
allow
us
to
use
the
same
and
the
different
name
for
the
same
values.
So,
technically
speaking,
we
could
just
add
another
canonical
like
IFC
canonical
later
and
just
make
the
economic
coming.
The
tariffs
you
like
later
magically
so
just
documented.
This
is
the
same
as
the
other
thing,
so
it's
more
explicit
like
if
you
actually
end
up
in
this
situation,.
G
A
A
D
A
Yeah
I,
don't
know,
like
I
mean
generally
speaking,
I
think
like
we
tried
to
make
things
approachable
and
like
what
we
know
from
usability
studies
is
that
simple
names
will
always
be
preferred.
People
say
that
one
clarity,
but
very
often,
when
you
have
the
choice
between
simple
words
and
more
complicated
words,
people
assume
the
simpler
words
or
what
they
want,
and
so,
if
you
expect
more
people
to
use
canonical,
then
name
a
canonical
makes
sense.
A
C
A
A
See
alright,
then
I
guess
let's
go
over
canonical
for
now
and
then,
unless
somebody
else
feels
super
strong
I
mean
give
me
the
number
of
people
that
will
use
this
API
is
literally
on
this
call
like
I
it's
just
from
a
from
a
general
principle.
Standpoint
like
we
try
to
have
simpler
names
if
we
can
make
that
happen,
but
it's
not
the
only
goal
we
have.
Sometimes
clarity
is
more
important,
so.
D
D
C
B
More
tech
support
tag,
so
this
genome
basically
just
represents
the
Seaboard
semantic
tags
which
are
unsigned
64-bit
integers.
This
enum
essentially
defines
a
list
of
all
the
tags,
as
defined
in
the
spec
and
using
the
wording
used
in
the
spec
as
well.
That
should
probably
reduce
the
controversy
here
now.
Do
keep
in
mind
that
the
tag
registry
for
Seaboard
is
extensible
and
we
would
expect
people
to
typically
assign
new
values
within
the
Siebel
tag
space,
but
this
defines
everything
that
exists
in
the
Seaboard
spec.
B
If,
for
what
it's
worth,
we
only
really
use
the
first
six
tags
for
any
semantic
tag,
serialization
and
deserialization.
Here
everything
else
is
just
added
for
completeness
so
date,
time
string,
unix
time
seconds
and
sign
big
nub,
big
naam,
negative,
big
naam
and
decimal
fraction,
so
the
first
five,
rather
the
decimal
fraction
are
all
used
for
types
that
we
write
and
read
emo.
Would
you
like
me
to
enumerate
the
all
the
other
tags
I.
I
B
B
So
that's
a
byte
buffer,
but
it's
meant
to
be
transferred
it
into
an
ASCII
string.
So
the
idea
is
that
you
are
able
to
make
a
full
back
and
forth
from
Jason
to
see
bore
so
basically
base64
encoding
czar
meant
to
be
so
it's
basically
a
byte
buffer,
but
it
includes
this
tab
for
transcoders
to
you
know
make
the
association
that
hey.
This
is
basically
for
string.
Okay
and
these.
D
Are
actually
I
was
gonna,
say
it's
it's
it's
a
suggestion
in
the
spec
they're
called
content
hints,
and
so
all
that
all
that
base64
URL
later
encoding
really
means
is
that
it's
the
number
21
and
it's
up
to
somebody
else
to
interpret
the
payload
that
it's
wrapping.
The
of
course
recommended
thing
for
it
to
be.
D
Wrapping
would
be
a
byte
array,
but
that
would
be
if
we
had
API
that
read
it,
then
it
would
throw
of
like
the
payload
made
no
sense,
but
if
somebody's
doing
it
manually
they'll
have
don't,
you
know
have
to
deal
with
the
fact
that
the
tag
carries
with
it.
No
semantic
reinterpretation
of
the
of
the
thing.
It's
just
a
a
comment.
Basically.
B
B
A
D
But
we
could
also
like
sure,
like
we're
doing
with
the
TLS
cipher
suites
like
periodically
go
through
the
IANA
registry
and
just
import
all
the
values
we
don't
have
and
be
like
yep
as
part
of
the.net
six
package.
We
added
the
six
new
tags
that
have
been
registered
in
the
last
year
and
yeah
yeah.
We
don't
know
what
they
mean,
but
we
totally
told
you
that
they,
this
is
the
name
associated
with
that
value.
For.
B
A
D
A
B
A
B
Sure
so
you
know
base64
string
later
encoding
base
16
string
later
encoding,
encoded
seaboard
data
item,
so
I
believe
that
this
denotes
a
raw
byte
string
that
is
itself
a
SIBO
encoding
again,
no
real
bearing
in
what
we're
actually
implementing
I've
just
added
this
URI,
as
defined
in
RFC
blah
blah
blah
base64
Earle
base64
Doc,
you
scroll
down.
Please
rejects
my
message
and
self-described
sea
boar,
which
is
basically
just
a
magic
value
that
you
might
optionally
want
to
put
at
the
top
of
your
support
document.
I.
A
D
A
C
D
A
D
A
G
A
C
D
D
B
A
A
D
B
B
Yeah
so
moving
on,
we
have
seaboard
simple
value,
which
is
you
know
the
one
kind
present
in
major
type.
Seven.
There
there's
also
floating-point
numbers
which
are
confusingly,
not
simple
values
and
simple
values
are
so
a
simple
value
is
a
bite-sized
value,
and
you
know
again,
the
spec
defines
four
constants
within
that
space,
false
true
null
and
undefined,
which
apparently
will
be
used
by
certain
decoders.
Whenever
there
is
a
format
error,
it
substitutes
the
bad
value
with
undefined,
which
we
don't
do,
but
I've
added
it
for
completeness.
B
D
To
go
back
to
see
Bohr
tag,
sorry
to
rewind
emo.
What
are
our
current
guidelines
for
you?
Long
for
an
enum
are
we
are
we
saying
if
this
is
shipping
herb,
it
should
be
CLS
compliant,
and
so
we
should
say
long
and
negative
numbers
are
a
callers
problem
or
or
what
we
definitely
need.
You
long,
because
it's
defined
to
be
a
64-bit
number,
we're
sorry,
the
longness!
That's
the
space
that
the
registry
is
occupying
yeah.
D
A
Mean
I
would
probably
go
with
long
like
I
have
no
idea
what
languages
that
are
known.
They
don't
so
like
I,
don't
know
what
VB
does
when
you
have
a
seaboard
tag,
for
example
like
because
I
mean
normally
that
mean
VB
doesn't
support
unsigned
data
types
I
mean
an
enormous
kind
of
behaving
differently
from
a
normal
number
type.
So
maybe
it
just
works
in
VB,
but
and
it's
a
strong
reason.
Why
needs
to
be
you
long?
I
would
probably
go
with
long
cuz
if
a
little
just.
B
B
Unsigned
unsigned
Long's
play
a
significant
part
in
both
the
super
spec
and
consequently
in
the
public
API
in
civil
writer
and
civil
reader.
So
you
know,
I
would
expect
CLS
compliance
to
be
an
issue
here,
like
also
I
would
say
that
if
we
change
this
to
long,
we
would
yeah
that
would
certainly
leave
out
certain
hypothetical
values
over
the
maximum
value.
Well,.
D
I
B
D
A
I
I
was
asking
because
there's
there's
various
specs
that
sometimes
define
these
individual
values
and
then
they'll
send
it
in
a
compressed
form,
in
which
case
you
might
have
to
shift
them
together,
in
which
case
you
don't
want
sign
types,
because
that
messes
up
your
arithmetic
a
lot
of
times.
That's.
A
I
A
That
case
yeah,
maybe
I
mean
it's
just
it
just
seems
odd.
To
like
restrict
the
negative
thing.
I
mean
I,
understand
that
you
need
to
hit
the
big
pattern.
I
might,
as
Jeremy
said,
I
mean
you
can
encode
the
number
and
whatever
form
you
want
right.
Alright,.
A
I
A
I
D
Right
I
mean
I,
do
know
that
for
comm,
assuming
that
I'm,
remembering
correctly
comm,
essentially
just
talks
about
the
number
of
bits
in
the
value,
and
so
it's
just
like
this
is
a
64
bit
number
and
SOCOM
assumes
signed,
except
for
the
8
bit,
which
is
unsigned
so
I.
That
definitely
would
come
from
like
a
middle
definition,
but
I
mean
we
certainly
don't
care
about
comment
or
up
here.
Yeah.
A
D
A
B
B
A
A
B
So,
let's
start
with
a
constructor:
SIBO
writer
exposes
a
single
constructor,
accepting
three
parameters:
all
are
optional,
so
obviously
the
conformance
level
has
discussed
the
default
currently
is
lacks.
It
additionally
exposes
a
couple
other
boolean
parameters.
The
first
one
is
convert
indefinite
length
and
coatings,
which
is,
as
I
mentioned
before
this
mode,
where
the
writer
will
convert
indefinite
length,
n,
co
and
codings
into
definite
length,
equivalents
for
optimized,
reads
and
also
for
conformance
level
reasons.
B
D
A
My
question
is
also
like
because
it
seems
like
potentially
becoming
grab
bag
of
stuff.
Like
the
more
options
you
have
eventually
you're
better
off
of
just
a
dedicated
options
type,
but
if
they
only
have
three,
then
it's
fine.
Even
the
spec
is
already
done
and
you
have
implemented
the
spec.
It
doesn't
seem
like
there's
potential
for
a
lot
of
more
options,
but
I
mean.
B
A
I
mean
it's
the
trade-off
right,
I
mean
if
you,
if,
if
you
have
like
I
mean
it
doesn't
have
to
be
perfect,
but
if
you're
fairly
confident
very
unlikely
to
add
in
the
very
near
future,
more
values
to
the
constructor,
then
I
think
it's
fine
like
if
you
eventually
have
to
add
one.
That's
also
not
a
biggie,
but
we
can
breast
case.
We.
I
A
A
Also
say
it's
kind
of
like
string,
it's
kind
of
like
also.
What
do
you
expect
right?
I
mean
like
the
polymers
also
when
you
have
defaults
for
primitive
type
that
are
boolean.
It's
probably
fine.
If
you're,
if
you
ask
me
for
like
fairly
complicated
types
like
an
interface
or
some
other
stuff,
I
have
no
idea
where
it
would
get
a
value
from
then
that's
azam,
yeah.
D
And
I
guess
one
point
where
you
know
there
was
the
discussion
of
what
should
a
default
be
for
the
conformance
level.
Is
that
maybe
the
conformance
level
is
not
a
defaulted
parameter
and,
and
we
just
make
people
specify
it
as
the
last
required
parameter,
we
could
change
that
later.
We
can,
we
can
add
a
default
and
that
wouldn't
break
any
existing
code.
So
that
is
just
one
thing
to
consider.
If
we
can't
decide
on
what
the
default
should
be,
maybe
that
means
there
shouldn't
be
one
right.
D
A
B
B
D
B
Yeah,
so
so
basically
I
probably
didn't
mention
this,
but
the
Siebel
writer
will
Auto
sort
the
the
keys
as
they
are
written,
primarily
because
the
sorting
is
done
on
the
encoding
level
and
as
such,
the
user
cannot
reasonably.
You
know,
sequence
the
operations
in
our
in
a
way
that
conforms
without
being
intimately
familiar
with.
You
know
the
internals
of
Seaborg
in
the
first
place,
if
that
makes
sense,.
B
H
B
D
B
D
Right
I'll,
say
I
would
encourage
it
to
be
true
for
converting,
definitely
think
codings,
which
is
make
the
API
do
more
work,
and
then
someone
gets
to
opt
into
I.
Want
you
to
do
less
tracking
and
less
reallocation,
but
that's
me
so
I
would
go
for
friendly
defaults
and
performant
options
instead
of
the
performant
default.
A
B
And
then
we
have
three
properties
that
you
know
refer
to
the
current
state
of
the
writer,
so
you
have
byte
written
as
you
would
expect
just
returns
the
number
of
bytes
that
have
been
written
to
the
buffer.
The
current
depth
again
returns
the
level
of
method
Ness
in
the
currency,
both
document,
the
is
write,
completed,
property
basically
returns.
True.
If
the
writer
has
complete
completed
writing
of
a
you
know,
full-well
foreign
seaboard
element
or
sequence
of
well-formed
root-level
suba
suba
documents,
depending
on
the
configuration
now.
B
D
B
B
It's
you
know
just
copies
the
data
from
the
buffer
into
a
new
array
that
it
allocates
and
there's
also
the
Tran
code,
which
is
a
non
allocating
equivalent
that
you
know
just
writes
the
data
to
a
span
provided
by
the
caller
and
we'll
return
false.
If,
and
only
if,
you
know
the
destination
isn't
large
enough
for
the
buffer.
H
B
A
I
D
I
mean
I,
don't
think
we've
taken
ibuffer
writer
anywhere,
okay,
I
also
don't
know,
I,
don't
know
if
top
of
my
head.
What
our
target
is
for
this
package
and
then
I
don't
know
what
targets
a
buffer
writer
has
signer.
A
G
A
D
But
I
think
the
answer
to
Kevin's
question
since
I
can
see
it
is
at
the
top
of
what's
being
presented
right
now.
There's
the
property
bytes
written
that
tells
you
how
long
the
output
to
encode
would
be
and
what
the
minimum
length
the
trying
code
would
be
correct.
Yeah,
so
you
don't
you
don't
have
to
do
the
double
and
retry
loop
it
will.
The
the
writer
tells
you
how
big
the
output
currently
will
be
after
every
operation,
because
it's
a
property
so
it'll
it'll
give
you
the
incomplete
progress.
D
D
D
So
it
would,
it
would
just
throw
if
the
span
seemed
short,
but
in
most
of
the
cases
that
I
wanted
to
use
it
I've
already
called
what's
the
length
that
I
need
to
make
sure
my
buffer
is
big
enough
and
it
just
makes
for
essentially
a
dead
block
that
I
have
to
deal
with
yeah,
so
I
would
recommend
adding
public
int
encode
span
of
byte
destination,
and
so
that'll
that'll
throw
an
argument
exception.
If
destination
is
smaller
than
bytes
right
right.
D
Because
the
because
the
type
is
already
exposing
a
this
is
the
minimum
length
that
you
need
to
pass
to
make
trying
code
succeed.
If
you've
already
checked
it,
you
can
avoid
the
the
redundant
try
and
dealing
with
the
false
I
mean
there
would
be
no
false,
but
now
you
have
the
do.
You
call
a
try
method
and
ignore
the
return
value
which
makes
Levi
cry
or
do
you
have
this?
If
not
throw
unreachable.
D
D
I
D
A
A
A
B
Okay,
I
guess
I
should
move
on
then.
So,
let's
talk
about
so
I've
sorted
the
right
methods
by
measure
type,
so
I'm
going
to
start
with
major
types:
zero
and
one
which
reminder
is
unsigned
integers
and
negative
integers
respectively,
so
force
for
supporting,
writes
for
these
particular
major
types.
I've
exposed
this
set
of
methods
so
to
begin
we're
looking
at
signed,
integer
encodings,
which
can
end
up
being
either
major
type,
0
or
major
type
1,
depending
on
the
sign
of
the
values.
So
there
is
nothing
really
controversial
here.
B
It
just
right
in
32,
accepts
an
int
value
and
performs
the
right,
but
it
can
throw
an
invalid
operation
exception
depending
on
certain
situations.
So
one
example
is
that
you're
trying,
for
example,
to
write
that
value
into
an
invalid
context,
for
example
an
indefinite
length
string
or
whether
you
know
it
is
a
duplicate
key
in
a
map
with
you
know,
canonical
conformance
or
what's
the
third
one
I.
B
Exactly
that's
the
one,
and
that
is
basically
a
recurring
pattern
for
all
the
right
methods,
so
I've
added
those
here
and
we'll
have
omitted
those
in
in
other
methods.
Similarly,
for
n64,
then
you
have
a
similar
set
for
unsigned,
integer,
comma
encoding,
so
32-bit
and
64-bit,
you
know
behave
as
you
would
expect.
B
D
D
In
I
was
looking
to
see
which
way
I
had
actually
gone
in
a
SN
writer.
It's
an
ASN
writer,
the
the
concept.
You're.
Writing
is
an
integer,
no
matter
what
the
value
is,
and
it
has
the
same.
Semantics
of
a
small
number
takes
fewer
bytes
and
a
bigger
number
in
the
encoding,
and
so
I
I
just
have
write
integer,
but.
D
Does
because
the
well
I
mean
I
do
also
have
read
integer,
which
gives
the
wrong
or
actually
I,
guess
it
gave
a
big
int,
but
the
there's
you
know,
try
read
into
32
where
the
type
has
to
be
in
it
now
because
it's
implying
restriction,
so
it
is
a
little
bit
asymmetric,
but
it
it's
yeah.
So
that's
a
thing:
we've
done
elsewhere,
I'll,
let
other
people
say
whether
they
think
collapsing
or
in
violating
symmetry
or
maintaining
symmetries,
better
I.
A
Mean
text
writer
is
a
good
example
of
it.
You
only
have
write
methods
and
right
line
methods
and
they're
overloaded
with
like
a
million
things,
and
it's
both
good
and
bad.
It's
good
when
it's
convenient,
it's
really
bad
when
you
need
to
write
an
actual
file
format
so
for
text
reader
and
text
writer
and
never
really
cared
because,
even
if
you
pick
the
wrong
overload,
the
output
is
text
which
doesn't
really
matter
but
for
binary,
read
them
by
a
writer.
A
For
example,
I
found
the
generic
write
method
on
binary
writer
to
be
utterly
unhelpful,
because
a
very
often
forgot
that
I
had
to
cast
my
whatever
into
whatever
it
is
to
a
short
or
abide
to
and
get
the
correct,
encoding
and
I
would
have
supported
this
much
easier
if
I
would
have
actually
called
the
method
called.
You
know,
right
by
the
walk
right
in
32
or
right
in
16
and
yeah.
A
D
I,
don't
think
that
we
would
want
to
go
so
far
as
to
have
everything
just
be
right,
the
with
a
with
just
solid
overloading,
but
it
right
in
32
like
if
you
call
right
six
right
in
64
and
give
it
the
upconverted
long
of
in
in
32
it's
going
to
produce
the
same
output
as
if
you
called
right
in
32.
It's
not
it's
not
gonna
write
it
as
a
64-bit
encoded
value
in
the
output,
because
the
encoding
rules
say
you,
you
shrink
it
down
to
the
fewest
number
of
bytes
that
you
needed.
A
A
You
never
have
a
hundred
percent
symmetry
revita
in
writer
anyway,
because
of
the
way
the
data
flows,
usually
so
as
long
as
people
can
understand
what
to
call.
It's
fine,
in
my
opinion,
should
I
having
just
you
know,
write
integer
and
then
have
corresponding
read
methods.
I
mean
the
question
is
how
you
would
call
the
read
methods,
but
you
can
always
go
with.
You
know
what
integer
32
right,
integer
64,
but
if
you
really
have
to
for.
D
For
Jason,
we
said
all
the
numeric
types
because
they
end
up
just
as
the
Jason
concept
of
number
and
the
writer.
They
were
all
overloads
to
write,
number
and
then
the
reader,
because
it's
returning
a
value
and-
and
you
can't
overload
by
return
type
they'll,
then
work
get
and
then
the
data
type
you
were
looking
for.
Okay,.
D
B
B
A
Yeah
to
me
that
the
question
will
is
like
what
the
stress
of
the
API
look
like
I
mean
I
can
live
with
what
you
currently
have
on
screen.
If
we
can
get
to
the
point
where
the
Jason
one
was,
if
we
just
say,
here's
like
four
spec
models
or
four
spec
concepts,
and
then
we
just
have
basically
four
methods
corresponding
to
the
spec
things
and
then
everything
others
just
overloaded
based
on
you
know,
there's
many
dotnet
types
that
met
to
the
same
spec
concept
and
that's
I.
Think
fine.
B
Strings
so
I'm,
just
gonna
repeat,
what's
written
here,
so
the
Seaboard
spec,
to
recap,
from
its
two
types
of
byte
strings,
definite
length
and
indefinite
length
and
indefinite
length
strings,
are
basically
defined
as
a
sequence
of
definite
length
strings,
so
they're,
just
essentially
arrays
containing
definite
length
chunks.
So
the
API
experience
here
is
pretty
much.
You
know
like
an
array
in
the
sense
that
you're
pushing
and
a
indefinite
length
byte
string
context,
then
you're.
Writing
your
byte
string
chunks
and
then
popping
the
context
so
going
through
the
individual
methods.
B
B
A
B
Can
call
a
sequence
of
right,
byte,
string
methods
and
if
you
try
to
call
anything
else,
if
you
try,
for
example,
to
write
a
text
string
or
if
you
try
to
write
an
integer,
it
will
throw
an
invalid
operation
exception.
So
it's
basically,
you
know
a
strongly
typed
byte
string
array.
I
think
that's
the
way
I
think
of
it.
I.
B
Will
be
concatenated,
provided
that
you've
opted
into
this
patching
mechanism?
If
you
didn't
use
that
which
is
the
default,
it
will
basically
what
it
looks
like
in
the
super
encoring.
It
would
write
an
initial
bite
saying
that
you
know.
Oh,
the
next
thing
coming
up
is
a
byte
string
with
indefinite
length,
and
then
you
would
have
a
a
sequence
of
definite
length
byte
strings,
but
you
know
they
must.
Then
they
must
be
definite
length.
You
cannot
nest
indefinite
length
byte
strings.
A
B
A
A
I
A
B
A
A
A
B
All
right,
yeah,
so
utf-8
strings,
major
type,
three,
essentially
the
same
design,
the
four
definite
length
text
strings.
It
accepts
a
real
or
read-only
span
of
char
and
it
can
throw
an
argument
exception
depending
on
your
conformance
level.
If
it
is
anything
other
than
lakhs,
then
it's
not
a
valid
utf-8
string.
It
will
throw
indefinite
length
text
strings
work
in
much
the
same,
whereas
in
different
lengths,
byte
strings.
So.
A
D
A
D
D
Yeah
I
mean
because
this
hits
the
question
of
familiarity
like
this
is
low
level,
so
maybe
someone's
expected
to
work
with
span,
but
again
just
for
the
the
closest
comparison
in
name
space
and
time
for
ASN
I
did
for.
If
it
took
we,
don't
we
span
of
char
I,
overloaded
it
with
string
but
I
didn't
do
byte
arrays
as
overloads
for
read,
always
bad
a
byte.
F
D
A
D
A
D
I
A
B
B
So
again,
there
are
two
right
start
array
overloads
one
for
definite
length.
Writing
where
you
actually
just
declare
the
length
as
an
argument-
and
you
know
likewise,
you
have
the
indefinite
length
variant
which
doesn't
accept
any
argument
and
then
both
both
kinds
are
concluded
by
calling
the
write
and
array
method
again
as
before
the
indefinite
length
version
of
write,
start
array
will
throw
an
invalid
operation
exception
if
the
conformance
level
does
not
support
them,
and
also
there
is
no
patching
opted
in
in
the
writer.
D
Right
so
I
will
say
that
if
we
want
to
keep
the
default
for
converting
definite
length,
encodings
as
false,
that
I
would
recommend
collapsing
these
overloads
into
a
nullable
int.
Someone
has
to
make
the
the
indefinite
be
explicit,
but
that
it
would
be
OH
that
the
easy-to-use
API
of
you
call
the
bright
start
array
and
I.
Don't
know
the
length
like
the
0
parameter,
1
the
fact
that
that
will
fail
in
modes
that
we
think
are
going
to
be
common
modes
for
the
writer
suggests
that
there's
a
mismatch
in
an
API
parody.
A
D
G
D
D
A
G
D
Means
if
you
are
using
the
the
patching
mode
that
you
have
do
you
call
right
start
array
null,
but
I'm
also
completely
fine
with
keeping
right
start
a
vapor
and
paren.
If
we
switch
the
default
of
convert
indefinitely
thin
coatings
to
be
true
because
then
you're
you're
opting
into
code,
you
may
have
already
written,
will
now
start
failing.
G
A
H
B
One
approach
we
went
for
initially
was
to
use
a
much
longer
name
for
the
indefinite
length
variant,
something
you
know
right,
start
array
indefinite
length
with
that
kind
of
suffix
just
to
make
it
both
the
discouraged
users
from
calling
that
particular
variant
and
to
sort
of
clearly
distinguish
the
two.
But
you
know
in
the
end
I
just
made
them
I
just
removed
that.
A
B
I
B
H
D
A
B
B
Maps,
maps,
okay,
so
maps
are
the
equivalent
of
a
JSON
object
again,
arbitrariness,
thickness
main
difference
is
that
keys
can
be
of
any
major
type
and
key
value
data.
Key
value
pairs
are
written
in
sequence
and
it
is
the
responsibility
of
the
caller
to
track
whether
the
next
value
is
a
key
or
a
value
and
again
maps
can
contain
either
definite
or
indefinite
length.
B
Key
value
pair
counts
again
the
similar
story
with
the
methods
you
know
right
start
map
again
same
same
shape
here.
Obviously,
if
we
go
for
the
recommendation
in
array,
we'll
do
the
same
thing
with
map
right
and
map
for
ending
the
context,
either
for
definite
or
indefinite
length
maps.
I've
added
a
note
here,
which
I
don't
remember
so
yeah.
It
might
actually
throw
an
invalid
operation
exception
if,
if
I
you,
for
example,
written
a
key
that
is
not
accompanied
by
a
value
again.
B
A
A
D
D
D
D
A
I
will
say:
I
say
that
right,
but
then
I
think
when
I'm
actually
starting
the
calls
I
would
probably
say.
Maybe
I
should
double
the
number
now.
The
questions
are.
Do
I
do
this
before
money.
You
know
after
but
because
I
mean
yeah,
it
is
a
bit
weird.
We
can't
finish
a
really
say
right
start
and
then
you
say
right
wide
wide,
wide
wide
wider
you're
like.
I
A
D
B
A
Your
program
model
is
atomic
building
blocks
right,
and
so,
unless
you
say
you
give
me
the
number
of
pairs
I
don't
know
how
people
would
avoid
that.
But
at
the
end
of
the
day,
like
there's,
only
one
correct
answer
and
yaqoob
will
never
work
right.
So
in
that
sense
you
will
find
out
very
quickly.
Yes,.
D
A
D
D
B
B
A
D
B
B
So
the
first
method
is
right:
tag
which
accepts
the
Seaboard
tag
enum,
which
we
discussed
previously.
That's
the
unsigned
long
enumeration
again
same
precisely
same
semantics
as
the
previous
right
methods,
and
then
we
have
the
individual
semantic
tag:
implementations,
there's
a
a
right
day,
time
offset
which
accepts
a
day
time
offset
value
and
that
C
realizes
it
into
a
tagged
day.
Time
string
following
RFC
three,
three,
three:
nine,
if
I'm
not
mistaken,
I,
might
be
wrong
I'm
trying
to
remember
it,
but
it's
basically
that
ISO
date
time
thing.
I
D
B
A
B
D
B
A
B
They
can't,
but
the
the
only
problem
is
that
you
know
if
you
are,
if
you're
right,
if
you're
implementing
a
method
that
does
a
bunch
of
rights
and
one
of
them
throw
then
Seaboard
doesn't
expose
a
public
mechanism
that
lets
you
say.
Oh
you
know,
I
actually
want
to
return.
I
want
to
rewind
all
the
rights
that
happened
before
I,
actually
initialize
this
method
of
mine.
We
were
kind
of
debating
whether
the
checkpointing
logic
should
be
exposed
that
we
decided
against.
That
I
mean.
D
B
D
If
the
color,
if
someone
writing
these
is
an
extension
method,
did
validation
ahead
of
time,
but
none
of
these
have
invalid
input
values.
The
only
thing
that
goes
wrong
is,
and
it's
do
we
leak
the
fact
that
the
right
tag
succeeded.
So
it's
it's
not.
While
there
is
a
technically
an
observable
difference,
it's
it's
within
the
boundary
conditions
of
what
we
consider
observable.
A
B
A
B
A
B
Go
ahead,
yeah
I
mean
I,
think
there's.
There
might
be
one
thing
worth
discussing
here,
so
I'm
exposing
to
write
unix
time
ii,
segments
methods,
one
that
accepts
a
long
representation
and
another
one
accepting
a
floating-point
representation.
The
reason
why
I
do
this
is
that
you
know
the
super
spec
obviously
permits
both
so
I
just
have
the
methods
except
those
also
I
intentionally
made
the
methods
not
accept
any
kind
of
data
and
values,
because
when
you're
reasoning
in
epochs
you
know,
numerical
values
should
suffice.
B
D
B
D
And
then
just
to
be
make
sure
that
everybody
else
has
the
clarity.
When
we
talked
about
the
major
type
0
&,
1,
integers
and
big
integer,
they
are
they're
different
encodings.
This
is
saying:
write,
big
integer
and
using
the
number
1
and
catching
the
implicit
conversion
to
big
integer
does
produce
a
different
light
output
than
calling
right
in
32
of
1.
B
B
So
again,
a
recap
from
the
introduction
major
type,
seven
actually
encodes,
two
different
kinds
of
values,
so
you
have
simple
values
which
are
basically
bite-sized
numbers
used
for
denoting
stuff
like
false
and
now
etc.
And
then
you
have
floating
point
the
coatings
in
either
half
single
or
double
precision.
So
for
as
far
as
simple
values
are
concerned,
the
basic
method
here
is
write,
simple
value
which
accepts
the
Seaboard
simple
value
enum,
which
is
backed
by
bite.
B
B
A
D
D
B
That's
a
good
question
certain
implementations,
including
the
reference
implementation,
to
do
that
so
right.
For
example,
if
you
were
to
write
a
man,
certain
implementations
might
bring
that
down
to
half
precision
or
if
you
know
the
value
is
an
integer,
but
this
implementation
doesn't
do
that.
First
of
all,
because
we
don't
have
a
half
primitive,
so
we
will
only
be
doing
this
halfway
through
like
we
could
only
do
it
down
to
single
precision
and
secondly,
another
reason
is
that
seat
up
to
explicitly
prohibits
this
kind
of
conversion.
B
A
Mean
I
guess
that's
a
separate
conversation
because
most
of
it
I
mean
the
bigger
problem
is
usually
API
surface.
If
the.
If
the
only
thing
you
need
to
do
is
implementation,
wise
I
mean
how
are
you
ta
evade
one,
also
grabs
in
some
source
files
to
basically
aid
the
implementation.
We
could
do
the
same
thing
here.
I
mean
I
would
not
target
in
a
Senate
to
one.
Probably
I
would
either
do
that.
A
D
D
B
Left-Right
encoded
value,
so,
as
you
would
expect,
this
basically
just
accept
a
accepts,
a
buffer
that
contains
a
pre
encoded
SIBO
data
item
and
injects
it
into
the
current
stream.
So
it
basically
does
all
the
validation
to
ensure
that
this
is
both
a
well
forms,
Ybor
value
and
also
conformant
to
the
conformance
level
of
the
CBO
writer.
So,
basically
you
know
it
has
all
the
semantics
you
would
expect,
but
it
can
additionally
throw
an
argument
exception
if
you
know
you're
trying
to
provide
something
that
is
not
valid.
D
Yeah
I
know
I
mean
I
can
almost
certainly
understand
why
you're
currently
taking
read-only
memory,
which
is
the
readers
gonna,
take
read-only
memory.
Yep
I
think
that
you
should
play
dirty
tricks
and
turn
the
read-only
span
into
a
read-only
memory
to
call
the
reader
for
validation,
because
this
read-only
span
is
the
functionally
correct
data
type
for
this
mm-hmm.