►
From YouTube: 2023-03-30 meeting
Description
Instrumentation: Messaging
C
D
D
C
B
I
went
I
once
was
in
such
a
plane,
basically
I
think
was
from
crackle
towards
Seoul,
so
it's
very
close
and
the
flame
was
so
small
I
felt
like
with
the
bus,
basically
or
in
the
traps
it
had
like
30
places
or
20
places.
D
D
A
D
C
A
I
don't
know
if
Damien's
gonna
make
it
either.
C
Okay,
cool
all
right
well,
welcome
everyone:
it
looks
like
everyone,
Mike,
I,
think
you're,
the
only
one
on
the
attendees
list.
If
you
want
to
add
your
name
there,
if
anyone
has
something
they
want
to
talk
about,
please
add
it
to
the
agenda.
We
can
jump
off.
I
know
Robert
you're.
First,
so
I
can
hand
it
over
to
you.
B
You
can
share
your
screen.
Basically,
the
most
codes
I
think
I
think
it
will
involves
most
of
the
places.
At
least
you
were
called
out
there.
Probably
you
were
in
deep
blame
I'm,
not
sure
if
you
were
creating
those
things,
but
basically
there
are
like
the
those.
There
are
two
issues
and
one
PR's
and
they
look
like
they
are
somehow
connected.
B
Basically,
they
are
connected
with
the
exporters
and
synchronization
and
yeah,
and
there
are
some
questions
like
here
there's
a
question
regarding
otlp
metrics
exporter,
and
if
you
look
at
the
yeah,
it
was
the
good
issue
yeah,
but
it's
your
open
a
few
of
them.
So
there
was
a
question
if
there
is
need
to
synchronize.
C
But
so
like
I'm
I
was
like
99
of
the
way,
if
you're
a
comment
to
respond
to
this
I,
don't
really
know
the
answer
without
digging
into
it,
but
I'm,
just
like
looking
at
the
the
recollection.
Of
course,
the
thing
yeah
so
like
I
mean
I
was
looking
into
this.
C
C
This
was
all
constructed
before
these
methods
were
added,
so
you
know
I
the
client
itself.
I
think
also,
like
you
know,
I,
don't
think
I
know
it.
It
was
updated
to.
You
know,
reflect
these
two
methods
here.
I
like
this
is
the
hard
part
for
the
concurrency
stuff,
like
coordinating
all
this
like.
If.
A
C
Is
like
it's,
it's
it's
not
like
impossible,
but
this
is
something
that's
like
challenging
to
do
and
like,
if
you
do
it
in
both
HTTP
and
the
grpc,
there's
a
lot
of
there's
a
lot
of
like
details
that
get
repeated
as
well
as
like
just
a
bunch
of
bloat
that
happens,
and
so
this
was
like
the
the
key.
C
C
If
that's
the
case
like
yeah
I,
don't
you
can
you
can
take
the
lock
off
of
those
two
methods?
If,
if
we
can,
you
know
update
the
interface
to
say
that
that
has
to
be
concurrent
safe
and
it
is
like,
if
all
of
our
readers
are
concurrent
safe
in
their
readout
of
the
aggregation
and
temporality
functions,
then
yeah
there's
no
reason
to
not
do
that.
That
sounds
good
to
me.
B
Yes,
so,
like
related
to
it,
I
think
that
the
interfaces
or
the
exporters
like
do
not
express
like
quite
well.
What
are
the
expected
concurrency
like
guarantees
that
the
implementation
needs
to
like
provide
and.
B
Because
I
was
like
bumping
their
back
to
compare,
you
know,
design
at
least
there's
also
I
think
it's
export.
It
should
be
exported.
C
B
It
is
span
export,
yeah,
adhere.
This
is
something
which
blew
my
mind
for
a
couple
of
minutes,
so
the
export
spans
is
called
synchronously.
So
there
is
no
concurrency
safety
requirements,
but
then
you
have
shut
down
which
needs
to
be
synchronized.
So
basically
there
needs
to
be
some
synchronization
between
exports,
exporting
and
shutdown
right,
because
you
want
to
you
want
to
have
make
sure
that
all
these
fans
which
were
exported
during
shutdown,
they
have
a
chance
to
be
flashed
right,
I
think
it's
even
written
in
line
41..
B
B
A
C
B
Foreign,
yes,
but
does
it
mean?
But
if
you
look
at
at
how
you
produce
spans,
if
you,
if
you
have
this
yeah,
but
you
know,
if
there's
if
there's
only
a
reader
lock,
if
there
are
no,
it
doesn't
like
take
a
lock
until
it
doesn't
synchronize
until
there's
a
right
right.
D
D
A
B
D
So
that
that
would
mean
that
there
would
be
because
there's
you
can
have
multiple
read
locks.
That
means
it's
going
to
be
calling
export
and
multiple
good
routines.
B
B
C
B
B
B
B
Yes,
it
is
different,
but
okay,
it
was
somehow
related.
You
know,
yeah
I
got
you
okay,
so
for
this
I
think
we
do
not
need
logs
I
think
when
I
quickly
look
at
the
implementation
side
of
how
it
was
used.
I
think
that
basically,
instead
of
if
you
go
to,
if
you
we
look
at
the
implementation
right
now,
simply
the
client
is
changed
like
there's.
Like
a
you
know,
different
implementation,
which
is
like
changed
when
the
shutdown
is
called.
C
By
the
direction
I
see
what
you're
saying
so
yeah
like
okay,
let's
see
if
we
can
find
it
so.
The
exporters
like
the
otlp
exporter.
C
Yeah,
so
if
you
look
at
this
client
right
like
this,
so.
B
D
B
Mean
yeah,
maybe
those
yeah-
this
is
originating
from
here,
so
it's
changing
the
clients
during
shutdown,
the
instance.
So
that's
why
the
lock
is
needed
here,
but
I
personally,
I
will
just
make
an
atomic
bullying
and
because
we
do
not
need
to
change
the
implementation
for
the
aggregation
and
what
was
the
and
the
second
one
temporality
right.
You
just
need
to
change
the
implementation
of
four
slash
shutdown
and
four
slash
after
shutdown.
Well,
what
about
export
and
export
so
by
the
temporary
integration
remain
the
same.
B
C
B
But
I
think
I
think
it's
being
guarded,
maybe
I'm
wrong,
because
shutdown
changes
its
changes
like
the
it's
protecting
the
client.
It's
protecting,
like
you
know
the
one.
The
field
which
is
under
the
Declaration
of
the
mutex
and
the
only
place
where
it
has
changed,
is
in
the
shutdown
I.
A
C
C
That's
what
I'm
saying
like
can
we
like
I?
Are
you
sure
that
this
is
concurrent
safe,
because
then
that
comes
back
back
to
the
client
right?
Any
implementation
of
this
needs
to
guarantee
that
it's
access
to
these
methods
are
concurrent
safe
and,
if
that's
like,
if
we
can
guarantee
that
then
yeah
sure
go
ahead.
I
mean
do
that
as
long
as
you
can
do
that,
plus
you
can
guarantee
that
this
client
doesn't
ever
change.
C
D
Those
temporarily
the
temporary
temporality,
hard
work
to
say
there
and
the
aggregator
those
are
called
when
you
oh.
A
D
D
C
D
C
D
I
think,
if
you're
looking
for
the
history
of
this,
this
was
the
easy
solution.
It
might
not
be
the
best
solution,
but
it
was
the
easy
one.
Yeah.
C
And
that's
what
I
started
off
by
saying
like
I
just
you
know,
this
was
intended
to
block
a
client
and
that's
what
it
does
here
like
whether
it's
the
correct
one
I,
don't
think
it
is.
At
this
point,
yeah
yeah
I
have
a
like
I
said.
The
comment
halfway
started.
I
would
say
that
but
I'm
here
in
the
meeting,
so
yeah
I'll
try
to
finish
that
one
down.
C
This
this
is,
we
already
talked
about
this.
C
Oh,
this
is
oh
I'm,
sorry
yeah!
This
is
just
the
issue
to
the
pr
okay.
I
got
you
okay,
cool
all
right
then,
moving
on
next
thing,
I
wanted
to
do.
Is
we
talked
about
this?
The
past
few
session
or
I?
Think
just
last
week
the
V2
and
since
Aaron's
here
I
wanted
to
ask
like
where
are
we
at
on
resolving
this
issue?.
D
So,
honestly,
I
think
the
only
thing
that
needs
to
be
done
is
we'll
leave
ourselves
some
kind
of
summary
of
what
we
found
here
and
like
record
it
so
that
it
it's
not
deep
in
the
the
issues
of
this
is
how
we
want
to
evolve,
and
this
is
what
like.
These
are
the
reasons
why
we
don't
want
to
use
the
V2
API.
D
It
I
I've
started
a
document,
it's
probably
just
going
to
end
up
in
our
documents
somewhere,
but
I
have
probably
the
first
200
words
of
the
probably
thousand
that
we
need
to
write
to
actually
summarize
all
of
this
okay.
C
D
Would
be
okay
moving
it
out
of
the
metrics
GA,
as
it's
literally
just
documentation
of
how
we
want
to
proceed
in
the
future.
Yeah.
C
I,
don't
think
it's
a
blocker,
I
agree.
I
just
wanted
to
you
know,
touch
base
and
see.
We
have
yeah,
okay,
okay,
cool
next
up.
I
wanted
to
talk
a
little
about
this
private
methods
issue,
so
I
wanted
people
to
pay
attention
to
it,
because
you
know
one
of
the
things
that
was
a
takeaway
from
the
B2
is
the
V2
API
approach.
In
fact,
we're
not
going
to
go!
C
That
direction
is
that
we
wanted
to
try
to
provide
something-
and
this
was
The
Proposal-
that
Aaron
and
Anthony
and
I
settled
on
and
so
I
wanted
to
kind
of
just
call
it
out.
If
you
haven't
looked
at
it
yet
take
a
look
at
it.
It's
it's
a
pretty
straightforward.
Instead
of
adding
a
private
method
to
the
interface
itself,
it
adds
these
additional
interfaces
in
this
embedded
package
that
all
have
private
methods
and
they
themselves
are
embedded
in
the
metrics
API.
C
What
this
does
is
it
allows
for
a
user
to
choose
whether
they
want
to
embed
the
metrics
API
directly
and
have
a
runtime
Panic
or
the
embedded
interface
itself
and
have
a
compiler
just
because
it
wouldn't
compile
any
new
methods.
Added
to
the
metrics
API,
so
yeah
that
that's
that
being
said,
there's
a
Aaron
I
think
we
have
still
a
discussion
going
on
about
the
documentation
and
then
other
than
that
I
don't
see
any
other
big
hold
UPS
on
this
one.
C
This
is
this
is
definitely
blocking
the
API
next
RC,
so
I
wanted
to
bring
it
up
in
this
meeting,
so
especially
people
on
the
recording.
If
you
see
this,
please
take
a
look
at
it.
If
you
have
opinions,
I
was
going
to
leave
it
up
in
a
little
bit
longer,
just
to
make
sure
everyone
sees
it,
but
we
also
can't
wait
forever.
A
C
Sure
have
you
looked
at
my
responses
to
this.
D
D
D
And
the
reason
for
it
is
a
first
off
I.
Don't
think
that
it's
a
good
idea
to
recommend
that
we
to
have
a
recommendation
to
look
outside
of
the
package
for
or
to
have
the
documentation
of
this
package
to
say,
look
outside
the
implementation
or
outside
this
package
for
the
solutions
that
are
offered
here.
But
specifically
the
API
package.
D
Yeah,
at
the
end
of
the
day,
like
I,
think
that
we
are
factually
leaving
out.
We
are
leaving
out
the
fact
that
the
no
op
is
special
compared
to
any
other
implementation
and
that
the
the
final
recommendation
should
be
no
up.
But
it.
C
C
If
that's
you're,
concluding
the
two
issues
and
that's
that's
what
I've
tried
to
clarify
here
in
this
in
this
comment,
so
this
is
one
of
the
things
that
I,
don't
think
is
being
conveyed
and
I
don't
think
you're
hearing
it
is
that
when
you
say
to
somebody
that
the
only
other
option
is
to
bet
the
no
op
they
hear,
the
only
other
option
is
and
then,
when
they
look
at
it
and
they
go
no,
that's
not
it.
I
can
embed
anything
I
want
here.
I
can
embed
another
implementation.
C
What
they
hear
is
that,
okay,
this
documentation
isn't
actually
comprehensive,
there's
a
missing
option
here,
which
isn't
the
case,
but
that's
what
the
new
author
or
the
new
reader
to
this
instrumentation
library
is
going
to
interpret
I,
don't
want
that
to
happen.
I
want
these
documentation
to
help
new
users
and
I
want
it
to
make
it
clear
as
to
what's
actually
going
on
what
this
does
is
it
clearly
identifies
something,
and
they
can
see
it
as
the
explicit
choices,
so
they
can
embed
another
implementation,
that
is,
that
becomes
very
clear
to
them.
C
Okay,
they
also
are
aware
that
the
only
other
implementation
that
is
recommended
by
us
to
embed
here
is
the
Noah
like.
It
seems
like
this
makes
it
very
clear
that
there's
one
explicit
choice
they
can
make
and
in
that
explicit
choice,
I
would
also
recommend
that
it
be
the
NOAA
like
if
you
want
to
say
that
it's
another
like
implementation
is,
is
not
acceptable.
I
think
that's
only
going
to
be
more
confusing
to
the
user.
D
C
So
does
the
Noah
I
mean
sure,
like
we
can
go
down
the
implicit
rabbit
hole
but
like
at
the
end
of
the
day,
you're
right,
like
there's,
really
only
two
choices?
That's
the
other
thing
that
I
was
saying
is
like
you
can
either
choose
it
to
be
a
runtime
Panic
or
you
could
choose
to
be
a
compilation
panic.
C
C
You're
not
you're
missing
the
point
like
that's
not
the
point
like
this
is
this
is
kind
of
like
you're
you're,
going
down
the
implicit
Choice
issue
here,
yeah.
What
I'm
saying
is
like
if
you
go
there,
you
can
extend
that
all
the
way
and
extending
it
all
the
way
is,
is
I
think
something
useful
for
a
debate
between
people
that
understand
the
technical
implementation
of
this
API
right.
That's
not
what
this
is
intended
for.
The
the
the
reader
of
this
document
is
not
you
and
me.
C
A
C
Frustrating
I
want
this
to
be
clear,
saying
that
you
know
you
can
only
embed
the
no
up
here
is
going
to
already
take
a
frustrated
reader
and
say
this
is
even
more
frustrating
because
I
know
I
can
embed
the
SDK.
That
would
also
work.
They
don't
understand.
Why,
though,
like
and
I
think
it
like,
if
you
make
it
clear
to
them
like
yes,
you're
100
right,
you
can
embed
anything
else.
You
want
here.
We
don't
recommend
doing
that
and
it's
it's
clearly
laid
out
like
the
implementation
is
the
only
one
that
opens
Elementary.
C
D
C
I
just
want
to
make
it
clear,
like
there's
two
things
we're
trying
to
say
in
this
Doc
and
that
is
to
try
to
like
ease
that
development
burden
and
then
make
it
clear
as
like
what
the
recommendation
is
and
if
you
just
do
make
the
recommendations.
You
don't
understand,
like
that,
there's
confusion.
That's
introduced.
D
D
C
D
C
Yeah,
okay,
next
up
I,
wanted
to
talk
about
another
thing
that
is
likely
blocking
the
API
release.
C
So
there's
this
open
issue
about
adding
it's
not
a
thread
safe
when
called
more
than
one
attribute,
and
so
this
I
think
has
okay,
that's
not
really
clear,
but
essentially
you
call
add
from
two
different
methods
in
two
different
go
routines
and
it's
gonna
panic,
because
underlying
ad
is,
it
doesn't
have
to
add
it
could
be
recorded
as
well
excusing
if
it's
past
the
same
slice
of
attributes,
it's
going
to
mutate
that
slice
of
attributes
when
it
creates
a
set-
and
that
does
a
sort
on
top
of
it,
and
so
because
of
that
you're
gonna
get
a
data
race
here,
so
I
think
there
there's
I,
think
a
few
different
options
here.
C
C
I
think
there's
a
really
strong
reason
to
do
this.
It's
there's
also
reasons
to
not
do
this
and
I
think.
The
reason
to
not
do
this
is
that
you
get
rid
of
the
variatic
arguments,
so
the
empty
case
is
it
requires.
Boilerplate
is
I,
guess
the
the
downside
specifically
something
like
this
like,
although
technically
I,
don't
think
you
need
to
use
empty
site,
you
can
just
pass
a
nose
new
set
here.
I
put
empty
set
everywhere,
just
to
make
it
explicit,
but
this
is.
C
This
is
essentially
what
the
the
no
op
case
turns
into
I'm.
Sorry,
the
no
attribute
case
turns
into
the
reasons
that
it
does
make.
Sense,
though,
is
because,
if
you
are
going
to
reuse
these
sets,
the
user
is
enabled
to
do
that
on
their
own,
like
we
don't
actually
have
to
deal
anything
like
there's
this
whole
issue
around
providing
a
what's
it
called.
C
It's
called
like
a
bound
API
I
think
we
used
to
have
this
and
Java
had
it
as
well,
but
they
also
got
rid
of
it
because
it
was
causing
a
bunch
more
issues
than
they
wanted.
But
the
idea
is
is
that
if
you
have
a
bunch
of
instruments
that
are
going
to
make
a
recording
for
the
same
attribute
sets
over
a
long
period
of
time,
you
can
just
submit
those
attributes
sets
once
and
then
and
then
forget
it.
C
This
allows
you
to
do
something
very
similar
because
you
can
create
that
attribute
set
once
and
then
pass
it
to
each
one
of
these
functions
wherever
you
want
right,
like
the
downside.
Is
you
know
like
if
you,
if
you
didn't,
want
to
do
that
and
say
the
attributes
are
going
to
be
updated
every
single
time.
You
have
to
wrap
this
in
a
new
attribute
set
and
that
again
like
it
adds
boilerplate.
C
But
you
know
to
also
be
clear.
It
doesn't
add
another
allocation
like
it
used
to.
We
fixed
that
a
little
while
ago,
when
we
fixed
the
pooling
on
this
on
this
function,
so
performance
wise.
It's
it's
not
equivalent,
but
it
also
isn't
like
I
mean
you're,
talking
about
a
reshuffle
and
a
sort
right.
So
if
you're,
if
you're
passing,
attributes
like
that,
like
you're
already
expecting
it
to
form
a
set,
I
I,
don't
see
like
a
few,
you
know
tens
of
nanoseconds
more
in
the
sort.
C
That's
actually
going
to
cause
the
problem
here,
but
I
guess
it's
an
order
end!
So
well,
let's
listen
over
to
Ben,
but.
C
Logger
I
think
analog
answer
something
like
that
is
probably
about
yeah.
Something
like
that
so
like
it's
definitely
something
that
is
is
gonna
impact
performance,
but
the
thing
is
that
it
isn't
compared
to
our
current
SDK
implementation,
because
each
one
of
our
methods
already
creates
a
set
for
you,
underneath
the
Hood
and
so
I.
C
Think
if
there's
like
Josh
has
some
other
way
of
going
through
and
hashing
each
one
of
these,
but
at
the
end
of
the
day
like
he
also
creates
a
set
at
the
end
of
the
day,
because
he
also
needs
to
produce
a
set
that
gets
translated
into
the
data
model.
That
is
is
pushed
off.
So
you
know
he
may
not
be
able
to.
C
He
may
be
able
to
optimize
away,
creating
some
sets,
but
I'm
saying
that
if
you
accept
a
set
as
a
argument,
the
choice
stops
being
you
know
some
sort
of
choice
that
the
SDK
is
going
to
implement
for
the
user,
but
the
user
gets
to
make
that
choice
well
before
they
actually
make
the
call,
and
they
can
do
any
sort
of
caching,
they
can
do
any
sort
of
optimization
of
Separation.
They
want
yeah.
D
C
I'm
or
I'm
hesitant
to
do
that,
and
the
reason
is
just
because
you're
going
to
have
two
methods
for
the
same
thing:
it
becomes
confusing
to
users
to
as
to
which
one
they
want
to
use.
You
know,
and
it
also
it
also
introduces
this
race
condition.
That
is
always
going
to
be
there.
If
you
accept
a
slice
of
attributes.
C
D
Like
I
would,
I
would
say,
add,
is
no
attributes.
It's
just
and
add
with
attributes
is
a
set
like
your
proposal,
I
see
you're,
saying
I
like
the
first
one
can
literally
be
defined
with.
C
D
C
Gotcha
yeah,
it's
just
like
a
wrapper
around
yeah.
That
makes
a
little
more
sense
to
me.
I
I
hear
you
yeah
that
that
does
make
a
little
more
sense
to
me.
Yeah
like
if
you
had
one
that
accepted
periodic
arguments,
makes
a
lot
less
sense
to
me,
but
yeah.
That
makes
a
little
more
sense
to
me,
I
mean
so
we'd
have
to
do
ad.
We
have
to
do
the
record,
and
what
about
observe?
We
do
the
same
thing
like
observe,
with
attributes.
B
C
An
interface
but
actually
no,
not
technically
just
an
interface,
and
that
can
be
you
know,
a
pointer
itself
to
all
the.
B
C
The
reason
the
reason
I
didn't
want
to
pass
it
as
a
pointer
is
one
it's
lightweight
around
the
interface
and
then
two.
It
has
the
same
problem
then
right,
because
if
the
pointer
changes,
you
have
still
a
data
race
underneath
the
hood
or
could
have
a
data
race
underneath
the
hood.
C
If
you
have
a
set
pointer
and
like
you
change
the
the
underlying
value,
the
pointer
points
to
the
right,
like
so
say,
say
you
went
to
a
bunch
of
measurements
and,
like
you,
have
a
set
pointer
and
you're
passing
this
pointer
as
an
argument
and
each
time
that
you
call
it
you're,
actually
changing
the
pointer
value
like
you're,
passing
the
same
reference
and
then
all
of
a
sudden.
At
the
end.
It's
that
issue
that,
like
all
the
previous
recordings
now
are
pointing
to
a
different
value
that
you
weren't
expecting.
B
B
Yeah,
but
still
you
you
could
pass
immutable
struct
as
a
pointer.
It
will
be
safe
as
well.
C
It's
the
same
reason
that
if
you
do
some
sort
of
iteration
over
a
loop
and
you're
calling
a
function
within
there,
you
don't
you
can
easily
try
to
assign
the
loop
variable
inside
of
the
function
call
and
it
will
be
incorrect
Behavior,
because
it's
the
last.
B
Now
I
see
so
you're
getting
a
new
value.
Yes,
because
you're
getting
this
set
and
then
you
are
sorting
the
set
I
thought
that
when
you're
creating
a
set,
it
produces
already
assorted
we've
sorted
attributes
that
when
you
know
the
cons,
the
factory
function
or
the
Constructor.
Basically,
these
are
that
there
is
no
ex
Source
function,
but
it's
you
know
sorted
like
from
from
the
beginning
and
you're,
never
rotating
it.
C
Oh
no,
it
started
from
the
beginning,
but
I'm
saying
it's
like
it
would
just
yeah,
okay,
I
I'm,
not
I,
don't
think
I'm
following
you
and
we
might
be
talking
past
each
other,
but
no
this
this
prevents
this
proposes
it
as
just
a
as
a
value,
not
a
pointer
yeah
I
mean
I,
but
back
back
to
Aaron's
point,
though
about
like
having
multiple
methods
like
I.
Think
if
that
makes
sense
Aaron.
Is
that
something
you
wanted
to
comment
in
the
this
issue
here.
D
Ahead,
I
wanna
I
wanna
be
clear.
That
is
just
a
suggestion.
I
have
not
thought
through
100
the
the
consequences
of
that,
but
if
it
makes
sense
that
might
be
no.
C
And
like
the
thing
is,
is
like
this:
this
in
Java.
It
like
reminds
me
of
what
they
do
there,
because
they
have
like
I,
think
three
different
methods,
all
the
same
name,
because
they
can
do
that
in
Java,
where
it's
all
overloaded
but
yeah
it
one's.
Just
like
add
one's
ad
with
attributes
and
then
I
think,
there's
like
I
think
there
might
be
a
third
but
I
can't
remember,
but.
C
I
wish
we
could
do
the
same
thing
and
go
like
God
I
wish.
We
could
do
the
same
thing
we
go.
We
could
use
the
V2
approach,
but
yeah,
but
yeah
I
mean
I.
Think
this
is.
This
is
totally
fair.
I'll
have
to
look
at
the
spec.
That's
the
only
thing
that
I'm
worried
about
is
like
the
wording
on
the
spec
but
I.
C
C
C
Okay,
cool
yeah,
this
last
one
is
related
to
a
bunch
of
different
issues
that
we've
had
filed
for
us,
and
this
is
around
the
fact
that,
like
the
schema,
URL
is
tightly
coupled
to
the
resources.
Well,
it
can
be
technically,
it
cannot
be.
But
if
it's
not
it
technically
is
a
I.
Don't
know
it's
it's
a
unified
empty
schema
URL,
so
it
always
is
coupled
to
schema
URL,
but
there's
no
translation
method
allowed.
C
So
if
you
have
one
resource,
that's
fine
with
one
schema
URL
and
you
don't
control
where
that
resource
comes
from
so
say
like
a
detector
and
some
sort
of
third-party
package
or
in
the
contrib
repository
or
even
our
repository,
and
you
want
to
use
a
different
version
of
the
schema
file.
Then
there's
a
problem
because
you
can't
merge
those
two
resources
right
and
that's
a
that's,
a
problem
that
is
actually
emanating
from
the
specification
where
they
say,
literally,
that
a
merge
error
should
occur
when
the
schemos
URLs
are
incompatible.
C
So
what
this
does
is
well
I
got
a
thumbs
up
from
Anthony,
so
that
was
I
expected
it
kind
of
skirts
around
that
and
and
I
think
it
does
it
in
a
a
way
that
is
somewhat
useful.
So
what
this
does
is
see
if
I
can
find
it.
It
adds
this
new
method
on
a
resource
which
is
like
with
schema
URL,
and
it
would
then
create
a
new
resource
that
uses
the
new
schema
URL.
C
First,
with
the
schema
URL,
what
this
does
is
it
just
does
a
comparison
of
the
schema
URL
versus
the
one
that
you're
actually
wanting
to
create
with,
and
it
will
either
upgrade
or
downgrade,
depending
on
the
relative
versions
of
each
one
of
those
schema
URLs,
which
is
actually
defined
in
the
schema
definitions
for
the
Otep
of
like
what
an
upgrade
in
or
downgrade
look
like,
so
it'll
produce
the
resource
as
long
as
the
schema
is
valid,
it'll
produce
the
resource
that
you're
expecting
and
then
the
only
thing
that
merge
at
does,
which
is
essentially
you
know.
C
In
addition
to
merge,
merge
is
just
left
as
it
is.
Is
it
takes
up
a
number
of
resources
that
you
want
to
merge
together
takes
a
schema
URL,
you
want
to
merge
them
at
and
then
contexts
may
have
to
do
an
HTTP
call
to
get
the
schema
URL
and
it
just
calls
the
with
skim
URL
to
make
sure
they're
all
on
the
same
schema,
URL
the
schema
version,
and
then
it
returns
a
merged
version
of
that
here.
C
So
yeah,
that's
the
proposal
at
least.
C
Well
or
yeah
I
mean
like
whatever
yeah
I,
think
it's
HTTP,
it's
just
to
get
yeah
yeah
it
does.
It
does
cache
them,
though.
That
is
the
one
thing
it
does.
Do
it
captures
them
local
to
the
function.
Call
so
I
created
this
thing
called
the
registry
and
that
registry
so
say,
like
you
know,
you
know
the
schemer
URL
here
is
like
1.1,
and
these
are
all
1.0.
D
My
my
very
big
hesitation
is:
we
are
going
to
go
fetch
a
potentially
unknown,
like
an
application,
author's
dependencies
get
to
Define,
essentially
where
the
schemas
may
exist
right.
D
Are
we
opening
ourselves,
our
our
cells
and
our
users
to
potentially
very
hazardous
things
with
doing
that
like
that
is
that
is
a
very,
very
scary
step
like
I
I
wouldn't
be
opposed
to
this.
If,
if
this
was
all
using
the
schemas,
the
schema
URLs
that
we
already
have
to
find
the
version,
the
simcom
version,
one
through
whatever
or
or
some
some
already
known
versions,
but
well.
C
But
so,
but
we
could,
but
then
the
problem
is:
is
that,
like
schema
definition,
isn't
necessarily
always
going
to
be
ours
right,
like
yeah
I
know,
they're
they're
definitely
like
the
schema
was
designed
so
that
a
third
party
can
come
along
and
say
like
we
don't
like
the
semantic
conventions
of
Hotel,
so
we're
going
to
change
it.
Yeah.
D
C
So
I
can
show
you.
This
method
is
not
too
much.
There's
a
cash
flow
up
here,
but
essentially
like
it
does.
This
request
so
just
creates
a
request
at
that
method.
This
is
all
the
requests
and
then
it
does
the
schema
URL
it
parses.
So
this
is
this
schema
parse
function
that
comes
from
from
our
internal
here.
This
parse
function
itself
is
a
Hammel
on
Marshall,
yeah,
yeah.
C
C
D
C
So
well,
okay,
I
mean
like
so
the
thing.
The
thing
that
doesn't
like
this.
This
doesn't
worry
me
because
it's
that's
up
to
the
user
right
like.
C
Well,
so
it's
just
that,
like
you
know,
with
schema,
URL
is
like
the
person
who's
calling.
This
is
the
person
who's
gonna
be
using.
It
is,
is
what
I
see
it
as
and
so
like,
if,
if
somebody's
returning
a
resource
from
a
third
party
package,
they've
already
gone
through
this
or
or
they're
returning,
something
like
that,
but
like
you,
you
need
to
call
this
yourself.
The
the
thing
is
like
here
like
you
could
be
getting
a
third-party
resource
that
has
a
schema.
C
D
C
D
I
mean
you
could
go
and
figure
out
where,
like
you,
could
dive
into
any
of
the
resources
that
are
returned
to
merge
them
right
like
but
yeah.
C
A
D
C
D
I
I
I'm,
just
weary
of
our
library,
reaching
out
over
HTTP
like
adding
that
ability
like
giving
that
tool
set
to
to
to
third
part
like
giving
an
extra
ability
to
reach
out
to
other
third-party
things
like
as
as
it
stands,
it's
probably
okay
like
because
we
assume
a
lot
of
the
the
fact
that
third
party
is
is
embedded
but
I
just
wanna.
Well,.
A
C
Hotel
schemas
are
going
to
contain
bugs,
and
so
it's
like
you
know
how
do
you?
How
do
you
deal
with
that?
Well,
it's
like
at
the
end
of
the
day,
you
just
need
to
make
sure
the
user
is
is
able
to.
I
guess
is,
is
the
key
because,
like
if
they're
not
able
to
understand
like
how
this
is
operating
or
they're,
not
able
to
access
how
it's
operating
right
so.
C
Is
like
you
know
if
here,
if,
if
say
like
the
resource,
you
couldn't
determine
the
the
schema
URL,
it
was
going
to
fetch
before
it
fetched.
It
that'd
be
a
really
big
problem
for
me
right
because
then
the
user
is
going
to
call
merged
app,
but
they're
not
able
to
vet
any
of
these
parameters
that
are
going
to
get
passed
here
like
they
can.
Obviously,
vet
schema
URL
right
like
because
they
can
go
down
because
they
know
how
this
is
going
to
use.
C
D
I,
don't
want
people
to
be
surprised
when
they
say
oh
yeah,
it
does
this
and
now
it
starts
fetching.
You
know
five
different
resources
schema
URL
right
because
because
they
included
it,
I
like
I,
wouldn't
be
surprised
by
this
function.
Reaching
out
to
the
schema
schema
URL.
You
know
the
string
that
we
put
in
there,
but
I
might
be
surprised
until
I
thought
about
it,
that
it
reaches
out
to
all
of
the
resources,
but.
A
C
That
being
said,
like
I,
also
think,
there's
a
really
oh
good
idea
to
add
something
like
this,
because
it
actually
wasn't
that
hard
and
I
think
it's
it's
a
it's
a
super
useful
thing
for
a
lot
of
people
like
there's.
Definitely
some
some
desire
here
so
I
wanted
to
try
to
just
I
proposed
it.
I
guess
is
the.
C
Cool
awesome
all
right,
well,
I,
think
that's
the
end
of
the
listed
agenda.
Anybody
else
have
something
they
wanted
to
talk
about.
B
B
C
Yeah
the
day
the
I
don't
work
there
or
something
like
that.
Yeah,
the.
A
D
Yeah
I
I
wish
I
could
go,
but
it's
not
in
the
cards
right
now.
C
Yeah,
okay
well,
I
mean
but
yeah,
but
that
is
a
good
college.
People
who
are
watching
the
recording
like
I,
don't
know
if
there's
like
a
slack
Channel
or
something
for
this,
but
it'd
be
cool.
If
you
know
everyone
in
the
go,
Community
could
also
meet
up
and
just
say
hi,
but
yeah
I
won't
be
there.
Aaron
won't
be
there.
I,
don't
know
about
Anthony
I,
don't
know
about
Mike,
but
Robert
will
be
there.
C
No
I
will
also
not
be
there.
Okay,
okay,
well
cool
I!
Think
we
can
edit
here
then
thanks.
Everyone
for
joining
Aaron,
safe
travels
and
we'll
see
you
all
next
week,
bye,
bye,.