►
From YouTube: Node.js Diagnostics WG Meeting - 2019-03-20
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
B
B
A
B
B
C
This
wasn't
me
close
to
you,
though
right
it
can
be
close,
but
I
think
it
would
be
nice
to
maybe
extract
these
comments
with
you
know
there
was
some
sorting
through
some
google
documents,
with
some
action
items
and
stuff
like
that.
Maybe
I'm
not
sure
if
we've
done
this
before,
but
would
it
make
sense
a
sense
to
kind
of
gather
that
all
together
in
a
markdown
file
from
where
or
or
is
it
okay
to
just
leave
it
in
a
closed
issue.
D
C
C
A
A
C
B
Could
just
have
summits
if
we
continue
to
plan
that
you
know
I've
had
to
continue
to
plan
ahead,
or
it's
probably
not
bad
to
have
it
in
there
yeah
all
right,
okay,
so
you're
gonna
put
in
the
I
pasted
the
link
to
the
action
so
I
think
if
we
have
the
actions
and
then
the
videos
and
whatever
else
you
think,
is
useful,
those
that's
the
key
stuff
yeah.
Oh,
maybe
a
couple
of
the
links
like
you
said
to
the
other
Doc's
that
get
started
working
as
well,
so
yeah,
okay,
awesome.
A
B
B
The
next
things
was
to
continue
on
the
v8,
the
torah'
fication
of
the
objects
in
in
in
v8,
so
that
then,
that
can
I
should
be
used
to
generate
the
yellow,
node
metadata,
as
well
I
think
from
the
different
options,
that's
the
one
that
seemed
to
be
the
most
feasible
and
basically
it'll,
be
a
matter
of
pushing
that
one
forward
and
seeing
what
we
can
do
with
that
data.
Okay,
best.
B
B
We
also
have
the
action
which
I'll
work
on
which
you
reach
to
get
a
draft
of
the
memory
best
practice.
We
agreed
in
the
summit
that
we
would
bring.
You
know,
work
to
bring
heap
dump
or
something
equivalent
in
the
core
which
you've
probably
already
seen,
there's
been.
Some
action
on
James
has
a
PR
first
PR,
this
landed
I
think
we
still
need
a
second
PR
which
actually
adds
triggers
to
be
able
to
trigger
them
without
having
to
like
write
code
or
anything,
but
so
there's
already
progress
on
that.
B
The
other
thing
we
asked
there
was
consensus
on
in
the
people
there
is.
We
should
bring
the
the
heap
sampler
into
core
and
Ally's
gonna
help
with
the
draft
in
terms
of
the
language
we
should
have
in
there
for
the
best
practice
of
you
know,
basically
explaining
when
you
would
use
the
the
the
heap
dumbs
when
you
would
use
the
memory
profiler
and
you
know
how
to
use
those
tools
to
debug
memory
issues.
Awesome.
D
B
C
B
You
know
we
we
had
a.
We
had
the
list
up
on
the
screen
that
showed
the
like
the
five
or
six
best
practices
we
were
going
to
work
on
and
that's
where
Peter
had
commented
that
you
know
they
should
be.
Some
of
them
should
be
more
specific
and
he
was
going
to
jump
into
that.
We
hadn't
started
to
talk
about
the
memory,
one
which
was
the
first
on
the
list
and-
and
we
spent
most
of
the
time
talking
about
heap'd
umph
in
core
and
memory
profiler,
and
that
kind
of
stuff.
C
C
We
I'm
not
sure
if
we
talked
specifically
about
the
tracking
issue
per
se,
but
we
did
talk
about
what
it
would
take
to
make
Asian
cooks
a
non-experimental
and
we
kind
of
diverted
into
saying
okay.
What
is
it
actually
that
most
people
need,
and
most
people
actually
need
continues,
continues
local
storage,
and
so
we
actually
kind
of
changed
the
discussion.
A
little
bit
talked
about
hi.
We.
If
we
should
get
CLS
into
core,
because
then
we
could
have
an
API
that
was
easier
to
reason
about.
C
There
was
higher
level
than
Asian
cooks
and
that
were
easier
to
land
as
as
as
non-experimental
as
stable,
even
though
the
underlying
asian
cooks
api.
That
obviously
would
use
would
still
be
experimental.
That
meant
we
could
get
a
lot
of
people
up
to
to
use
the
CLS
part
and
less
people
using
an
experimental
API,
which
would
mean
it
it
might
well,
in
theory
at
least,
we
could
then
change
the
experimental
API
behind
the
scenes
and
still
keep
the
same
CLS
API
that
was
like
that
was
like
the
gist
of
that
part
of
it.
C
B
I
mean
I'll
agree
with
your
interpretation.
I
think
there
were
a
few
people
who
really
want
to
get
it
out
of
experimental
anyway.
So
there
is
one
of
the
docs
that's
opened
is
around
working
on
some
of
the
performance
aspects,
so
I
think
Benedict
and
Matteo
are
pushing
on
that
to
try
and
remove
that
as
one
of
the
blockers,
but
I
I'm
in
the
same
mindset
of
view
is
that
I
don't
know
that
we've
closed
on
thinking
that
we
have
the
right
API
and
the
discussion
on
CLS
was
all
around
well.
B
A
B
A
Other
things
going
on
I
talked
to
bill
and
one
of
our
guys
Paolo,
who
was
there
and
I,
talked
to
Paul
a
little
bit
about
you
know.
Can
we
go
and
take
some
of
those
ideas
and
get
them
implemented
on
b8
and
just
kind
of
start
skiing?
What
that
conversation
looks
like
so
I,
don't
know
it's.
You
know,
that's
gonna
get
a
lot
of
traction
yeah
that.
A
I
mean
I
yeah,
unfortunately
I
just
a
very
limited
time
to
sink
into
this
at
the
moment
and
I,
don't
know
when
that's
gonna,
clear
up
and
I
think
the
other
aspect
to
it
is
it's
kind
of
like
a
wonky,
complicated
topic,
and
you
know
it's
like
you,
try
and
explain
things
or
trying
you
know
like
attraction
and
it
just
like
you
know
either
people's
eyes
glaze
over
or
you
know
it's
it's.
It
feels
hard
right
and
so.
B
A
And
I
need
to
think
with
them
about
where
their
time
is
and
I
do
think
that
they
have
some
some
cycles
to
go
off
and
and
push
on
some
related
type
thing.
So
right,
I
need
to
see
where
that's
at,
but
a
yeah
dude.
It's
like
you
know
ideally
ideal
world.
It's
like
you
know.
We
we
tack
this.
Like
you
know,
we
have
people
hitting
this
from
the
spec
level
and
hitting
it
at
the
implementation
level
right
and
you
know,
we'd
surface
something
out
that
would
you
know,
address
I.
Think
the
you
know
the
noted.
A
B
Cuz,
it
was
even
like
you
know:
the
Matteo
showed
bubble
prof.
and,
like
some
of
his
examples
were
like
you
know,
you
see
these
things
that
go
off
to
the
side
and
come
back,
and
you
know
that
was
I.
Think
even
at
that
point
he
was
kind
of
saying
well
yeah
this.
This
isn't
that
useful,
because-
and
it's
probably
because
it's
showing
lower
level
details
of
what's
going
on
with
the
promises,
as
opposed
to
what
you're
thinking
should
be
happening
on
the
ASIC
level,
yeah.
A
A
A
Sure
well,
I'll
touch
base
with
Bill
I
think
he's
out
on
vacation
right
now,
but
I
think
he's
coming
back
in
a
week
or
something
so
I
make
sure
that
it
sort
of
to
sync
with
him
periodically
and
try
and
push
them
and
making
some
progress
here.
B
B
Mean
I
think
the
yeah
and
the
the
as
was
mentioned.
The
other
thing
is
that
there
is
now
a
CLS
API,
a
PR
for
a
CLS
API
in
core.
So
that's
sort
of
all
related
to
this,
and
people
are
interested
in
this
part,
should
also
be
looking
and
reviewing
that
to
make
sure
it
doesn't.
We
don't
suffer
a
similar
problem
with
having
the
you
know,
an
API
that
doesn't
quite
match.
Yeah.
A
A
A
B
Cases
where
it's
gonna
follow
the
wrong
context.
We
should
probably
try
and
get
those
test
cases
capture
right
like
so,
if
you,
if
you
kind
of,
have
a
feeling
from
the
work
you've
done
on
the
asynchronous
like.
If
you
do
this
this
and
this,
the
current
implementations
will
probably
give
you
the
wrong
thing.
It
would
be
really
good
to
get
that
int
get
that
so
that
ends
up
being
a
test
case
for
the
CLS
stuff.
Yes,.
A
A
Think
you're
at
risk
from
you
know
somebody
going
in
and
introducing
you
know,
I
don't
know
like
introducing
a
timer
inside
of
their
implementation
of
you
know
like
the
socket
connection,
logic
right
and
it
throwing
things
off
in
certain
ways
that
people
didn't
expect
and
I.
Think
that's
kind
of
the
challenge
right
is
that
it's
exposing
this
stuff
in
a
low-level
way
that
you
know
makes
it
brittle
with
respect
to
low-level
underlying
changes
right.
But
yes,
absolutely.
If
there's
cases
that
people
identify
there
should
be
tests
to
ensure
that
the
right
thing
happens.
C
Yeah
I
agree
that
it's
Stephen
and
I
way
we
talk
about
that.
It
would
probably
make
sense,
based
on
this
CNS
PR,
to
make
at
fault
of
the
elastic
APM
agent,
because
we
have
a
very
comprehensive
test.
We
all
it
uses
that
that
base
branch
of
that
PR
fits
us
and
then
swap
out
our
own
CLS.
We
have
it
and
use
that
and
then
see
if
we
get
the
same
test
result.
Yeah.
A
Likewise,
for
other
people
that
are
doing
because
I
know
there's
an
existing
CLS
implementation
out
there
and
thought
right
like
there's
been
one
around
for
years,
I,
don't
know
what
the
gaps
are
is
compromise,
native
promises
and
async/await
are
probably
gaps
and
what
that
support,
I
haven't
looked
at
it
years.
Actually,
what's
it
what's
the
idea
with
the
current
there's
a
package
for
CLS
out
there?
This
would
just
supersede
that.
B
C
And
there's
also
just
that
the
dance
game
right
now
is
very
hard
to
get
an
overview
off.
There
were
so
many
different
implementations
that
and
folks
of
existing
implementations,
that's
stalled.
So
there's
the
half,
the
current
continuation,
local
storage,
where
that
results
to
patching
everything
and
not
using
Asian
cooks,
and
there
is
a
fork
of
that
that
is
using
Asian
cooks
and
then
that
Falk
is
that
she's
are
also
falling
back.
If
it's
running
on
no
D
version
of
no
prior
to
notate,
it's
not
actually
falling
back
to
patching
things.
C
It's
falling
back
to
using
async
wrap.
It
so
use
its
process
that
binding
to
use
async
Ram.
So
it's
yeah,
not
nice,
and
there
is-
and
there
was
on
top
of
that-
there
is
a
lot
of
consistencies
and
how
these
different
implementations
work.
When
it
comes
to
well,
do
we
bind
to
to
promise
them
or
do
we
bind
to
whenever
the
promise
was
was
created?
You
know
what
in
context
they
bound
to
and
stuff
like
that
and
and
if
we
can
kind
of
say,
okay
there's
this
one
way
to
do
it
inside
no
more
I.
B
C
B
I
think
it's
called
okay
yep.
This
is
the
one
I'm
just
gonna
paste
it
into
the
like
I've
made
a
few
comments
and
that
it
it
seems
different
than
continuous
continuation,
local
storage
in
a
few
different
ways
and
anyway,
I
think
it
just
requires
a
fair
amount
of
discussion.
But
it's
good
to
have
that
discussion
and
start
to
experiment
and
stuff
like
that.
Great
thanks.
D
Lee's,
not
sure,
but
I
I,
don't
think
is
in
the
update
for
that
I
guess.
Profeta
would
be
under
this,
and
over
the
last
week,
I've
been
talking
to
the
people
who
work
on
the
photo,
and
so
I'm
got
some
more
clarity
on
how
it
fits
in
the
note.
I
realized
that
some
that
I
didn't
have
at
the
presentation
in
Munich.
D
So
if
there's
still
like
outstanding
concerns
or
anything
you
feel
free
to
post
in
the
issue,
one
thing
in
particular
is
that
there
I
mentioned
protobuf
as
a
dependency
turns
out
its
they're
trying
to
make
it.
So
it's
not
a
run
on
dependency,
so
it
wouldn't
actually
be
part
of
the
note
binary,
which
would
maybe
help
with
the
undersized
and
also
just
the
compilation
stepped
in
general.
D
E
I
was
kind
of
curious
after
seeing
James
PR
on
the
heap
snapshot
and
nerdcore,
one
thing
is
I
think
you
can
do
that
New
Zealand
now
with
the
inspector
module,
however,
having
it
as
a
separate
function
is
nice,
because
then
you
could
actually
use
it
while
you're,
debugging
and
I
think
if
you're
debugging,
then
you
can't
use
inspector.
So
so
it's
actually
not
bad
to
have
that
before,
but
there
there
was
a
comment
left
in
that
PR
I
think
asked
kind
of
generally
asking
about
the
whole
thing,
with
heap
snapshots
being
a
huge
JSON
wad.
D
B
First
thing
I
did
want
to
throw
in
at
the
beginning
is
the
there
was
it
was
mentioned.
You
could
do
it
through
the
inspector,
but
there
seemed
to
be
consensus
that
that's
not
something
you
can
really
do
in
production.
So
that's
was
one
of
the
other
reasons
like
you
want
something
you
can
actually
generate
in
in
production.
That's
why
I
was
saying:
there's
gonna
be
like
a
second
PR
that
adds
like
some
external
triggers
through
a
signal
or
something
like
that
and
yeah
I
mean
we've.
B
Had
the
discussion
way
back
like
years
ago
about
saying:
could
we
come
up
with
a
new
format
or
even
having
you
know,
being
able
to
generate
a
heap
dump
from
a
core
dump?
And
there
was
some
discussion
on
that?
It
just
never
really
went
anywhere,
I.
Think
at
the
summit
there
was
a
little
bit
of
a
discussion
that
you
know.
Maybe
if
there's
progress
on
the
DSL
or
the
Torah
fication
of
the
objects.
E
B
E
E
So
they
can
get
quite
large
and
then
you
know
we
were
reading
them
a
server
that
became
a
problem
had
actually
for
the
process
to
read
them,
so
we
didn't
kill
our
own
server
so
having
some
other
formats
other
than
JSON.
That
doesn't
require
a
huge
one
time.
Parse
would
be
super
interesting,
I
think,
but
that's
about
as
far
as
I
know,
anybody's
done
much
spanking.