►
From YouTube: Diagnostics WG Meeting - 2018-03-07
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).
A
A
A
D
A
A
Okay,
so
why
don't
we
do
this
like
in
the
next
I?
Don't
know,
I,
don't
know
if
next
meeting
we
want
to
actually
do
a
deep
dive,
but
maybe
the
one
after
that
we
just
want
to
like
slot
them
in
in
these
regular
11
a.m.
slots
now,
and
rather
than
go
through
stuff.
That's
on
an
agenda
item
we'll
just
dive
in
on
something.
Is
that
fair.
B
A
My
hope
is
that,
like
we've
got
enough
stuff
to
discuss
in
detail
like
I
kind
of
feel
like
from
the
summit,
that
there
was
a
lot
of
deep
conversations
that
were
happening
and
that
it's
like,
if
we
said
like
hey,
we
wanted
to
you
know,
go
into
detail
about
all
these
different
things.
We'd
have
easily
have
you
know
six,
a
dozen
different
topics
that
somebody
could
dive
on
right
agreed.
B
A
So
you
know
we
could
prioritize
things
to
what
people
think
are
interesting
right
now,
I've
got
to,
and
you
know
the
you
know,
I'm
gonna
I
think
it's
the
balance
between,
like
you
know,
doing
those
deep
dives
and
then
making
sure
that
you're,
you
know
tracking
and
discussing
stuff.
That's
on
the
agenda
right.
If
nobody
has
any
strong
opinions,
I'll
just
say
we
do
it
every
other.
You
know
meeting
until
somebody
says
that's
too
much
right
or
it's
not
enough.
Does
that
sound,
fair.
A
So
the
working
group,
the
times
changed,
we're
now
at
11
in
case
anybody
on
the
call
hasn't
noticed
I
closed
the
issue.
I,
don't
think,
there's
anything
else
to
discuss
for
whatever
reason
somebody
thinks
we
need
to
adjust
times
again.
It's
like,
please,
you
know,
don't
hesitate
to
bring
it
up.
I,
don't
think,
there's
a
time.
That's
gonna
work
really
well
for
everyone.
So
I
would
don't
be
shy
if
you're
like
this
time
is
terrible
for
me
and
you
know,
I
think
some
of
the
other
groups
have.
A
A
D
A
G
Have
some
ideas
I
think
we
can
have,
for
example,
with
a
J's
function
is
created
if
the
code
generated
is
different
from
the
building
trampoline,
when
the
flag
is
on
the
runtime
site
for
for
the
future,
and
maybe
also
I,
had
another
idea,
don't
remember
now:
oh
I
may
be
using
the
code
event
listener.
I.
D
I
believe
this
could
be
a
good
topic
for
the
deep
type
by
the
way
to
come
up
with
the
timeline,
the
plan
around
testing,
how
we
bring
back
to
function
at
it
together,
v8
to
the
north,
yes,
and
how
we
can
provide
some
support
for
that.
So
I
think
those
days
kind
of
topics
could
be
good
candidates
for
this
deep
type
agreed.
A
A
A
G
A
A
H
Is
one
bug
fix
in
electron
like
related
to
the
electron,
that's
kind
of
worrisome,
because
it
will
further
regret
regress
performance.
So
the
background
is
that
in
electron
you
have
gate
context
that
come
from
chrome
and
from
no
TAS,
and
so
when
you
have
a
promise,
that's
resolved
in
the
chrome
context
that
promise
hook
in
no
TAS
will
fire
and
when
we
try
to
get
the
environment
that
will
fail.
H
H
H
H
So
one
thing
that
Benedict
and
I
have
been
thinking
about
is
to
redesign
the
API
so
that
you
install
for
every
one
of
the
five
different
types
of
hooks
J
as
a
JavaScript
function
onto
the
context,
so
that
the
aid
will
fire.
Those
JavaScript
functions
when
promised
originating
from
that
context.
Changes
its
state
and.
H
Ideally,
the
I
think
ID
tracking
would
also
be
done
by
v8
to
get
rid
of
this
like
going
into
the
network
and
having
to
you
know,
do
the
thing
in
C++,
and
maybe
we
can't
even
figure
something
out
like
doing
the
destroy
somewhat
more
performant
inside
of
the
eight
and
instead
of
passing
the
drama's
back
to
the
assumed
cook
just
has
in
the
promise
ID
it
did
a
as
an
ID,
but
this
was
just
a
short
discussion
that
I
have
with
Benedict
today
and
we're
not
sure.
Where
does
that
make
sense?
C
E
C
H
So
one
open
question
is
that
if
we
decide
to
do
this-
and
we
actually
come
up
with
this
like
engineering
time
to
do
it,
what
is
the
timeline
and
what
are
the
dependencies?
I?
Don't
think
we
can
make
it
by
no.10,
because
that's
really
really
close
and
if
we
can
only
make
it
by
note
11
is
there
a
possibility
to
you
know,
emulate
the
current
API
using
what
we
are
proposing
right.
C
H
C
A
H
Actually
quantify
it,
but
I'm
very
for
it
will
be
significant
because
you
have
to
actually
do
an
object
lookup
in
C++
and
there's
no
IC
and
like
an
lioncash
to
optimize.
That
and
like
generally,
it
feels
like
the
way
I
think
cooks
are
currently
model
is
not
not
correct,
because
what
you
actually
want
to
do
is
to
have
the
hooks
for
context
and
not
paralyzed
it,
because.
E
H
E
Oh
okay,
so
just
wanted
to
point
out
that
we
are
conflating
two
different
discussions
here.
One
is
there's
this
electron
issue
that
there
is
a
fixed
being
proposed
that
might
be
problematic
and
Jung
is
working
on
a
alternative.
That's
going
to
be
better,
so
I
think
that's
a
that's
a
problem,
that's
more
immediate,
but
I
think
we
can
work
around
it.
But
the
second
more
pressing
problem
is
that
we
think
that
promise
hooks
may
API
will
need
to
be
changed.
E
One
thing
I
would
like
to
do
is
be
able
to
go
to
the
to
the
module
ecosystem
and
give
them
the
tools
and-
and
the
code
necessary
to
do.
You
think
context
properly,
but
I've
already
been
doing
this
with
with
the
changes
in
nan
have
already
been
doing
this
for
a
few
modules
such
as
FS
ament's
and
notes
ass,
like
I'm
modifying
them
to
properly
propagate
context.
E
So
the
question
really
becomes
that
as
long
as
we
there
is
uncertainty
that
we
might
change
async
cooks,
which,
by
the
way
I'm
not
hearing
that
we
might
change
as
it
cooks,
I
think
the
API
might
survive
with
the
exception
that
maybe
the
promise
object
won't
be
available.
So
the
so.
What
I
would
really
like
to
do
is
the
sooner
we
can
get
to
a
point
where
we
can
make
native
modules
not
break
context.
I,
think
the
better
is
going
to
be
from
the
point
of
view
of
not
having
to
go
monkey
patch.
H
E
If
so,
there
is
one
particular
thing
that
may
happen,
which
is
if
we
change
promise
hooks,
and
we
were
discussing
that.
Actually,
the
promise
and
probably
the
resolve
value
rather
than
the
promise
would
be
available,
then
that
that's
like
that's
a
breaking
change
to
a
thing
hooks,
it's
experimental,
so
we
can
get
away
with
it
and
it's
probably
doesn't
affect
too
much
because
I
think
there's
only
a
few
specialist
users
I
think
zones,
Jase
was
Richard
who
actually
are
even
interested
in
this.
E
C
E
A
J
Amassing
coxa
and
monkey-patching.
We
are
currently
doing
a
little
survey
about
the
p-values
APM's
and
compare
them
to
guessing
hoops
and
so
on.
We
have
gathered
the
data
we
are
actually
in
the
process
of
interpreting
the
stuff.
Okay,
so
I
just
wanted
to
keep
you
posted
that
I
said
we
will
be
going
to
look
into
this
and
we
are
it's
just
that
it's
now,
it's
not
ready
yet
to
be
presented.
I
would
share
a
draft.
J
A
C
A
That's
one
of
the
topics
for
a
deep
dive.
That's
the
next
thing
on
the
agenda.
We
we
haven't
made
I,
don't
think,
there's
been
any
progress,
I,
don't
think
marks
done.
Anything
I
haven't
done
anything
with
sort
of
this.
This
idea
of,
like
the
logical
model
and
I
think
there's
certainly
some
stuff
to
be
done
in
terms
of
what
async
folks
is
producing,
and
you
know
what
you
would
see
in
this
ideological
model
right
I.
Think
a
CMOS
produces
a
lot
of
events,
because
it's
firing
events
more
different
lifecycle.
A
So
that
is
an
exercise
it
needs
to
happen.
I
think
the
next
step
for
that
that
I'd
like
to
do
exactly
know
what
I'm
going
to
find
time
but
I
wanted
to
do.
Is
monkey
patch
things
to
the
point
that
we
could
produce
this
sort
of
logical
model
for
monkey
patching
and
then
see
if
that
stuff
starts
making
sense
to
people
and
then
juxtapose.
A
You
know
that
with
the
logical
model
that
gets
produced
via
you
know,
async
book,
so
that
was
nice
right
if
you
were
to
say,
like
hey,
we're,
gonna,
listen,
a
it
to
these
names
in
cooks,
events
and
we're
gonna
produce
these
things
that
we
talk
about
in
an
illogical
model.
What
is
that
data
set
look
like
and
is
that
the
right
side
of
dated
a
reason
about
async
call
flow
versus
this
sort
of
you.
A
A
What's
the
right
word,
I
mean
there's
there's
just
like
a
lot
of
you
know
a
lot
of
things
happening
in
in
the
data
set
that
are,
you
know
a
result
of
the
event.
They
sync
hooks
events
firing
around
the
life
cycles
of
you
know
these
resources
right
that
don't
necessarily
relate
to
the
async
call
flow
that
the
user
is
kind
of
expecting
when
they're
reading
a
block
of
code
right
and
that.
A
A
A
If
we
can
do
some
of
the
this,
you
know
the
monkey-patching
thing
and
the
monkey-patching
thing
can
generate
a
more
idealized
form
of
you
know
it's
a
set
of
events
that
model
the
asynchronous
code
flow
and
then
that
ends
up
being
more
intuitive
to
to
the
user
right,
then
that's
something
that
we
should
be
sort
of
considering
or
looking
at
on.
Now.
A
It
may
be
the
case
that
you
know
we
go
off
when
we
month
you
patch
some
stuff.
When
we
generate
this
idealized.
You
know
stream
of
events
and
it's
worthless.
It's
not.
It
doesn't
accurately
reflect
what's
what's
happening
right,
which
is
something
that
we
need
to
know
about,
but
I
kind
of
feel
like
what
we
need
to
do
is
we
need
to
be
able
to
say,
like
hey,
here's,
a
program,
here's
one
view
of
an
event
stream.
A
C
It
so
there's
two
like
separate
issues
in
that
that
I
like
to
see
being
maintained
separately.
One
is:
does
they
see
who
satisfied
like
the
mathematical
model,
and
for
that
you
don't
really
need
it
to
be
inseparable.
You
just
need,
like
the
the
context,
be
preserves
and
then
there's.
The
other
issue
is
like
is
Asian
groups
interpretive
all.
A
Yes,
yes,
those
are
two
distinct
things
and
I
think
with
respect
to
the
former
that
is.
Does
it
conform
to
the
mathematical
model
that
you
know
we've
been
talking
about
the
open
question,
I
think
the
open
question
there
is
there's
this
notion
of
the
causal
context
that
gets
raised
when
a
promise
is
resolved
and
I.
Don't
know
that
that
is
satisfied
by
a
current
set
of
async
books.
If
you
guys
I,
don't
know
if
promise
books
like
that
is.
A
A
C
F
I'm,
like
I'm
working
on
that
as
we
speak,
I've
been
doing
it
as
we
all
have
been
talking
the
API.
There
is
basically
just
you
know,
changing
the
tracing
agents
so
that
it
will
turn
on
automatically
if
the
categories
are
set,
so
the
trace,
trace,
Evette
enabled
flag
will
no
longer
be
necessary
and
then,
if
the
API
is
set,
it
will
basically
start
and
stop
the
tracer
and
enable
the
new
the
new
category
so
on
the
same
file.
So
it's
ongoing
getting
closer
getting
it
done.
A
F
They're
not
sure
about
the
specific
checkboxes,
but
one
of
the
other
things
that
I've
been
looking
at
is
kind
of
revamping
slightly
vamp
of
the
way
our
categories
are
set
currently
within
core,
for
instance,
if
you
enable
the
category
just
node
versus
node
dot
async
folks,
what
do
you
get
kind
of
make
it
more
of
a
hierarchical
namespace?
So
if
you
say
one
list
of
the
category
node
you
get
everything
node
will
output.
If
you
want
to
just
listen
to
a
sink,
looks
he
would
do
the
node,
mate,
nice
and
coax.
F
So
there
is
no
there's
a
PR
out
there.
It's
a
couple
of
macros
that
will
build
those
categories
out
for
us.
Our
key
thing,
if
you
can
go,
take
a
look
at
that
I'll.
Send
you
the
link,
it's
really
simple!
So
there's
a
few
things
like
that
and
then
just
going
through
an
enabling
more
trace
event.
Output,
like
I,
have
a
PR
that
it
enables
DNS
trace
events
just
kind
of
playing
with
it.
B
And
I
guess
on
number
82,
which
is
adding
trace
points
so
chin
working
on
the
IBM
team
has
tried
to
put
together
a
matrix
that
showed
where
we
have
them
and
don't
have
them
and
he
should
be
put
I.
Think
pasting
it
into
that
issue
fairly
soon
as
a
starting
point
for
like
how
do
we
start
adding
additional
trace
points
because
he
was
gonna,
help
work
on
that
yeah.
F
There's
on
one
point
on
that
is:
there's
lots
of
places.
We
can
add
trace
points.
It's
you
know
how
useful
are
those
going
to
be
to
user.
You
know
is
it
is
it?
Is
it
actually
going
to
be
able
to
be
interpreted
in
any
way?
That's
useful,
Yeah
right
and
that's
that
that's
difficult
thing.
I'm
going
through
with
HP,
for
instance,
there
are
sites
identified
three
or
four
different
ways.
I
can
go
through
an
instrument
for
trace
and
it's
completely
up
in
the
air
where
you
know
which
one
is
actually
going
to
be.
B
So
what
what
are
the
thing
doing
now
is
looking
for
what
craze
points
are
available
like
that
you
can
enable
in
Java,
then,
just
as
this
is
an
example
of
what
was
useful
in
another
language
and.
F
F
It's
only
called
in
certain,
and
you
know
you
know
if,
if
it's
actually
passed,
but
it's
kind
of
difficult,
you
know
in
in
every
case,
to
do
that
I
mean
it
would
be
excellent
if
we
could
find
a
better
way,
but
we
have
to
work
with
to
be
a
team
in
order
to
do
that,
so
I'm,
just
building
that
JSON
string
it's
just
kind
of
complicated.
Sometimes
you
could
get
kind
of
expensive,
I.
Think.
F
F
Lt
t
ND
has
been
removed,
it
was
big.
It's
been
broken
for
over
a
year
anyway,
so
that
was
that
was
just
removed
DTrace.
I
floated
the
idea
just
just
just
to
the
tribal
and
floated
the
idea
of
like
hey
what,
if
we
remove
DTrace
and
had
people
just
go
into
a
panic
going,
you
know
screaming
yelling,
it
was
funny,
but
it
was
what
I
expected.
You
know
folks
want
to
keep
the
that
I've
got
the
dynamic
probe
capability
in
there
now
a
DTrace
coming
to
linux
soon,
with
the
changing
license.
F
If
it
you
know,
it
definitely
makes
sense,
we
still
need
to
figure
out
kind
of
how
to
align
those.
The
number
of
DTrace
probes
we
have
currently
are
very
limited
right
now.
We
could
actually
make
every
trace
event
emit
a
you
know:
dtrace
probe,
that's
something
we
could.
We
could
look
at
doing
it.
Would
he
actually
expand
the
usefulness
of.
E
The
feedback
that
they
were
some
people
who
wanted
interest
rate
this,
but
all
of
them
were
from
the
company
I
really
have
is
that
I
I
think
I
I,
firstly
and
I.
My
impression
is
wrong.
I
personally
haven't
seen
too
much
ownership
of
that
core
or
active
upkeep.
So
if
more
trace
points
are
interesting,
I
would
much
rather
have
see
the
decrease
people
caught.
You
buuuut,
something
there
I
rather
effectively
trying
to
go
address.
That
use
is
that
I'm,
not
over
I
presume,
not
sure
I
know
enough
about
dtrace
to
properly
address
that
you
stood.
F
Now
there
is
actually
a
another
part
of
the
use
case
is
bility
to
enable
the
tracing
on
a
live
instance
without
a
start-stop,
but
with
tracing
enabled,
which
is
why
I'm
setting
it
where
you
know
working
on
the
PR
now
it'll
be
a
built-in
enabled
v8
trace
events
dynamically,
but
the
other
part
of
that
is
being
able
to
consume
the
data
dynamically.
All
right,
then,
right
now
we're
just
writing
it
out
to
a
file.
F
E
F
Gonna
try
to
look
at
it,
I'm,
not
sure
he
gets
it.
The
other.
The
other
aspect
of
this
too,
when
it
comes
to
that
v8,
trace
of
a
format
it
uses
a
route
object
with
the
trace
event
property
in
an
array.
If
that
file
format
was
actually
something
like
a
line,
delimited
JSON,
it
would
be
much
easier
to
consume
in
a
streaming
way
and
if
we
had
these
things,
basically
it's
a
long
way
of
saying.
If
we
had
these
things,
we
could
probably
cover
a
majority
of
the
dtrace
use
cases
using
v8
race
events.
F
There
are
tools
like
if
you
look
I
think
it's
called
eight
each
piece
OOP,
that
there
are
a
couple
of
tools
that
are
basically
DTrace
one-liners,
that
that
look
specifically
for
node
Pro
points
and
a
fee
Snoke,
for
instance,
will
output
a
line
for
every
incoming
a
superior
cost.
It'll
give
you
the
method,
will
give
you
the
the
path.
What
was
requested
in
a
timestamp.
F
A
A
F
C
A
J
Would
like
to
add
one
thing
to
what
you
just
said:
all
of
these
isn't
absolutely
not
documented
in
our
base.
Okay,
like
it's
I,
want
to
I
want
to
stress
this
fact,
because
it's
a
to
me
if
something
is
now
documented
and
not
it
can
be
easily
used
by
our
massive
user
base,
is
kind
of
useless,
okay
and
I'm.
Sorry
to
say
this,
but
this
is
the
hard
truth.
No.
F
B
F
F
F
B
B
That
that
wouldn't
I'm,
just
trying
to
see
like
can
we
make
most
of
the
people
happy
by
saying
you
know
for
all
the
trace
points
where
we
can
like
the
regular.
You
know
the
non
dynamic
ones.
You
basically
say
well
for
so
nos
the
the
macros
will
resolve
in
2d
trace
things.
Otherwise,
all
other
platforms
they
just
go
to
the
VA
trace
of
an
infrastructure
and
the
dynamic
ones.
Will
sorry,
but
you
don't
get
those
on
on
son
AHS
would
would
the
the
people
who
are
using
D
trace
a
yeah?
F
B
And
there's
no
way
of
like
the
existing
ones
that
are
there
if
they're
useful,
it
would
seem
like
if
we
replace
them
with
a
macro.
We
get
a
savvy
trace
event
in
the
same
place,
another
platform
and
a
one
that
that
sounds
like
a
good
thing
and
then
it
would
still
be
sort
of
a
semi,
consistent
story.
Yeah.
A
E
James,
you
mentioned
the
the
root
object.
I
think
it
as
far
as
I
understand
it
and
I
reckon
to
protect
the
the
about
tracing
the
do
support
partially
truncating
solves
so,
in
other
words,
is
that
if
it's
not
properly
structured
ease
onto
some
tolerance
for
tolerance
in
those
tools,
yeah,
so
things
like
that
might
be
possible
and
we
can
work
towards.
Is
it
providing
us
to
apply.
F
I
think
that's
largely
and
then
on
the
trace
event,
stuff
I,
you
know
I'm
still
gonna
be
pushing
or
you
know,
kind
of
figuring
out
the
the
dtrace
stuff
like
I
said:
LT
TNG
was
just
removed.
We
still
have
the
ECW
support
and
dtrace
support
in
there,
and
it
would
be.
It
would
be
nice
to
figure
that
stuff
out.
It's
just
again.
It's
really
hard
to
figure
out.
How
useful
is
this.
A
K
A
A
A
B
F
K
F
F
Yeah,
the
only
the
only
other
thing
with
the
tracing
that
I
would
say
is
still
an
open
discussion
is
whether
or
not
it
makes
sense
to
have
that
a
tracing
intrinsic
function
and
JavaScript
that
can
be
optimized
out
of
tracings
to
say
currently
disabled.
There
are
some
complexities
there
when
we
have
a
way
that
we
can.
You
know
like
right
now
understand
it.
A
function
where
we
can
emit
trace.
Events
from
JavaScript
is
a
one
of
the
internal
bindings
in
node.
F
We
can
use
that,
but
I
prefer
being
able
to
instrument
the
JavaScript
in
a
way.
This
is.
This
is
little
cost
as
possible,
all
right,
the
one
complexity
there
is.
If
we
are
dynamically
turning
tracing
on
and
off
it
may
be
difficult
to
actually
get
the
right
optimization
on
that,
so
it
may
not
even
be
worth
it.