►
From YouTube: Node.js N-API Team meeting - Sep 6 2018
Description
A
A
A
B
So
I
have
I
have
a
PR
outstanding
on
that
the
main
it's
two
separate
projects,
as
it
turns
out.
Pre
build
and
pre-built
install
I,
have
common
code
to
support
an
API
between
the
two
projects
that
I
do
placated,
and
so
the
maintainer
is
asking
that
I
put
that
into
a
common
module,
so
I'm
working
on
getting
that
code
published
into
a
common
module
so
that
it's
not
duplicated
between
those
two
okay.
A
A
D
Yeah
Anna
Anna
supported
me,
so
that
was
even
better
yep
yeah,
hopefully,
hopefully
we'll
we'll
get
this
straightened
out
and
now
I'm
helping
explain
the
meaning
of
the
different
parameters
of
the
thread-safe
function
and
I
and
I
provided
examples
for
two
folks
who
were
looking
to
use
threats
a
function.
One
of
them
was
in
conjunction
with
async
work,
how
to
call
out
of
execute
using
the
thread-safe
function,
yep
and
the
other
one.
D
D
We'll
see
we'll
see
what
this
person
says
in
response
to
the
example,
because
I'd
really
not
want
to
add
that,
but
on
the
other
hand,
I
did
have
to
use
an
extra
mutex
for
for
the
round
trip
asynchronous
call,
because
you
know
the
the
object
which
you
pass
into
JavaScript
and
then
you
get
back.
You
have
to
access
it
through
a
mutex,
because
you
know
that.
Meanwhile,
the
thread
is
checking
whether
the
call
was
answered
or
not
so
yeah.
D
If
we
want
to
limit
use
of
livery
so
as
to
prevent
ABI
breaks,
then
then
we
may
want
to
wrap
that
particular
use
case.
You
know
where,
where
you
have
something
coming
in
from
a
thread
going
into
JavaScript
coming
back
at
a
later
time
and
then
being
checked
from
the
thread
to
see
whether
it's
resolved
or
not,
it.
D
B
A
A
B
D
But
then
again,
this
other
person
is
using
a
sea
library
that
that
that
does
all
its
own
threading
and
it's
behind
closed
doors.
So
to
speak,
so
they
don't
control
the
threading.
But
presumably
they
have
hooks
for
four
functions
which
can
run
either
on
on
one
thread
or
another.
And
then
they
can
that's
that's
where
they
can
hook
into
it
and
go
an
API.
And
so
so
then,
presumably
that
C
library
would
not
expose
the
primitives
that
it
itself
uses
for
the
for
the
threading.
D
So
so
then,
so
then
you
know
if
they
have
to
reach
for
synchronization
primitives
additional
ones,
then
you
know
then
maybe
reaching
for
a
livery
would
not
be
a
good
idea,
but
I
don't
know
III
would
say
I
would
say
we
should
be
conservative
about
this,
and
and
let's
see
what
these
folks
say
and
if,
if
the
need,
if
the
need
becomes
more
pressing,
then
we
can.
We
can
start
thinking
about
adding
stuff
together
or
supporting
even
more
multi-threaded
stuff.
So
yeah.
D
A
A
D
Yeah
and
and
as
a
segue
into
this
becoming
non
experimental
thing,
we
have
to
figure
out
how
to
how
to
do
this,
because
my
impression
from
from
trying
to
back
four
to
six
point
X
this,
this
stuff,
which
was
missing,
is
that
we
may
have
a
very
limited
window
to
to
mark
things
as
non-experimental.
Be
because
if
we
have
things
marked
as
experimental
in
the
three
supported
versions
of
node,
then
we
have
a
very
limited
window
to
you
know
massage
the
the
the
header
file
and
move
things
from
experimental
to
like
some
version,
but.
A
D
Eventually,
ten
will
be
will
take
the
place
of
sex.
Yes,
then,
then,
you
know
how
much
of
a
window
do
we
have
for
shuffling
the
the
header
files
so
that
those
things
are
no
longer
experimental?
You
know
like
LTS
is
a
moment
in
time.
You
know
when
when
when,
when
that's
it,
it
enters
maintenance
mode
from
one
moment
to
the
next
right.
A
I
think
I
think
the
things
like
it'll
be
that
when
we
promote
them,
you
basically
get
a
new
nappy
version
right
right,
right
and
and
and
at
that
point
it's
basically
okay.
Well,
if
there's
a
new
nappy
version
that
may
you
know
probably
back
to
current
no
problem
and
probably
back
to
the
most
recent
LTS,
it's
probably.
B
A
D
So
sorry,
so
if
somebody
so,
if
somebody
builds
against
version
against
such
an
N
API
version
that
is
only
available
in
in
in
current
and
LTS,
but
happens
to
be
perfectly
available
in
maintenance
except
marked
as
experimental,
then
they
will
still
be
a
bi
compatible
with
maintenance.
They
will
just
happen
to
be
a
bi
compatible
with
me.
A
A
E
A
D
Yeah,
but
if,
if
things,
if
things
were
experimental
and
they've
stayed
experimental
for
so
long
that
they
are
now
even
present
in
maintenance
using
ideal
signature
using
identical
signatures,
yep,
then
then,
then,
then,
claiming
that
they
that
the
new
version
of
napi
is
now
available
across
across
all
node
releases
is
as
simple
as
creating
a
PR
against
the
maintenance
release
which
merely
changes
the
the
node
API
dot
H.
It
doesn't
actually
add
a
code,
nor
does
it
remove
code.
For
that.
D
A
A
A
D
A
D
D
A
C
A
D
A
D
C
A
A
A
A
A
A
A
A
A
Cuz
yeah
I
mean
I
think
we
could
walk
through
the
code.
Even
if
we
did
that
all
ad-hoc,
you
know,
walk
through
the
code.
Okay,
so
where
things
are
and
then
talk
about
how
to
get
contribute,
yeah
I
think
yeah.
Okay,
so
we
got
that
in
there.
I
didn't
mention
it
that
we
in
somebody
at
the
TCB
did
sort
of
listed
the
ones
that
were
there
I
said
well,
I.
Think
the
API
team
a
wanted
to
do
something
so,
okay,
there
we'll
throw
that
in
there.
Oh
wait.
A
E
A
D
Yeah
I
mean
insofar
as
filing
issues,
but
I
was
hoping
to
discuss
whether
we
should
start.
You
know
making
documentation
PRS
for
that
and
whether
we
should
like
where
exactly
we
should
document
you
know.
Do
you
know
what
the
badges
shall
look
like
and
so
forth
and
I
mean
we
can
even
add,
like
links
to
the
documentation
and
just
have
people
copy
that,
because
it's
really.
B
D
D
D
A
D
A
A
B
B
B
D
A
D
A
A
For
the
very,
very
first
hello
world
that
gives
you
that
you
know
basically
everything
you
need
to
call
a
function
from
JavaScript
into
a
native
C
code.
Yeah
would
be
that,
and
that
would
be
our
first
sort
of
then
workshop
thing
go
through
this
and
that's
like
now:
here's
the
more
advanced
one.
Where
now
you
want
to
bind
the
lifespan
of
the
C
code
and
the
C
plus,
you
know
the
JavaScript
code
and
the
C++
code
together
and
the
generator
still
helps
you
generate
that
yeah
actually.
A
D
A
Sometimes
it's
useful
to
show
like
Bo
like
multiple
right
but
I.
What
I
also
think
that
it
would
be
okay
if
we
didn't
show
of
v8
examples
in
some
cases
like
I,
don't
think
I
guess
what
I
would
wouldn't
want
to
say
is.
We
should
also
set
the
expectation
that
each
exam,
every
example
does
not
have
to
support
all
the
different
ways.
A
D
Right
exactly
yeah,
so
that's
another
thing
yeah!
If
we,
if
we
do
reinstate
that
repo
and-
and
we
do
start
out
with
the
contents
as
it
is
now-
then
we're
going
to
have
to
do
a
bunch
of
cleanup,
because
you
know
things
like
you
know
I.
What
is
that,
like
you
know,
things
like
handle?
You
know
value
instead
of
local
value,
those
things
I
think
they're
still
there
in
that
repo
and
that's
that's
very,
very
old
code.
D
A
A
D
A
I
think
I
think
like
some
something
up
front,
that
says
you
know
there
may
only
there
may
not
be
each
for
each
of
the
examples
there
may
or
may
not
be
implementations
for
the
different
flavors
like
there's
no
guarantee
there's
anything
other
than
then
there's.
There's
an
example
for
one
of
them
right
at
mo
at
least
yeah.
A
D
B
A
A
A
D
A
B
B
D
Did
a
bi-stable,
no,
the
add-on
examples.
Does
it
have
like
a
well
I'll
have
to
see
if
it
has
like
a
common,
a
common
trunk
with
with
that
or
no
that
on
examples,
because
I
mean
if
the
commit
IDs
are
the
same
hash
for
hash
up
to
a
certain
point,
then
then
a
bi-stable?
No,
the
add-on
examples
is
strictly
ahead
of
no
doubt
on
anxiety,
in
which
case
there
would
be
no
issue
with
the
history
yeah.
A
D
B
E
A
B
B
D
B
A
E
B
D
D
Check
what
what
what
the
native
function
is.
So
basically
you
have
the
native
function,
you
have
the
data
and
then
you
associate
and
then
you
create
a
JavaScript
function
out
of
that
right,
and
my
problem
was
that
if
you
have
property
descriptors
then
then
you
know
you,
you
create
the
native
data
and
you
store
it
in
a
structure.
D
You
could
you
pass
the
function
pointer
into
the
structure
and
then
you
pass
the
structure,
and
so
so
at
the
point
where
you
give
the
structure
to
an
API,
you
don't
know
whether
that
structure
was
was
created
by
by
third-party
code
or
whether
that
was
created
by
node
add-on,
API
itself.
That
was
the
issue,
but
but
I
realized
that
you
can
distinguish,
because
the
function
pointer
stored
inside
the
structure
is
a
function
pointer
created
by
know
that
on
API,
so
so
so
that
part's
good.
D
But
the
problem
is
when
you,
when
you
pass
things
into
napi,
define
properties,
the
the
actual
Nappi
value,
that
is
the
JavaScript
function.
You
never
get
back
because
it
creates
the
Nappy
value,
but
then
it
saves
it
as
a
property
and
then
it
discards
the
Nappy
value,
because
it's
already
saved
as
a
property
on
the
object.
So
you
don't
need
to
hold
on
to
it
anymore,
right,
and
so
so,
even
even
even
though
I
can
distinguish
the
case
where
I
need
to
do
this.
D
Then,
then,
look
at
the
resulting
object
and
reach
and
grab
the
function
from
the
object
and
and
and
then
attach
the
data.
So
that's
that's
crazy,
that
that
makes
the
function
really
really
heavy.
So
so
my
solution
to
that
was
to
modify
Nappi,
define
properties
to
to
save
the
the
Nappy
value
in
the
structure
after
it
creates
it.
D
So
so
it
goes
nappy
create
function
that
results
in
a
p-value
which
is
a
JavaScript
function,
and
then
you
store
that
function
back
in
the
property
descriptor
and
then
when,
when,
when
a
P
defined
properties
returns
the
property
descriptor,
whereas
before
it
contained
whatever
we
don't
care,
because
we
didn't
look
at
the
value
now,
it
contains
an
a
p-value
which
is
the
JavaScript
function.
So
then,
as
the
next
step,
you
can
loop
over
the
over
the
array
of
property
descriptors
again
and
for
each
one
that
is
a
function.
D
You
would
associate
the
data
with
the
the
Nappy
value
if
and
only
if
the
the
function
pointer
is
internal
to
know
that
on
API.
But
this
I
and
I
asked
this
on
IRC
yesterday,
whether
whether
this
constitutes
an
API
break,
because
because,
whereas
so
far,
if
you
pass
function,
pointers
via
an
app
e
property
descriptor,
then
we
ignore
the
Nappy
value
that
you
also
passed
in,
because
we
don't
care
what
it
would
take
to.
We
take
the
function
pointer
and
we
turned
them
into
an
empty
value.
D
We
didn't
we
weren't
touching
the
actual
value
field,
whereas
now
we
would
that
particular
item
in
the
Nappy
property.
Descriptor
array
would
no
longer
be
input
only.
It
would
be
input
output
now
because
we
would
be
saving
this
new,
newly
created,
nappy
value
and
then
returning
it
so
I'm,
not
sure
if
that
constitutes
an
ABI
break
like
if
you
go
from
don't
care
to
output.
A
D
D
A
D
You're
right
back
and
back
porting
that,
because
it's
just
a
challenge,
yeah
and
there's
another
nail
in
the
coffin,
which
is
which
is
the
fact
that
that
this
works
for
functions,
but
it
doesn't
work
for
accessors
because
because
if
you
have
accessors,
you
have
two
function:
pointers
to
native
function,
pointers
and
and
then
you
call
you
call
like.
Ultimately,
you
end
up
calling
a
v8
object,
set,
accessor
or
whatever,
or
something
like
that
and
and
you'll
be
passing
the
two
function.
Pointers.
But
you
don't
get
back
anything!
D
B
D
I
I
wouldn't
even
know
with
what
to
associate
this
data
right.
No,
like
do
I.
On
the
one
hand,
I
could
associate
it
with
the
object
itself,
because
that
makes
sense
from
the
point
of
view
that
that
you
know
the
accessor
is
inseparable
from
the
object,
whereas
the
function
can
be
ripped
off
the
object
and
used
alone,
so
I
could
associate
with
with
the
object
in
the
accessor
case
and
with
the
function
in
the
in
the
function.
D
A
E
D
A
E
D
A
A
D
D
But
this
is
another
kind
of
this
is
this
is
another
implication
of
it
which
is
orthogonal
to
this,
like
you
know,
ultimately,
when
I
have
mine,
a
p-value
which
is
the
function
and
I
have
my
data
I?
Have
it
both
in
my
hands
gray
I
can
then
use
nappy,
wrap
if
I
don't
have
this
function
or
I
can
use
this
function?
If
it's
already
there
that's
fine,
but
in
order
to
get
the
Nappy
value,
that
is
the
function
with
which
to
associate
the
data.
D
D
D
A
D
B
D
A
D
And
and
and
and
and
the
place
to
save
them
would
be
the
value
field
of
the
of
the
nappy
property
descriptor
and
then,
and
then,
when
the
property
descriptor
array
which
passed
in
comes
back
out
now,
all
the
ones
which
are
functions.
The
the
value
field
becomes
well
useful.
Instead
of
don't
care
right.
A
D
Because
inside
nappy
inside
nappy
defined
properties,
we
do
not
know
that
that,
for
this
particular
function
after
you
create
the
function,
you
must
also
associate
the
data
with
it,
because
nappy
proper
nappy
define
properties
is
is
as
low
level
as
it
gets
from
the
point
of
view
of
the
add-on,
and
so
so
it
certainly
cannot
distinguish
between
between
you
know
between
the
different
function,
pointers
that
was
passed
into
it.
You
know
it
could
be
a
function
pointer
coming
from
no
data
on
API.
It
could
be
a
function
pointer
coming
from
an
add-on.
D
A
D
Yes,
yes,
exactly
exactly
rap
and
rap
rap,
these
things
when
you
create
the
function.
Yes,
that
would
be
yeah,
but
but
okay,
that's
that's!
That's
not
so
simple
to
implement
either,
because
because
then
each
of
those
each
of
those
property
descriptors
could
have
its
own
finalizar.
And
so
now
you
would
have
to
pass
in
an
array
of
finalizar
x'.
You
know
for
each
property
that
is
function,
value
that
you
attach.
You
wish
to
use
this
finalizar
yeah.
D
You
know
which
will
be
the
same
finalizar
for
all
of
them
in
99.9%
of
the
cases,
but
it's
again
it's
a
degree
of
freedom,
sure
yeah!
So
so,
oh
it's!
It
gets
really
hairy
at
that
point.
So
I
I,
don't
know
I,
think
I!
Think
for
now,
ii-I'll
see
what
the
code
looks
like
with
with
with
just
doing
another
iteration
over
these
things.
Yeah.
B
D
D
D
D
D
D
Wait:
wait,
I'm,
sorry,
you're
right,
you're
right.
The
only
ones
you
can't
do
are
the
accessors
right
now.
Okay,
those
will
have
to
be
heavy
because
because
a
function,
you
can
either
pass
the
front
of
the
native
function,
pointers
into
the
property
descriptor
or
you
can
pass
pass
an
a
p-value
into
the
property
desired.
B
D
A
D
A
D
D
A
D
A
A
Okay,
if
not
well,
thanks
for
everybody
for
coming
and
I
guess
so
next
week
we
will
want
to
talk
more
about
the
async
worker,
stuff
and
I
think
we
should
also
maybe
Jim
if
you've
had
a
bit
of
time
to
think
about
the
workshop
for
no
coffee
you,
we
should
hopefully
talk
about
that
like
an
and
if
we
need
different
people
to
do
things,
trying
to
sign
out
action
items
that
kind
of
stuff.
Okay,.