►
From YouTube: Node.js N-API Team meeting - March 23 2020
Description
A
A
A
B
C
My
feeling
right
now
is
as
as
I
look
at
the
code
that
the
issues
are
probably
related
to
another
contributors
code
that
eliminated
the
the
dependency
on
libuv
for
async
operations,
so
I
think
if
I
cannot
resolve
it
soon,
I
will
back
those
changes
out
and
just
try
to
get
it
going
on
the
libuv
and
then
make
the
async
handling
a
separate,
make
it
a
separate
PR
just
so
we
can
get
get
something
going
there.
Yeah.
A
C
C
A
A
A
Sounds
good
the
next
things
we
have
are
burning
down
the
list
of
issues
raised
by
module
owners,
so
there
any
that
people
have
to
call
out,
for
example,
on
know
that
on
API
I
think
we
should
discuss.
Actually
one
one
I
will
throw
out
is
that
there
was
a
I
think
a
comment
on
one
of
the
issues
about
when
we
should
do
our
next
release.
A
A
A
D
E
A
Do
have
yeah
there's
been
a
change
lock.
Oh,
we
should
look
to
see
if
there's
somewhere,
that
we
document
that,
like
it's
a
little
bit
of
an
interesting
thing
like
I
guess,
there
seems
to
be
consensus
among
at
least
some
areas
of
the
ecosystem
that
you
should
do
a
major
when
you're
dropping
release
a
version
like
when
you're
dropping
support
for
a
version
of
node
yeah.
D
C
A
Could
be
the
act
of
LTSs,
although
that
there
is
there's
like
active
and
maintenance
too,
so
it
might
be
confusing
anyway,
the
ones
which
are
not
end
of
line
it
should
only
support
those
is
it's
generally.
My
feeling
is
that
that's
at
any
one
time-
and
it
just
feels
a
little
odd
to
just
do
a
major
for
that,
especially
since
we
don't
really
do
majors
but
I.
A
C
A
E
Actually
dropping
dropping
the
source.
Implementation
is
tantamount
to
dropping
support
for
8,
because
8,
not
all
versions
of
8,
have
have
any
PDI
right,
so
yep,
so
yeah
and
and
that
that
is
so
its
major.
If
for
no
other
reason,
then,
because
we're
dropping
the
source
implementation
right,
yeah
no
go
ahead.
E
A
E
No
no
I
mean
I
mean
that
ok,
what
I'm
saying
is
ok,
so
so
that's
a
change
on
our
part
that
you
stopped
testing
right
right,
but
if
we
do
absolutely
nothing
and
things
to
work,
then
and
there's
no
reason,
but
that
that's
obviously
never
going
to
right,
because
because
it's
an
ongoing
project
and
there
any
any
little
change
we
make.
You
know
you
know
if
one
of
the
one
of
the
node.js
version,
the
core
version
goes
out
of
maintenance
and
then
becomes
end
of
line.
Then
then,
for
what
little
changes
we
wish
to
release?
E
F
A
E
E
E
E
E
D
E
E
A
E
Actually,
the
changelog
that
we
create,
where
does
the
change
of
grab
its
content
from?
Because
you
know,
if
it's
anything
related
to
the
to
the
commit
comments
or
to
the
commit
messages,
then
then
the
PR
that
removes
the
support
says,
remove
an
API
implementation,
v6
and
v8
for
neck
support.
So
so,
if,
if
the
subject
of
the
of
the
commit
gets
gets
bundled
into
the
changelog,
then
then
that
will
appear
in
the
in
the
changelog
with
the
release.
Okay,.
A
A
E
E
A
So
maybe
we
should
I'm
thinking
yeah
the
package
like
in
the
package
maintenance
group
we've
been
working
on
some
additional
json
which
allows
you
to
specify
the
intent
and
with
the
intent
here
being.
We
support
octave
LTS
versions,
and
that
might
be
the
way
to
maybe
I'll.
Do
a
PR
to
add
that
into
this.
The
repo
is
a
first
step,
and
we
can
then
talk
about
whether
there's
other
things
we
should
do
too,
but
I
think
for
the
lease.
What
you've
got
is
probably
good,
since
it
will
show
up
in
that
yeah.
A
A
G
E
E
E
A
E
E
A
A
A
A
A
A
C
C
A
C
A
A
F
A
A
Sounds
good,
I
think
so
I'm
moving
on
to
this
next
one
I,
don't
think
there's
anything
to
new.
Since
last
night,
I
see
that
was
good.
That
sharp
was
landed
and
then
I
think
that
just
continues.
We
continue
to
see
an
upward
trend,
which
is
good,
oh
we're
up
to
600,000
now,
so
that's
quite
good
I
think
it
was
yeah.
It
was
around
3,
so
we've
almost
doubled
since.
A
A
G
G
The
Nappy
threats
a
function
call
J,
yes,
I'm.
Taking
that
parameter
directly
from
directly
that's
being
passed
into
the
new
call
and
take
passing
that
directly
to
the
not
be
create
that
safe
function
and
the
reason
that
I
was
doing.
That
is
because,
in
a
different
and
a
different
issue,
there
was
a
comment
saying
that
any
sort
of
wrapping
for
that
call
Jas
was:
was
a
performance
hit
or
whatever.
So
that's
why
I
was
just
trying
to
pass
that
value
directly
as
is
without
any
sort
of
wrapping,
but
I,
don't
think
we
could.
G
G
G
F
G
F
F
E
You
can,
if
you
can
pass,
you
can
pass
them
as
template
parameters
right
I'd
like
for,
for
for
for
Nappi
function.
You
we
were
able
to
avoid
wrapping
by
by
passing
template
parameters
for
we
not
oh,
no
I'm,
sorry,
no.
We
were
able
to
avoid
heap
allocation
by
passing
by
using
template,
but
not
the
actual
yeah
yeah,
not
the
actual
right.
E
G
G
E
E
E
E
E
E
E
No,
no!
No!
No!
No!
You
wouldn't
right,
because
the
function
coming
in
from
the
user
is
the
convenient
function
that
we're
trying
to
provide
right.
We
put
a
wrapper
around
it,
so
the
signature
of
the
wrapper
matches
whatever
core
expects
and
then
and
then,
whenever
core
cause,
you
know,
convert
or
call
J
s
it
cause
our
function
and
code
will
be
called
the
convenient
user
function.
So
it
it's
an
equal
number.
It's
an
equal
number
of
wraps
as
as
a
plain
JavaScript
function.
Call
is
why
I'm
saying.
E
E
A
E
This
is
about
calls
coming
from
java
straight
to
native
right.
That's
that
that's!
So
that's
the
plain
function
call
right
like!
Would
you
create
that
function
with
function,
new
and
when
that
function
gets
called?
You
know,
first,
the
v8
function
gets
called
and
that
it's
converted
to
a
foreign,
API
called
and
that
gets
come.
E
I
know
that
on
API
call
right
and
then
that
gets
cano
that
doesn't
that's
the
final
step.
Okay,
but
when,
when
you're,
when
you're,
when
you're
talking
about
the
threats,
a
functions,
a
marsh
killer,
right,
it's
called
j/s,
then
then
the
call
to
the
marshal
ER
or
rigea
Nate's
from
Cora
API
right,
okay,.
D
E
You
know
the
map
at
the
end,
to
avoid
boy
the
one
with
the
two
boys
pointers
in
in
threads:
a
function
DX
dot
coz.
So
it
calls
a
function
of
that
signature
right
and
what
Kevin
is
saying
is
that
if
we
want
to
change
the
signature
right
now,
he's
not
wrapping,
it
he's
passing
the
function
or
modified
interview
into
court
right,
but
that's
not
true
for
regular
functions,
right,
regular
functions,
we
wrapped
them
before.
We
pass
them
into
core
right.
We
convert.
We
convert
the
the
signature
that
we
expect
for.
E
New
that
callable,
we
wrap
that,
with
with
a
with
a
with
a
function
that
that
we
can
pass
into
into
core,
but
we
don't
wrap
this
right.
So
this
as
it
stands,
right
now
actually
has
less
wrapping.
Then
then,
then
the
then
the
regular
function
that
you
create
using
function
U.
So
that's
why
I'm
confused
as
to
why
the
performance
impact
of
wrapping
this
function
is
any
greater
than
the
performance
impact
of
wrapping.
Any
plain
old
JavaScript
function
that
we
already
wrap.
G
E
E
G
G
G
B
E
Basically,
okay,
so
so
so
so
so
the
PR
as
it
stands
now
sort
of
swings
in
the
opposite
direction.
Right
it
has
fewer
raps.
Then
then,
then,
what
know
that
on
API
already
does
right,
whereas
whereas
the
comment
that
I
made
here
referred
to
through
dropping
the
ability
to
pass
in
a
function
pointer
so
that
you
can
have
a
different
function
for
each
call
Jas,
because
because
that
is
that
that's
an
additional.
E
E
Yeah
I
know
I
mean
drop
in
terms
of
not
in
turn
implies
that
part
in
this
new
version
of
thread-safe
function.
That
Kevin
is
working.
That's
what
I
mean
by
draw
I
don't
mean
drop
it
from
the
original
forensic
function
class
because
that
that
would
be
a
grant
major
and
then
generally,
okay,
okay,
so
so
so
so
yeah
yeah,
yeah,
okay,
I,
understand
that.
So
so,
basically,
the
my
comment
was
about
dropping
the
ability
to
pass
a
different
function.
G
A
E
G
The
one
thing,
though,
is
that
I
removed
all
of
the
the
the
new
overloads,
because,
with
the
non
exe
there
was
like
the
optional
async
resource
or
the
optional
finalizer
and
all
of
that
stuff,
so
removing
all
of
those
extra
extraneous
ones
actually
make
makes
it
very
simple,
I
think
it's
it's
very
similar
and
I
guess.
Another
thing
is
I,
don't
know
if
I
should
make
this
one
inherit
the
old
thread-safe
function,
or
should
they
just
be
completely
orthogonal
and.