►
From YouTube: 2020-03-12-Node.js N-API Team 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
A
A
Okay,
so
top
of
the
list
was
renaming
an
api
to
something
more
appropriate
and
descriptive.
I
I
think
jim
you've
been
pushing
a
number
of
those
forwards.
Do
you
have
an
update
there.
B
I
don't
I've.
I've
not
had
a
lot
of
spare
cycles
the
last
couple
weeks.
The
one
thing
my
next
priority
is
the
what
we
call
the
nipi
resource
the
tutorial
website
right
for
some
reason
that
did
not
get
updated
so
that
that's
the
next
on
my
list.
Okay,
should.
B
Let's
add
it
to
that
list,
maybe
above
the
above
the
build
tools,
heading
okay,
that
would
be
good.
That's
a
great
idea,
michael
sure,.
A
So
just
doc,
so
this
is
a
copy,
since
I
always
get
this
wrong.
B
B
Yeah,
I
I
think
I'd
see
it's
the
example
site
that
has
the
resource
and
somehow
my
edits
hit
the
readme
page,
but
not
the
tutorial
site.
C
Yeah
but
the
folder
that
we
named
in
the
example
because
under
every
folder
we
have
an
api,
do
we
need
to
rename
that
folder?
Oh
all,
right.
D
C
A
D
A
A
A
D
B
A
Okay,
that
sounds
good
thanks
for
continuing
to
to
look
at
that
blog
post
about
transition
to
any
to
node
api.
So.
C
A
Yeah
is
there
any
issue
with
putting
that
into
the
the
issue
itself.
C
C
Yeah
yeah
only
you
can
can
add
it
to
the
documentary.
D
C
Yeah
just
jack,
send
me
the
the
email
and
I
can
add
you
as
an
editor.
Okay,.
A
Right
now,
I'm
just
thinking,
though,
that
like
that
would
be
a
good
thing
to
do.
Just
have
an
email
that
says
jack,
here's
our
email
so
that
he
can
reach
out
to
us
between
between
calls
okay,
so
stay.
The
next
thing
is
stale
issues.
So
let's
take
a
quick
look
at
the
stale
issues
going
backwards,
so
I
didn't
add
any
new
ones
since
last
time,
let's
see.
C
Pr
I
opened
the
foreign
okay,
two
five,
eight,
the
the
the
the
issue,
two
five.
C
So
if
you
yeah,
we
discussed
last
last
week
and
I
added
some
paragraph
to
explain
what
happened
if
you
use
this
factory
method.
C
Yeah
we
can
close
the
the
issue,
throw
this
paracas.
A
And
so
fix
is
2k,
so
that
should
actually
close
that
one
out
so
perfect,
okay,
good,
that's!
Basically
everything
we
had
on
the
list,
then
so,
okay!
Well,
that's
that's
great
tracking
issues
for
modules
that
we've
noticed
porting.
I
guess
nothing
new
there,
but
we
usually
do
take
a
quick
look
at
just
see
how
adoption
is
going.
Yeah,
four
million
four
million-
oh
okay,
wow-
that's
nice
still
keeps
just
seems
to
be
on
on
a
good
track
of
being
used
more
and
more.
So
that's
good,
okay,
review
external
examples.
A
D
I
did
I'd
eventually
like
to
talk
about
the
reference
handling
change
that
I've
got
going
with
with
lucas
right
yeah,
I
don't
know.
Maybe
we
should
talk
about
other
things.
First,
I
think.
D
A
C
D
C
But
I
I
think
okay
using
is,
is
there
since
the
c
plus
plus
11..
So
this
is
the
the
the
the
only.
C
A
D
F
A
A
D
Ish,
probably
so
it's
been
around
yeah.
So
let
me.
A
A
Okay,
that's
good
good
point.
I
guess
I
asked
the
question
we'll
break
any
existing
code
and
the
answer
was
no
but
yeah
whether
the
features
support.
It
was
another
good
question.
F
A
F
F
While
the
nappy
function
calls,
then
the
number
function
call
will
still
return
a
not
p
value,
but
if
the
number
value
is
a
empty
one
and
there
is
no
compiler
checks
around
the
different
values,
so
the
and
we
have
to
using-
let's
say
no
pmv-
get
get
pending
exceptions
to
to
each
nfp
function
code,
and
I
have
made
a
change.
F
This
is
a
demo
that
similar
to
v8,
maybe
so
that
we
can
facilitate
compiler
checks
around
the
return
value
to
safely
ensure
the
function
called,
does
return
a
value
so
it
it
brings
a
strong
guarantees
to
when
the
first
class
exceptions
were
disabled.
D
F
F
A
F
So
I
have
to
define
use
a
micro
to
switch
it
on
or
off.
A
F
Sorry,
okay,
right
yeah,
the
about
one,
the
the
c
plus
password
yeah.
This.
F
F
So
we
can
handle
the
exceptions
programmatically
or
we
just
I'm
doing
simple,
I'm
doing
the
simple
way.
So
if
the
value
is
empty,
so
let's
let
it
crash
and
our
code
will
be
clean,
but
that's
up
to
the
developers,
but
this
introduced
a
compiler
checks
around
the
return
values,
so
it
can
be
much
more
safer.
A
E
F
The
difference
is
that
if
we
return
a
empty
nappy
value
and
the
comp
we
using
the
written
value
with
the
other
node
add-on
api
api
or
no
dyno
plus,
then
the
compiler
will
now
complain
that
this
value
is
maybe
empty.
And
if
we
wrap
it
with
a
maybe
box,
then
if
we
don't
check
it,
the
compiler
will
complain
and
we
will
not
compile
the
code.
E
D
C
D
A
F
And
I
don't
think
most
people
will
be
aware
of
that.
If
they
are
writing
the
code-
and
there
is
nothing
since
there
is
no
test
case
for
their
code
and
they
might
be
ignoring
it
since
there's
nothing
complaining
about
that.
F
Yeah
like
there
should
be
a
check
that
says
pr:
the
compiler
thorough,
they're,
not
compile.
If
you,
if
the
database
don't
check.
A
D
Yeah,
a
weaker
solution,
a
weaker
solution
might
be
to
just
document
for
each
for
each
method
that
we
have
that
this
method
may
throw
an
exception
and
therefore
the
return
value
may
be
empty.
But
that's
still.
F
In
my
mind,
there
is
a
very
much
places
that
javascript
can
throw
like,
say:
getters
and
setters,
and
these
are
not
function.
Calls
it
seems
like
it
can
be
seems
like
it's
just
a
get
a
property
or
object,
but
if
the
property
is
a
getter
or
ether,
then
just
could
my
just
throwing
in
this
way,
and
we
have
not
mine
not
aware
of
that
in
my
throat.
D
You
know
one
one,
one
speaking
of
getters
right:
we
have.
We
have
these
convenience
functions.
You
know
where
you
just
have
like
a
square
bracket
operator
which
returns
the
property
l
value,
followed
by
like
an
assignment
operator
which
which
performs
the
set
right
so
in
in
this
case.
I
don't
know
how
this
is
going
to
jive.
With
with
with
this
maybe
solution,
because
you
know
an
exception
may
be
thrown.
D
D
D
D
You
know,
because
you
know
def
may
not
have
been
assigned
to
the
c
abc
property
of
the
object
at
all
because
of
an
exception.
Currently
we
just
kind
of
assume
that
it
works.
D
D
These
science,
the
the
result
of
the
entire
assignment,
is
a
maybe
bool
and,
and
it
gives
you
a
compiler
time
warning,
if
you
don't
check
the
value
of
the
bull
so
actually
come
to
think
of
it
lucas.
One
of
the
things
you
may
want
to
add
is
is
like.
If
you
don't
perform
the
check
right
like
you,
you
must
not
ignore
the
return
value.
Like
there's
a
there's
like
a
gcc
there's
a
gcc
attribute.
You
can
add
to
the
function
that
that
throws
a
warning.
D
If
you
don't
check
the
return
attribute
right,
so
that
that
may
be
another
thing
to
do
right
like
in
the
case
of
maybe
value
you
have
to,
because
that's
your
value,
but
in
the
case
of
maybe
bool
like
for
dot
set
you'll
want
to
add,
like
the
the
attribute.
That
throws
a
warning
if
you
don't
consult
the
return
value,
because
I
remember
v8
does
that
too
so
anyway?
Yes,.
F
F
D
F
So
this
is
a
is
the
actual
function
call
and
it
will.
There
is
a
not
p0,
is
failed
assertion
in
2144
and
if
the
function
call
fails
for
the
there
is
a
javascript
pending
exceptions
here,
the
nappy
throw
is
filled
will
assert
that
the
action
is
filled
and
it
will
throw
in
that
throwing
exceptions
again.
Well,
there
is
a
pending
javascript
exception,
so
the
the
program
will
crash
for
throwing
at
a
pending
exception.
D
Yeah
yeah
yeah.
I
see
this.
I
see
the
problem
here
yeah,
so
so
we
shouldn't
not
be
throwing
failed.
If,
if
there
is
a
pending
exception,
we
should
throw
that
and-
and
otherwise
we
should
so
so
yeah
we're
checking
we're
checking
the
status
here
indiscriminately
right,
but
we
have
to
have
a
special
case
for
where
the
status
is
nappy,
pending
exception,
right,
yeah,
and
so
so
maybe
we
should
change
nappy,
throw
if
failed
to
to
handle
this
special
case
if
it's
not
currently
handling
it.
D
A
Yeah,
actually
it's
a
pr
okay,
which
is
but
this
this
is.
This
is
related
to
right,
so
this
one
there
so
so
this
was
like
one
about
in
shutdown
like
because
we
we
mixed
pending
exception
with
shutdown,
and
I
don't
know
if
it's
directly
related
to
that
other
one
that
we're
just
talking
about,
but
it
it
it's
a
little
bit
in
that.
A
Okay,
I
should
actually
be
checking
if
there's
a
pending
exception
and
making
sure
that
I
don't
make
the
call,
if
that's
the
case
right,
but
this
this
was
around
because
we've
mixed
terminating
in
with
penny
exception
when
things
are
terminating,
you
don't
necessarily
want
to
throw
the
fatal
exception,
because
maybe
it's
not
useful.
D
Yep
yeah
yeah
this
this
is
this
issue
of
distinguishing
between
environment
shutdown
and
appending
exception
is
coming
up
more
and
more
often,
and
so
I'm
I'm
starting
to
think
that
maybe
we
need
to.
We
need
to
make
that
breaking
change,
because
it's
it's
just
like
we're
going
to
have
environment
shut
down
in
a
lot
of
places
now
that
we
have
workers
and
now
and
that
now
that
their
adoption
is
is
is
growing,
and
so
you
know
we
had
this
argument
of
of
whether
this
is
a
this
is
a
like.
If
is
it
like?
D
D
I
I
have
a
way
I
and
I
I
have.
I
have
an
issue
in
the
core
repo,
where
we
can
do
this
without
breaking
in
a
semi-minor
way.
So
basically
we
we
we
give
the
user
the
opportunity
during
during
in
during
module
registration
or
module
initialization,
to
provide
a
callback
that
will
accept
a
status
of
not
be
pending
exception
and
will
return
a
new
status
of
whatever
they
choose.
D
If
at
that
point,
and
so
so
they
may,
they
may
be
able
to
handle
it.
That
way.
So,
basically
pipe
like
before
you
return
from
the
napi
call
just
pipe
it
through
the
user's
callback
and
see
if
they
change
the
value
of
the
return
status
and
then
and
then
just
hand,
hand
control
back
to
the
user
and
then.
A
A
D
A
D
In
or
not
when
we
return,
and
then
we
can
point
them
to
that
api-
okay,
so
I
wouldn't
I
wouldn't
go
with
I
wouldn't
go
with
with
is
terminating,
I
would
go
with
is
able
to
run
javascript
like
can
run
js,
and
we
are
here.
A
A
A
Well,
it's
like
in
this
case,
so
you
know
what
I
have
on
the
screen
here.
It's
like,
okay.
First,
we
check.
Is
there
a
pending
exception?
Okay,
there's
no
pending
exception,
then
that
means
that
we
can
go
ahead
and
what
made
me
think
about
when
we're
looking
at
the
other.
One
is
like.
It
basically
says:
if
there's
a
pending
exception,
don't
try
and
throw
we.
We
know,
there's
a
penny
exception.
We
know
that
that's
actually
just
going
to
say,
because
the
the
preamble
and
throw
actually
says
is
there
already
a
pending
exception.
D
A
D
A
D
A
A
E
D
Yeah,
a
a
and
b
this
this
chain
of
two
pending
exceptions
is
not
necessarily
caused
by
environment
shutdown
like
as
we
know
during
gc.
D
You
can
also
have
this
right
where,
where
you
know
like
you,
call
a
finalizer
and
the
finalizer
calls
back
into
javascript,
but
currently
javascript
execution
is
unavailable
and
you're
nowhere
near
environment
shutdown,
it's
just
a
regular
operation,
and
so
so,
if
you
do
this
during
regular
operation,
you
will
be
swallowing
exceptions
right
and
actually
the
we
we
just
learned
the
other
day
right
that
the
buffer
finalizer
is
is,
is
on
a
set
immediate
to
avoid
precisely
this
issue,
but
finalizers
for
regular
references
are
not
right
and
we
haven't
run
into
this
issue
yet
for
regular
references,
but
we
may
at
some
point
right
yeah.
D
Right
answer
or
not:
well,
ideally,
you'd
you'd
put
you'd
put
the
throwing
of
the
exception
on
a
set
immediate.
If
you
get
a
pending
exception
here
right,
because
you
know
this
pending
exception
is
because
the
inability
to
execute
javascript.
So
then,
if
you
were
going
to
throw
an
exception
originally,
then
just
throw
it
in
a
set
immediate.
That
would
be
the
solution
and
then
you
know,
and
then
the
stack
unwinds
and
then
and
then
the
the
exception
pops
up
and
you
still
you
will
still
have
thrown
it.
D
But
but
you
know
you
will
have
thrown
it
in
into
an
environment
that
is
actually
able
to
process
it
right,
but
we
don't
have
set
immediate
exposed
anywhere.
A
D
A
So
I
guess
I
want
to
bring
this
up,
so
I
think
if
people
can
think
about
it,
maybe
comment
in
it
because
that's
the
fundamental,
like
is
the
best
thing
to
do
to
do
nothing
in
this
in
if
you
can't
call
into
js,
or
is
there
still
value
in
terms
of
like
flagging
errors
to
the
user,
because
that
was
our
original
reason
for
throwing
the
fatal
error
and
like
in
in
the
termination
like
the
terminating
threads,
it
seems
to
be
you
can
you
can
you
can
trigger
this,
but
not
like?
It's
not.
A
A
Right,
like
I
I
if
there
was
so
that's
why
we
explain
we
explored
a
little
bit.
Maybe
we
can
go
back
and
look
at
that
some
more,
but
it
seemed
like
the
callbacks
that
we
have
weren't
necessarily
going
to
help
you
be
able
to
figure
out
like
yeah,
I'm
in
the
state
I'm
going
to
avoid,
throwing
in
the
first
place.
D
Can
we
on
this
note,
can
we
have
a
look
at
at
this
one?
This
may
be.
A
F
D
One
one
quick
feedback
at
first
blush
about
the
maybe
thing
can
you
use
variatic
template
arguments
to
not
have
so
many
overrides?
Maybe
you
can
cover
all
the
all.
The
dot
calls
that
we
currently
have
with
with
like
a
single
template
function.
If
you
use
like
dot
dot
in
the
template,
and
then
you
just
pass
the
arguments
through
and
then
and
then
the
compiler
will
resolve,
which
sets
of
arguments
will
work
see
like
you,
don't
have
to
have
so
many
variations.
If
you
just
have
like
a
very
addict
template.
A
F
D
Oh,
but
wait
a
minute
because
we
can't
well
wait
a
minute
is:
isn't
isn't
that
going
to
override
places
where,
where
it's
supposed
to
stay
value,
no,
you
would
have
a
new
type.
Oh
I
see.
Okay,
it.
A
D
A
Yeah,
okay,
so
it
sounds
like
you
know,
there's
enough
interest
to
to
refine
a
little
bit
and
maybe,
like
you
said
you
wanted
to
look
at
some
of
the
other
places,
because
I
think
if
it's
like,
we
could
only
do
it
at
half
of
them.
It's
not
quite
as
interesting
as
if
we
could
do
them
like
if
there's
places
it
should
be,
but
we
can't
do
it
that
might
affect
the
decision
too
right.
Yeah.
F
A
Okay,
so
sorry,
then
I
do
want
to
keep
a
bit
of
time
to
talk
about
the
issue.
We
were
going
to
get
jack
to
start.
Looking
at
gabriel,
you
had
one
other
one,
though
you
want
to
go
to.
D
A
So
this
is
we.
You
know
we
did
take
a
a
cut
quite
a
while
back
to
sort
of
go
through
all
of
the
the
the
api
surface
and
sort
of
say:
where
do
we
have
tests
or
not
right,
but
this
is
this
is
going
to
be
stale.
It
no
longer
covers
all
the
different
methods
so
that,
let's
see-
and
what
do
we
have
here?
What's
this
one
yeah?
A
Okay,
that's
just
related,
so
I
think
like
that
would
be
a
good
thing
to
start
with
to
say
you
know,
update
the
table
and
add
in
the
column
that's
kind
of
like
yes,
no
probably
like.
I
can
see,
there's
some
things
about
like
cprs
and
stuff
like
that,
but
like
something
that
clearly
says
you
know
covered
or
not
covered.
A
You
know
if
you
have
any
questions,
let
us
know,
and
I
think
jim,
if
you
can
send
them
an
email,
just
ccing,
all
of
us.
Okay,
we
has.
C
This
game,
so
now
we
have
two
power
casts
about
the
test
and
we
need
to
update
the
issue
with
that
yeah.
So
take
a
look
at
the
pr
before
starting
working
on
something.
That's
that's.
C
We
have
two
pr
at
the
nine
to
eight
and
nine
two,
three,
okay,
that
add
some
tests
and
so
just
pay
attention
to
not
cover
the
same
thing.
Yeah,
okay,
makes
sense.
A
Okay,
good,
so
then
the
last
thing
we
want
to
try
and
squeeze
in
was
discussion
of.
Do
you
know
you
have
the
issue
on
issue
or
pull
request
gabriel
number
yeah
hold
on?
Is
it
a
pr
issue?
It's
a
pr.
Okay,.
A
D
Oh
yeah,
sorry
yeah,
yep
yeah.
I
moved
the
mic
up
okay,
so
there
are
two
things
here:
the
first
one
is
this
top
top
hunk.
This,
I
think,
is
safer
in
general,
no
matter
what
to
to
empty
out
the
the
objects
or
the
instance
copy
of
the
finalizer
pointer
and
just
call
then,
because
this
would
make
a
hundred
thousand
percent
sure
that
we're
not
calling
into
the
user's
finalizer
twice.
So
I
think
that's
a
good
one
now
down
here
this
yeah
this
this
is.
D
This
is
something
we
should
be
doing
because,
although
in
in
newer
versions
of
node,
we
can't
call
javascript
during
environment
teardown
in
in
older
versions
of
node
we
can
like
in
14.
I
think
lucas
correct
me.
If
I'm
wrong,
I
think
in
14
you
can
still
call
into
javascript
during
environment
teardown,
which
means
that
as
soon
as
you're
executing
any
kind
of
javascript,
it
is
possible
that
that
you
will
you're
going
to
launch
a
gc.
D
And
so,
if
you
keep,
if
you
keep
the,
if
you
click,
keep
the
weak
callback
attached
to
the
javascript
object,
then
v8
may
end
up
calling
the
weak
callback
and
so
you're
going
to
end
up
in
finalize
you're,
going
to
re-enter
finalize
so
you've
entered
finalized
from
environment
teardown
right
then
you
execute
some
javascript,
then
the
gc
will
run
and
it'll
enter
finalize
from
gc
right
and
then
that'll
cause
a
double
free.
D
So
if
you
clear
the
week
before
executing
the
finalize,
then
then
that
will
not
happen
and
and
and
so
because
basically,
what
we're
saying
is:
okay,
it's
environment,
tear
down
the
the
destructor
for
napi
and
is
responsible
for
running
all
the
finalizers,
so
gc
stay
out
of
the
way
right
like
we
are
now
running
the
finalizer,
not
the
gc,
because
the
gc
may
or
may
not
run.
It
depends
depends
on
on
the
gc.
A
D
D
A
D
Later
versions,
yeah
because
you
cannot
call
back
into
js
anymore,
yeah
and
and
then
of
course,
that
whole
that
whole
pending
exception
thing
pops
up,
but
that's
a
different,
that's
a
different
discussion,
but
anyway
there
is
one
caveat,
and
I
put
that
into
comment
so
currently
calling
as
far
as
I
can
tell
calling
clear
week
is
a
guarantee
that
the
the
the
week
the
week
callback
will
not
be
called,
but
but
we're
basically
trusting
the
engine
that
or
a
call
to
clearweak
will
remove
even
a
pending
finalizer.
D
E
I
think
in
the
the
comment,
if
you
scroll
down
a
bit
and
this
one
here,
a
little
bit
sorry
this
this
kind
of.
E
F
Yeah
and-
and
I
don't
agree
with
that-
blue
engines
or
not-
we
are
built
on
top
of
the
engine
and
if
we
are
not
believing
it,
a
lot
of
our
code
will
have
a
lot
of
extra
work
to
do
so.
If
we
believe
it's
a
engine
work
we
have
to
fix,
I
believe
we
have
to
work
with
the
engine
partner
wrapping
around
it.
D
D
D
D
F
D
Of
what
basically,
the
okay,
so
the
finalize
that
we
have
currently
on
master
is
only
in
ref
base
right,
but
there
are.
D
D
A
E
A
D
C
D
D
Okay,
so
like,
if
you
look
at
it,
if
you
look
at
it
in
a
certain
way
where
we're
we're
kind
of
we're
during
environment
teardown
we're
sort
of
shearing
the
reference
apart,
on
the
one
hand,
where
we're
we're
setting
the
ref
count
to
zero
artificially
making
it
weak
and,
on
the
other
hand,
we're
clearing
the
weak
callback
from
the
engine
strong,
so
so
during
environment
tear
down
the
the
reference
just
sort
of
explodes
it's
both
weak
and
strong.
At
the
same
time,
we're
like
entering
quantum
territory
here.
D
So
you
know
you
can
look
at
it
from
this
really
weird
perspective,
because
clear
weak
is
something
we
normally
do
when
we
strengthen
the
reference
right,
but
on
the
other
hand,
we're
setting
the
we're
setting
the
ref
count
to
zero
meaning
we
want
to
weaken
the
reference,
but
we
have
to
do
it
because
we
have
to
ensure
that
that
that
the
finalize
happens
from
for
exactly
one
reason
which
is
environment,
tear
down
and
we
weakened.
We
set
the
ref
count
to
zero
so
that
we
get
this
deferring
behavior
and
we
we
cleared.
D
D
D
D
D
So,
basically,
basically,
when
we
introduce
this
line
that
you
highlighted,
we
basically
missed
the
step,
which
is
to
to
to
tell
the
garbage
collector
to
back
off,
because
we
we
thought
it's
not
going
to
happen
because
it's
environment
tear
down,
but
lucas,
found
an
instance
where
it
does
happen,
and
so
so
now
we
need
to
introduce.
We
need
to
fix
this
misstep
by
also
removing
the
clear,
weak
and,
of
course
only
on
older
versions.
A
Okay,
okay,
yeah-
that
makes
sense
to
me:
does
that
fix
the
intermittent
failures
we've
been
seeing
in
the
node
add-on
api
tests.
A
D
A
A
Yeah,
I
know
okay,
so
I
I
the
only
thing
that
might
be
handy
is
to
add
a
little
bit
to
this
comment
at
273.,
okay,
sure,
yeah,
right
just
to
say
that
you
know
there's
actually,
like
you
know
the
tie
between
this
finalized
code
and
this
thing
right.
So
if
I'm
reading
this,
you
know
what
you
might
say.
D
A
Okay,
well
we're
we're
well
over.
So
thanks
for
everybody
for
taking
the
time
unless
there's
something
we
need
to
talk
about
before
we
close
up
today,.