►
From YouTube: 2020-07-15 Diagnostics Deep Dive WG meeting
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
C
A
C
So
this
could
be
manifested
in
the
form
of
probably
a
return
value
from
a
function
which
is
responsible
for
the
computation
or
it
could
be
like
manifested
as
a
untie
lead
database.
At
the
end
of
the
day,
when
you
hold
it
a
DB
where
these
numbers
or
numbers
are
sitting
as
a
result
of
the
computation
is
not
matching.
A
A
A
C
A
C
C
A
A
A
C
So
when
we
talk
about
this
is
not
what
developer
thought
it
was
can
be
manifested
as
a
an
attempt
to
perform
a
wrong
invocation,
for
example
the
receiver
object,
or
that
this
point
is
wrong,
which
means,
if
you
invoke
a
function
on
that
object,
the
function
doesn't
exist.
Actually,
so
most
probably
it
throws
an
exception.
Saying
that
dot
say
foo
is
foo
is
not
a
valid
property
of
this
the
object
or
whatever
I'm
just
wondering.
C
A
A
C
Yes,
there
are
a
bunch
of
a
class
of
issues
related
to
child
process
I'm
just
trying
to
see
how
do
we
abstract
into
one
statement,
so
the
common
issues
with
the
child
process
is
one
is
unexpected
exit
code
or
unexpected
termination
of
the
child
process.
The
second
Clause
of
issue
is
the
piping
or
the
internal
plumbing
between
the
parent
and
the
child
is
not
proper,
by
which
the
the
IPC
channel
is
not
functioning
properly.
A
C
How
do
we
see?
It
is
mostly
the
parent
and
child
work
in
a
master/slave
or
an
in
a
coordinated
manner,
where
master
would
be
giving
some
command
to
the
child
child
execute
and
get
returned
back.
The
the
data
or
the
response
so
based
on
the
data
passed,
the
success
or
failure
of
the
child
is
asserted.
Mostly,
there
will
be
missing
data
on
either
side
that
that's
how
we
see
that
the
idea
channel
is
either
corrupted
or
the
simplistic
data.
C
These
are
not
neither
termed
as
limitations
nor
fixed,
so
what
type
of
the
issues
could
be
coming
through
that
and
then
another
set
of
issues
could
be
misuse
of
api's,
for
example,
feeding
a
FD
I've,
seen
program
of
passing
an
FD
in
place
of
one
of
the
IPC
endpoint,
whereas
the
FD
itself
is
not
initialized
or
it's
not
not
a
valid
FD
and
expecting
the
IPC
channel
to
make
it
valid
and
work
which
is
not.
That
is
not
how
the
API
works.
The
APA
either
creates
the
channel
by
itself.
C
B
Was
wondering
like,
as
I
was
listening
and
reading
some
of
the
things
you
have
they're
like
unexpected
control
flow?
Is
that,
like
a
parent
to
these,
where
you
know
we
we,
we
expected
the
execution
to
follow
a
certain
path,
but
for
some
reason
that
path
isn't
followed
and
that
could
be
because
something
went
wrong
or
we
use
the
API
wrong
and
therefore,
like
we
didn't,
you
know
we
expected
a
callback
to
happen,
but
it
didn't
happen
because
we
didn't
do
the
right
thing.
A
B
C
Yeah,
as
Matias
said,
some
of
the
use
cases
are
concrete
instances
of
the
abstract
use
case,
which
you
mentioned,
but
at
the
same
time,
I
also
recognize.
That
scenario
exists.
Independent
of
these
discrete
use
cases,
for
example,
we
can
see
several
issues
of
that
kindly
help
repo
where
novice
users
come
and
say,
I
have
this
code,
but
it
is
not
X.
C
This
line
of
code
is
not
executed
or
it's
sexy
after
this
line,
which
is
not
expected
kind
of
thing,
but
that
Clause
of
his
shoes
are
mostly
reported
by
novice
users
and
it's
a
it's
a
matter
of
explaining
and
clarifying,
not
sure
whether
such
scenarios
would
be
documented
here
or
only
production
issues
come
in.
The
purview
of
this
are.
B
C
B
Yeah
okay
I
got
I
was
like
the
I
was
thinking
like
missing
callbacks,
which
you
think
are
in
is
just
an
example
of
I
didn't
get
the
flow
that
I
expected
and
I
was
just
thinking
along
those
lines,
because
then
that
leads
me
to
think
like
well.
How
would
you
do
this
right
and
like
say,
for
example,
the
misuse
of
api's.
B
I'm
just
wondering
like
how
do
you?
How
do
you
debug
that
but
I
kind
of
understand
that
if,
if
you
misuse
the
API-
and
it
doesn't
result
in
the
flow
that
you
expected
you
could
there
can
be
tools
to
help
you
debug
well,
what's
the
actual
flow
and
then
understanding
that
you
might
realize
what
you
did
wrong
right,
yeah.
C
Yeah
or
on
that
lines
we
should,
we
could
also
have
an
expected
sequence:
I
mean
as
a
as
a
complement
of
unexpected
control
flow,
unexpected
chronology
of
the
code.
This
mostly
happens
with
timer
events
like
set
set
immediate
set
timeout
set
interval
customer
says
that
I
have
set
a
timeout
for
500
milliseconds,
but
it
it
fired
up
the
five
seconds.
B
You're
right
because
the
timing
is
often
just
as
it
may
say,
okay
I
expected
these
things
to
happen,
but
they
didn't
happen
in
the
right
order.
I,
don't
know
whether
that's
like
again
like
underflow
or
separate
or
whatever,
but
it's
an
it's.
It's
definitely
in
a
separate
thing
that
we
would
want
to
help
like
there
might
be
a
different
way
to
figure
out.
What's
going
on
on
that
front,
so
it's
important
as
a
separate
category.
A
A
C
We
thought
telling
anything
about
the
actual
instance
of
time
in
which
these
things
can
happen,
including
the
set
timeout
and
set
interval
API.
They
say,
if
you
say,
set
timeout
on
X
millisecond.
The
function
is
guaranteed
to
be
called
after
X
millisecond,
not
exactly
upon
reaching
500
milliseconds.
C
C
Was
that
I
mean
he?
Finally,
on
the
workload
in
such
a
manner
that
the
G
C's
are
happening
at
fine-grained
intervals
and
when
he
migrated
or
when
he
changed
the
workload
to
the
slightest,
then
the
GC
pattern
has
changed.
He
treat
it
as
an
unexpected
behavior
I'm,
not
sure
these
are
definitely
virtual
machine.
Specific
internal
behavioral
changes,
I
think.
C
B
It's
like
my
take
is:
if
it's
not
like
it,
I
guess
it
there
there
might
be
a
concern.
That's
it
is
affecting
your
app
and
you
just
don't
know
but
like
in
general.
I
think
the
contract
is,
is
that
GC
can
do
whatever
it
wants,
and
if
it's
not
affecting
your
app
like
the
implementer,
might
decide
that
hey
I'm
gonna.
Do
it
more
frequently
because
that
means
you
won't
see
long
pauses
or
something,
and
that
should
be
okay,
yep.
C
Yeah
heck
a
new
pattern,
especially
with
the
cloud
native
deployments,
is
that
we
have
tracing
and
monitoring
capability
inbuilt
into
the
services,
which
means
you
always
have
the
profile
data
right,
including
CPU
profile,
and
things
like
that.
So
without
any
reason
you
could
be
actually
looking
at
the
profile
data
and
get
alarmed
by
seeing
near
hundred
percent
CPU
right.
We
have
seen
a
couple
of
times
complain:
people
complaining
that
my
CPU
is
around
100%
in
a
place
debug.
C
A
A
A
A
B
A
B
A
B
I
guess
I,
you
know
what
I
could
see
is
like
hey,
you
get
an
unexpected
ordering
of
things
or
flow,
even
and
then
it
could
be
okay.
Well,
the
first
thing
like
underneath
that
there's
different
potential
causes
one
which
is
like
hey
the
internal
behavior
change.
So
did
you
change
node
versions,
right
and
then
other
you
know,
you
know,
that's
one
caused.
The
other
causes
might
be
the
you
know
incorrect
assumptions
or
using
the
API
is
incorrectly
or
there's
a
whole
bunch
of
you
know.
B
But
I
don't
know
like
into
you're
right
that
the
debugging
for
like
this,
you
know,
is
different,
but
it
may
be
that
you
always
want
to
start
with
hey
things
aren't
going
in
the
order
you
expected.
The
first
thing
is
like
is
that
because
you
changed
node
versions,
if
so
go
down
this
hey,
there
were
changes
in
the
behavior
path
to
see.
If
you
can
rule
that
at
first
right,
whereas
if
you
didn't
change
anything
like,
if
you
didn't
change
node,
then
it's
down
the
other
path,
which
is
the
like.
A
B
A
B
A
A
B
B
A
B
A
B
A
B
The
other
thing
that
came
to
mind-
maybe
tracing,
is
about
flow
and
logging
is
a
more
about
like
things
that
went
wrong
or
things
that
have
completed
or
you
know,
I
could
see
tracing
B.
This
happened,
and
this
happened,
and
this
happened
without
actually
having
an
opinion
on
whether
it
was
a
good
thing
or
a
bad
thing,
and
logging
is
intended
to
give
you
more
information
about
this
good
thing
happened,
or
this
bad
thing
happened,
I,
guess
or
whatever
something
in
between
right.
A
B
Right
it,
the
tracing,
hopefully,
is
in
the
context
of
what
happened
before
or
after
versus.
Slogging
is
just
I'm
telling
you
something
at
this
time.