►
From YouTube: Node.js N-API Team meeting - 28 Oct 2019
Description
A
B
A
B
C
B
D
C
C
B
D
C
B
C
C
C
A
C
A
Like
we
want
to,
if
we're
gonna
ask
people
to
potentially
like
write
a
PR,
we
should
send
an
email
to
the
maintainer
'he's
asking
if
they're,
okay,
like
here's
a
little
bit
of
context
in
terms
of
we're
doing
this
workshop
as
part
of
the
workshop,
we
want
to
have
a
session
where
people
work
on
porting
modules.
Is
it
ok
if
we
include
your
module
on
the
list
so.
C
C
C
B
C
B
C
B
B
Know,
even
if
we,
even
if
we
formulate
this
as
sort
of
a
sort
of
a
call
to
action
and
I
just
you
know
at
the
end
of
the
workshop
after
people
have
gone
through
the
examples
and
all
that
you
know
to
to
put
this
to
put
this
link
up
on
the
board
and
say:
hey
go
there
and
there
are
a
bunch
of
here
modules
that
you
can
actually
get
your
hands
dirty
with
and
start
porting.
You
know
offline
yeah
that
that
I
think
might
also
be
of
some
value.
Yeah,
that's
good!
If
we.
A
Like
should
we
now
say:
hey
we're
doing
this
we're
doing
a
workshop
at
the
upcoming
conference.
If
you
have
a
you
know
a
module
and
would
like
to
PR.
If
you
have
a
native
module
and
would
like
a
PR
to
convert
at
NTP
I,
you
know
we're
happy
to
add
you
to
the
list
of
ones
we
may
get.
People
started
to
just
let
us
know
yeah
yeah,.
B
A
C
A
A
A
A
A
But
I
think
they're,
just
thinking
organizationally
wise,
like
something
this
is
napi
four
and
five,
probably
a
slide.
That
says
like
what
happened
to
note
on
no
that
on
API
and
then
may
be
a
third
slide
that
says
these
other
things,
like
you
know,
added
support
for
pre
build
the
guide
update
an
API.
They
aren't
really
necessarily
tied
to
one
or
the
other,
but
are
good
things
so.
C
C
C
C
C
A
D
A
D
A
C
A
A
D
Okay,
so
where
I
can
really
use
some
help
here
is:
is
the
reviews
Nicola?
Thank
you
for
your
review,
but
I
want
I'm,
not
exactly
clear
that
I've
got
all
of
the
topics
that
need
to
be
discussed
under
the
under
the
four
sections
that
are
called
bare
outline.
So
if
I
could
please
get
some
feedback
on
what
topics
are
important
to
cover
under
those
under
those
four
sections
that
that
would
be
enormous
ly
helpful
to
me.
C
D
G
B
Actually,
I
think
people
don't
realize
that
that
that
those
are
available
most
often
because
they
they
don't
produce
too
many
native
values.
Usually
it's
like
you
know
you
you,
you
Tran,
you
validate
the
input
coming
in
from
JavaScript,
you
convert
it
to
native
types
and
then
you
you
get
a
value
from
the
native
side
and
you
convert
it
to
JavaScript
and
that's
it
alright.
So.
A
B
Aren't
there
aren't
enough
values
present
to
to
really
load
the
scope
that
encloses
the
call
into
the
native?
So
so
so
the
so.
The
fact
that
you
can
you
can
save
a
little
bit
of
memory
by
using
scopes.
Doesn't
it
doesn't
strike
me
as
something
that
comes
into
question?
Very
often,
you
know
it's
it's
mostly
it's
mostly
for
people
that
deal
with
large
arrays
right
and
now
that
we
have
a
ray
buffer,
that
the
number
of
those
people
should
be
going
down
right.
B
So
so
I
think
I
think
the
the
the
availability
of
scopes
as
far
as
I
can
tell
hasn't
really
come
up,
but
which
is
to
say
that
it's
more
more
of
one
of
those
specialized
areas
which
you
can
really
get
into
when
when
you
find
yours,
your
memory
ballooning
out
of
proportion,
you
know
so,
but
until
until
you're
running
to
that
you,
you
don't
even
realize
that
there
are
scopes
and
that
scopes
can
be
managed
and
and
so
forth.
Okay,.
A
A
B
Yeah
yeah
I
yeah
I
mean
that
we
could
we
could.
We
could
just
use
the
test
because
I
believe
legenda
caste
world
wrote
that
test
and
he
basically
used
the
threat
safe
function.
Example
from
guy
or
no
I'm.
Sorry
he
used.
He
used
the
threat
say
function
test
from
core
and
he
just
rewrote
it
using
no
doubt
on
API
so,
but
but
either
way
we
can.
We
can
definitely
use
that
because
it's
a
good
example
so
I
think
then.
A
D
A
A
Just
sort
of
like
I
I
don't
know
how
how
easy
it
will
be
to
pull
out
the
steps
like
but
it'd,
be
kind
of
like
okay.
Here
you
can
put
the
scaffolding
place.
Okay,
here
you
can
do
this
and
here
we're
showing
you
sending
data
back
and
forth
now
I
suspect,
it'll
test.
You
know
we
may
not
want
to
cover
absolutely
everything
that
the
test
has,
but
it'll
probably
be
a
good
starting
point.
Okay,.
G
D
A
G
G
So
my
my
company,
we
are
landing
on
open-sourcing,
one
of
our
utilities,
that
we
have
that
listens
for
network
interface,
changes
and
I
saw
on
that
previous
list
of
modules.
There
was
one
for
USB
detection,
so
the
thing
that
we
have
is
pretty
similar
to
to
that,
but
for
network
interface,
changes
and
I
feel
we're
we're
pretty
close
to
open
sourcing
it,
probably
within
the
next
month
and
I
think
it.
G
D
B
A
B
B
B
So
so
what
we
ended
up
doing
was
temporary
solution
in
nodejs,
where
we
just
declare
a
handle
scope
before
we
retreat
the
the
note
environment
and
and
Anna
pushed
the
change
in
to
v8,
which
will
which
will
do
the
same
thing,
but
it
will
create
the
handle
scope
inside
v8
before
before
it
retrieved
the
the
pointer
that
is
essentially
the
note
environment.
It's
like
this
soft
internal
light
pointer
that
then,
that
it,
that
is
essentially
a
property.
B
So
it's
a
property
get
inside
the
engine,
and
so
it
needs
us
go
and
but
it's
not
obvious
that
it
needs
a
scope
because
you're
just
giving
it
a
thing
and
you're
getting
better
back
a
pointer.
So
that's
it
doesn't
look
like
it
might
be
the
scope,
but
it
does,
and
so
so
we
we
have
like
a
heavily
commented
solution
in
nodejs,
saying
that
you
know
we
need
to
declare
handle
scope
here.
B
B
A
B
B
To
retrieve
the
node
environment,
in
order
to
attach
an
immediate,
which
is
then
responsible
for
actually
freeing
the
buffer,
and
it's
unable
to
do
that
because
as
soon
as
it
attempts
to
retrieve
the
node
environment,
that
crash
is
because
there
is
no
handle
scope.
Because
it's
coming
straight
from
the
garbage
collector.
There
is
not.
B
B
A
B
Interesting
thing
is
that
that
it
happens
on
Mac
and,
and
it
doesn't
happen
on
I
tried
to
reproduce
I
just
copy
the
code
for
beta
I'm,
almost
from
from
from
the
from
the
bug
report,
I
was
unable
to
reproduce
it
and
and
Anna
was
sort
of
perplexed
as
well
that.
Why
is?
Why?
Is
this
happening
with
with
with
production
versions,
because
v8
is
not
built
with
with
it,
with
with
checks
in
place
right
right.
A
B
Yeah,
that's
that's
actually
conceivable,
but
the
fact
that
the
fact
that
the
stack
is
so
obvious
and
and
the
fact
that
the
fact
that
it
ends-
where
is
the
stack
we
check
the
stack
again
before
I
say
something:
that's
not
true
yeah,
so
so
so
it
it.
It
ends
in
a
fatal
error
from
v8
right.
So
that's
an
intentional
abort
right
right.
Okay,
I
see
what
you're
saying
it
says,
cannot
create,
handle
without
a
handle
scope.
So
so
that
means
v8
is
imposing
its
own
constraints
that
are
fatally
right.
B
B
B
Has
some
some
real
platform
dependencies
and
time
dependencies,
and
so
so
the
stacks
may
never
line
up
like
this
on
other
platforms,
but
but
there
is
there's
still
good
reason
to
believe
that
it
would
that
you
would
get
into
a
situation
quite
often
where,
where
you
know
you're
coming
out
of
the
event
loop
and
going
straight
into
the
garbage
collector
and
then
unwrapping
a
buffer
right,
it
seems
like
it
should
happen
often,
and
yet
somehow
it
doesn't
right.
Okay,.
A
B
B
No
I
couldn't
yeah,
that's
that's
the
thing
like
I
I'm,
I'm
thinking
because,
like
the
PR
ought
to
have
a
test
case
so
I'm
thinking,
maybe
I
can
finagle
something,
but
I
suspect
that
if
I
say
like
global
dot
GC,
then
then
that
might
be
inside
of
a
handle
scope.
You
know,
and
and
and
if
it
synchronously
goes
down
all
the
way
to
freeing
the
buffer,
then
this
will
not
happen
because
well,
there
is
a
handle
scope
because
it's
coming
from
JavaScript,
because
that's
where
I
said,
global
GC,
Rob.
B
A
finalizer
right,
oh
yeah,
yeah
for
sure
for
sure,
but
but
that
test
uses
global
GC.
You
know,
because
global
GC
is
indeed
deterministic
at
that
point.
Despite
what
what
the
v8
folks
say,
global
GC,
we
have
never
had
it
not
be
determinist
right,
yeah,
no
guarantees,
but,
however
I'm
thinking,
maybe
maybe
if
we
called
global
GC,
but
not
using
the
JavaScript
interface,
but
rather,
but
rather
the
v8
interface
directly
from
from
an
event
loop.
B
Maybe
then,
when
we
can,
we
can
do
this
and
and
see
if
it
see
if
it
crashes,
in
fact
to
think
of
it.
This
is
probably
a
scenario
we
should.
We
should
be
introducing
into
all
our
tests,
which
which
rely
on
the
on
the
garbage
collector.
You
know,
wherever,
wherever
the
JavaScript
says,
global
DC.
There
should
be
a
second
version
of
the
test
that
says
global
GC,
but
does
say
so
in
in
a
stack
that
doesn't
involve
JavaScript
at
all.
You
know
just
so.
We
can
test
these
right.
A
B
A
B
Yeah
yeah
yeah
yeah
that
the
thing
is,
though,
I
mind
the
impression
I'm
getting
is
that
it's
quite
involved,
because,
because
you
know
we
would
be
providing
a
new
facility,
essentially
right
for
for,
for
calling
the
garbage
collector
straight
from
the
event
loop
right
and
and
the
tests
would
would
not
be
able
to
immediately
make
use
of
that
facility
right.
So
the
test
would
basically
be
something
like
you
know,
create
the
buffer
and
then,
instead
of
calling
global
GC,
you
would
call
you
know
attach
handle
to
event
loop,
which
then
runs
global
GC.
B
You
know
so
it
would
be.
The
second
version
of
the
test
would
be
like
that.
However,
unlike
the
first
version
of
the
test,
the
second
one
would
not
be
able
to
then
immediately
check
that
that
that
the
effect
has
happened,
because
he
it
would
not
be
synchronous
right,
because
Global
DC
is
synchronous,
but
this
would
not
be
this.
Would
this
would
need
another
iteration
of
the
event
loop?
B
And
then
you
could
you
could
start
it
with
a
flag
and
if
you
say
sync,
then
it
it
just
Global
DC
and
then
and
then
the
the
the
concluding
function,
the
the
callback.
And
if
it's
an
if
it's
asynchronous,
then
it
it
attaches
the
handle.
And
then
when
the
handle
has
fired,
then
it
calls
and
and
doesn't
assertions
so
yeah.
It
would
be
a
bit
involved.
We'd
probably
have
to
refactor
the
tests
in
order
to
account
for
this
right.
A
B
A
B
B
Yeah
but
I
mean
there
are
yeah,
but
we
finalized
different
things
right,
so
we
have
at
least
like
three
or
four
different
finalize
errs
right,
so
the
finalizar
for
for
node
buffer
is
different
from
a
finalizar
for
an
array
buffer
and
it's
different
from
a
finalizar
for
for
attached
data.
So
we
don't.
E
B
A
G
I've
been
working
on
the
vets,
a
functional
copy,
constructor,
breaked
sky
I'm,
not
sure
with
the
current
status
of
the
build,
because
the
the
one
on
github
is
green,
but
I'm
not
sure
the
one
that
you
linked
to
earlier
there
before
I
resolve
the
issues
that
I
believe
that
I
found
right.
One
of
the
the
errors
that
was
on
Mac
was
complaining
about
the
use
of
STD
future
right.
B
That's
usually
the
case
I
I've
run
into
I've
run
into
standard,
or
this
SDL,
no,
not
that
Steele
what'd.
He
call
that
this.
This
Lipstadt
C++
issues
many
times
on
Mac,
like
things
that
are
supposed
to
be
part
of
the
standard,
are
not
they're
missing.
On
Mac
I've
had
this
more
than
once
like
there
was
like
what
was
that
two
integer,
or
something
like
that
was
missing
at
some
point,
so
you
had
to
set
the
Xcode
to
I,
don't
know
what,
in
order
to
to
actually
to
get
like
real
C++,
C
love
and
support.
G
D
A
Basically
we're
building
on
ten
eleven
but
somewhere
I'm
pretty
sure
in
in
our
build
config
we
say
the
target
is
OS
X
10,
eight,
because
that's
how
far
back
we
support
right
right-
and
you
know
we're
thinking
of
upping,
that
for
master
but
for
older
versions
and
I.
Think
even
up
to
it
may
have
been
up
for
right.
I'd
have
to
look
at
the
here.
We
can
actually
go
find
that
I
think
are.
A
A
E
G
A
E
A
C
E
A
A
A
G
G
B
Yes,
yeah
yeah
yeah.
We
can
do
yes,
but
please
have
another
look
because
I
I
I
changed
it
like
after
talking
to
you
I
believe
I
changed
it
to
to
keep
nodejs
six,
but
to
move
it
to
the
allowed
failures
category
so
and
I
had
a
note,
note:
13
I,
don't
know,
maybe
I
don't
know.
Maybe
we
don't
need
it
because
we're
only
testing
LTS,
but
it's
kind
of
the
current
version
of.
A
B
Yeah
yeah,
okay,
good
good,
so
so
so
then
so
then
basically
I
was
going
to
remove
a
node
six
altogether.
But
but
after
talking
to
Nicola,
we
kind
of
decided
to
keep
it
but
to
move
it
to
the
allowed
failures
for
Travis,
so
we're
still
kind
of
keeping
an
eye
on
it,
but
not
really
actively.
So
if
somebody
points
us
to
a
bill
that
failed
on
sixth-
and
maybe
we'll
look
but
but
it's
not
a
priority
right,
okay,
cuz
six
is.
C
E
C
D
E
B
A
I
do
think
it's
worth
talking
about
about
this
one
572
as
well
like
dropping
all
the
deprecated
features.
I
wasn't
sure
we
really
wanted
to
do
that.
Like
we
I
know
we're
doing
assembler
major
release,
but
I
think
we
were
only
sort
of
saying
yeah.
Let's
do
assembler
major,
because
none
of
the
majors
we
thought
would
affect
anybody
right.
No.
B
Yeah
yeah
I
agree
completely
like
I'm
perfectly
fine,
with
leaving
the
deprecated
stuff
in
the
fur
fur
for
another
major
release,
specifically
to
give
to
give
people
some
time.
So
so
this
so
this
semver
major
it
will
truly
be
deprecated
and
then
the
next
one
it'll
be
gone.
I
I
think
I.
Think
VA
does
does
something
similar
as
well.
They
they
crime.
A
Even
like,
is
it
worth
like
rushing
to
pull
it
out
right
because
until
we
pull
it
out,
we
haven't
ever
actually
made
anything.
We
think
is
gonna
break
anybody,
so
I
don't
mostly
tempted
to
just
leave
it
there
yeah,
it's
not
the
preferred
way
to
go,
but
it's
clearly
identified
through
the
files
just
leave
it
there
until
we
run
into
an
issue
where
we
really
can't
right,
yeah.
A
B
A
G
G
C
C
A
G
A
F
C
C
B
A
There
any
complication,
though,
in
C++,
like
it's,
pretty
straightforward
and
see
right
where
each
function
stands
on
its
own.
In
this
case,
is
there
any
cases
where
it's
like
you're
you're,
removing
methods
from
a
class
and
the
class
needs
to
exist
in
both,
but
you
want
to
have
a
subset
of
methods.
I.
B
Don't
have
the
perspective
to
to
tell
you
for
sure
about
everything,
but
I
think
the
attempt
will.
Let
us
know
right
whether
that
is
the
case
of
market
jeopardy.
My
instinct
is
that
it
shouldn't
be
because
you
know
things
are
separate.
You
know
we
are.
We
shouldn't
be
using
like
no
Jo
specific
features
in
any
in
any.
You
know
language
specific
class,
but
if.
A
A
B
A
A
A
A
A
A
B
C
C
A
A
B
A
A
Jim,
you
know
it'll
cuz,
there's
kind
of
the
two
pieces,
one
it's
like
making
making
it
so
that
you
don't
compile
the
only
disadvantage
to
importing
the
full
one
versus
the
subset.
Is
that
you
we
could
make
a
mistake
more
easily
right
yeah,
but
in
theory,
if
we
get
it
right,
it
doesn't
matter.
So
you
know
eight
and
ten
we're
a
little
bit
more
possible
making
mistakes
twelve
and,
on
you
know
we're
protected
by
the
separations.
That's
there.
A
C
C
B
Thing
is
we
we
shouldn't
be.
We
shouldn't
be
relying
on
on
like
the
node
major
minor
versions
in
in
like
the
headers
right,
because
I
mean
we
could
easily
say
you
know
number
if
there's
node
major
version
greater
equals
something
something
that
include
j/s
native
API,
dot,
H,
otherwise,
no
dpi,
dot,
H
right,
but
but
but
I
don't
think
we
want
that
in,
like
the
production,
header
files
right,
because
they're
not
supposed
to
be
dependent
on
any
node
version
right.
B
So
so
we
can't
do
that,
but
I'm
thinking
can
we
maybe
add
some
testing
code
to
that.
You
know
like
number.
If
they're
you
know,
testing
know
that
on
API
then
include
try
to
include
J
as
native
API
alone
and
then
and
then
we
can
define
the
testing
preprocessor
directive
in
our
in
in
the
CI
you
know
or
in
binding
like
in
test
slash
bindings
or
jib,
and
then
when
and
then
when
that
is
defined,
then
it
will
do
the
strict
separation
and
then
we
can
test
the
separation.
B
We
can
test
whether
the
separation
actually
works
on
those
node
versions,
which
we
know
have
the
separated
headers
in
core.
So
so,
yes,
our
production
stuff,
would
have
some
some
testing
stuff
in
there,
but
but
it
would
it
would
help
us
test.
So
we
need
to
expose
this.
You
know
in
order
to
properly
test
it
and
to
make
sure
that
when
we
do
perform
the
separation
that
that
the
separation
is
actually
working,
you
know
before
we
can
actually
publish
the
separation.
B
C
B
So
yeah,
basically
yeah
so
in
production
we
will
include
node
API
dot
H
in
both
X's
because
we
have
to
because
we
don't
know
if
it's
separated
or
not,
but
but
we
can,
we
can.
We
can
guard
the
inclusion
of
node
API
dot
H
with
like
an
if
not
defined,
testing
right.
Otherwise
we
can
include
specifically
J
s
native
API
dot
H.
B
That
testing
thing
will
only
be
defined
when
we're
running
the
test
suite
and
then
you
know
if
we,
if
we
have
separated
things
wrong,
then
the
test
suite
will
fail
to
compile
and
then
we
will
have
our
answer
as
to
what
needs
to
be
fixed
in
the
headers
and
so
forth.
In
order
to
make
that
work.
Okay,
it
should
help
us
with
the
separation,
but.
B
A
A
B
A
B
D
B
A
I
was
saying:
don't
you
know,
don't
test
it
separated
in
ten
and
eight
like?
Oh,
like
basically
we'll
just
ten
and
ten
and
eight
we'll
just
say
you
include
the
node,
yes,
the
full
one,
that's
what
we
use
and
that
old
that'll
mean
whatever
people
use
regards
the
version
is
actually
tested
and
and
the
fact
that
twelve
will
have
it
separated
well
like
most
likely
catch.
If
not,
you
know
guaranteed
you
can't.
Yes,
yes,.
B
A
B
A
D
B
A
B
It's
a
it's
a
it's
a
degree
of
freedom
in
the
build
system,
so
we
can
add
another
degree
of
freedom.
Do
you
want
separated?
You
want
to
try
for
separated,
headers
or
not,
you
know,
and
then
in
our
tests
we
can
try
for
separated
headers
and
we
can
be
pedantic
and
and
always
you
separated
headers,
and
we
can
base
that
decision
on
the
node.js
version
in
binding
chip
of
the
test,
suite
right
and
and
then
we
can
leave
it
up
to
folks
it's
normally
off.
It
normally
includes
everything
right.