►
From YouTube: 2019-10-11 Java SIG
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
B
B
B
C
B
C
C
F
E
Great
I
guess
we
can
get
started.
We
will
only
have
like
half
an
hour.
You
know
30
minutes,
please
so
what
we
decided
from
last
week,
so,
let's
jump
to
thee.
Do
the
stuff
first
item
is
that
I
didn't
have
enough
time
to
work
on
the
clock,
interface
and
approach
so
I'm
wondering
we
should
leave
out
the
current
PR.
You
know
for
adding
explicit
time
stamps
for
spanned
start
and
end.
What
do
you
think
baktun?
Should
we
leave
that
out
or
should
we
just
merge
what
we
have.
C
There
is
an
issue
that
I'm
funny
right
now
and
probably
something
that
I
would
like
to
hear
options
from
others.
I
know
sorry,
I
know,
Java
8
adds
this
instant
time,
but
for
and
we
try
to
simulate
the
same
thing
by
defining
our
only
time,
step
class.
My
question
is:
do
we
want
to
actually
have
a
class
or
we
go
with
evokes
represent
in
nanoseconds,
which
will
give
us
like
300
years
of
resolution,
and
we
avoid
one
unnecessary
allocation
and
a
lot
of
complicated
things
in
calculating
time
scent
and
stuff.
D
So
I
guess
I
can
speak
to
that
a
little
bit.
I
just
put
a
polar
question.
Last
night
we
kind
of
related
to
this
topic,
so
it's
kind
of
fresh
on
my
mind,
and
that
was
mostly
around
removing
protobuf
from
the
steam
converter
stuff.
If
you
saw
that
yeah
so
I
think
what
you're
suggesting
is
just
having
one
number
like
just
just
only
tracking
Long's
nanoseconds
is
that
we
are
sending
yes,
which.
C
C
You
you
do,
you
do
have
me
list
which
will
give
you
you
will
have
if
you
do
Java
7,
you
teach
me
list
you
do
the
system
me
release
from
epoch
or
something
like
that.
I,
don't
remember
that
last
little
metal
name,
but
but
after
that,
in
Java,
8
or
moving
forward.
What
you'll
do
in
two
instant
now
na
nose
right,
yeah.
C
C
The
reason
why
we
use
nano
time
internally,
so
we
do
use
we,
we
read
once
a
park
and
everything
inside
a
single
trace
everything
we
calculate
using
nano
time
from
that
moment
to
that
epoch
for
for
guarantee
ordering,
because
people
will
say
I
want
to
see
that
my
my
event
that
I
recorded
here
is
going
to
be,
after
that
event
or
for
span
that
I
started
after
should
be
after
which,
which
is
a
nice
thing
that
nano
time
in
guarantees
you
so
so
it's
more
like
a
question.
How
do
we
represent
epochs?
C
F
F
F
F
So
since
we
need
like
we
basically
won
both
fair,
we
sort
of
could
we
use
the
epoch
millage.
So
basically,
we
have
a
clock
class
when,
when
we
started
up
it,
initializes
ok
here
was
the
epoch
or
the
time
when
we
started,
and
we
use
that,
and
we
also
take
a
sort
of
cyst
now
no
timestamp
at
that
point,
and
we
use
that
as
our
own
internal
epoch.
So
every
time
you
restart
you'll
have
a
new
epoch,
but
we
can
calculate
sort
of
from
the
beginning
of
our
startup.
F
We
can
have
full
nanosecond
granularity
and
if
you
want
to
have
the
actual
time
and
time
of
day,
we'll
have
to
match
it
up
with
the
phenomena
we
took
in
the
beginning.
The
benefit,
then,
is
off
by
10
millisecond.
We
know
it
won't
change
while
we're
running
and
we're
only
paying
around
with
nanoseconds
during
the
whole
execution
time.
That's
that's.
D
D
C
D
C
D
C
D
C
F
C
The
evil,
if
you
make
a
calculation,
it
goes
up
to
300
years,
so
you
can
include
in
in
63
I
mean
because
long
in
Java
is
fine.
So
in
this
to
you
know
a
sixty
treat
in
63
bits.
You
can
encode
300
years
with
the
nanoseconds
resolution
and
I.
Think
I
think
that
was
the
discussion
that
until
two
thousand
two
hundred
will
be
fine
and
I.
Don't
expect
this
code
to
live
that
long
sorry,
so
it
could
be
point
everyone,
but
I.
Don't.
E
C
A
F
A
A
C
C
Maybe
we
did
enough
I,
don't
know
if
we
there
are
good
arguments
to
be
made
against
nanos,
the
the
main
one
being
in
nano
world
even
reading
the
nano
time
is
around
200
220
nanos.
So
if,
if
the
time
measurement
cost
more
than
than
the
resolution,
then
you
can
make
arguments
that
the
resolution
that
we
are
going
for
is
probably
not
the
best
company
yeah.
F
I
think
the
main
benefit
was
taking
with
is
probably
to
stick
with
me
lists
and
or
nanos
and
go
with
Michelson
and
others.
Are
you
just
right,
because
there's
no
natural
way
to
really
see
get
it
another
units
really
and
for
doing
it
in
microseconds?
You
would
have
to
do
it
with
and
in
a
non
resolution
and
then
sort
of
reduce
the
resolution,
basically
to
microseconds.
So
then
you
might
as
well
keep
it
unless
we
want
to
save
a
few
bytes.
C
A
E
C
E
B
Yeah
so
I
thought
I
would
just
you
know
the
other
agenda
item
I
had
so
New
Relic
has
been
spending
this
week,
trying
like
taking
open,
telemetry
and
plugging
it
into
open
tracing
and
using
the
shim
extensively
to
holes
and
gaps
and
pretty
quickly
ran
into
some.
You
know
the
unimplemented
stuff
that
I
put
in
that
the
probably
miss
named
PR
for
is
our
current.
The
current
implementation
of
the
SDK
plus
the
shim
ends
up
with
a
lot
of
broken
traces.
B
E
E
B
B
B
Yeah,
so
the
PR
that
I
that
I
put
in
there
was
just
a
like
a
real,
quick
hack
to
at
least
propagate
a
couple
of
the
w3c
headers,
which
I
know
is
not
complete,
and
it's
certainly
not
it's.
It's
probably
not
accurate
in
a
lot
of
ways,
but
it
at
least
gets
w3c
traces
to
flow
through
the
system
which
they
don't
at
the
moment
at
all.
So
so
so
do
you
use
baggages,
do
care
about
packages.
B
C
B
So
I
actually
actually
what
we,
what
we
did.
No
I
will
I'll
try
to
put
this
up
somewhere
on
the
web,
so
it's
public
is
basically
we
took
the
Santa
open
tracing
sample
app.
Sorry,
the
open
tracing
can't
rib
special
agent
sample
app
and
it's
wired
in
open
telemetry
as
the
tracer
mm-hmm
and
then
just
started
extra
sort
of
playing
around
with
the
UI,
so
I
can
I
can
definitely
post
the
exceptions.
Where
mean
exceptions
are
just
that.
You
know
the
one
beyond
supported
operations
that
are
getting
thrown
okay
but
yeah.
B
It
was
actually
a
really
good
experiment.
I
learned
a
lot
about
how
a
lot
of
this
stuff
works
internally
but
yeah
and
we
have
a.
We
have
a
super
prototype,
II
implementation
of
the
plug-in
for
special
agent.
It
has
open
telemetry
wired
into
it
nice,
so
we
can
make
that
repo
public.
It's
not!
It's
not
really
really
ready
for
contributions
at
this
point,
but
we
could
make
the
repo
public
and
kind
of
show
you
what
we,
what
we
wired
up
so.
C
Yeah,
let
me
know
if
you
can
make
it
public
and
if
you
can,
it
will
be
very
useful
to
have
that
as
an
example,
you
can,
even
if
you
want
to
move
it
here
for
the
moment
or
but
anyway,
keep
it.
There
I
think
it's
better,
because
it
forces
us
to
also
see
if
our
public
artifacts
that
we
deplore.
We
release.
B
Are
good
yeah,
the
other
thing
I
was
doing
I
was
poking
at
was
seeing
if
I
can
implement
the
distributed
again.
These
class
names
should
be
context.
Manager
myself,
like
override
override
just
the
distributed
context
manager,
but
the
SDK
implementation
is
all
package
access,
so
they
can't
actually
get
access
anything
to
provide
my
own
implementation.
Yeah.
Let
me
let
me.
C
C
Is
it
or
not,
with
open
telemetry
by
default,
which
is
cool,
but
they
are
now
removing
a
lot
of
unnecessary
allocations
like
they
are
removing
the
fact
that
for
the
span
they
remove
the
Builder
pattern
that
they
go
with
with
the
static
factory
methods
to
avoid
allocations
and
stuff.
They
are
that
crazy
right
now,
interesting
and
I
was
curious.
How
much
we
stick
with
Java
in
general.
I
think
we
should
stay
with
Java
formats
for
the
moment,
use
builders
and
stuff.
But
but
at
one
point
we
may
want
to
revisit
that.
C
C
F
We
are
good
any
other
topics.
Questions
aside,
one
question:
I
the
contribution
for
the
open
and
tracing
for
integrating
with
site
decoders
basically
have
like
a
quarter
of
events
happening
when
you
create
the
spine
horoscope
as
they
call
it
there,
and
so
so
you
can
correlate
sort
of
memory
allocation,
other
things
going
on
the
VM
with
sort
of
your
tracing.
So
thank
you
sort
of
just
started
thinking,
okay.
How
would
I
do
this
read
the
code
a
bit
more
well,
just
the
basic
question
would
put
you
know.
F
This
would
only
be
really
supported
on
your
eleven,
because
that's
where
fight
order
is
open
sourced,
but
good
recommendation
be
to
sort
of
try
to
integrate
this
into
the
default
implementation
or
with
a
way
to
do
it
rather
be
to
create
the
way
we
did
it
in
open,
telemetry
or
open
tracing
was
basically
build
wrapping
tracer,
and
would
that
be
the
way
to
go
here
as
well?
Or
is
there
an
other
way
to
cook
into.
F
F
So,
basically,
what
we
need,
what
we
want
to
do
is
create
events
in
flight
recorder
at
the
same
time,
you're
creating
span
events
and
trade
with
some
information
about
which
thread
to
span
was
active
in
acceptor.
So
if
you
transfer
span
between
different
threads,
we
want
to
be
aware
of
that.
So
we
can
say
that
this
thread
was
executing
this
ban
at
this
particular
time.