►
From YouTube: Node.js N-API Team meeting - Dec 20 2018
Description
B
A
Going
through
the
milestone,
I
think,
though,
the
first
thing
we
should
probably
just
talk
about
is
I
know
a
ruinous
has
mentioned
that
he
has
a
conflict
with
the
current
time.
So
maybe
we
could
talk
a
little
bit
about
if
there's
any
other
times
that
would
still
work
now.
I'm,
just
looking
to
see,
I
asked
him
whether
earlier
or
later
worked.
So
let
me
just
find
that.
A
E
B
C
A
D
A
A
F
I
I
I,
just
remember
one
very,
very
cool
thing
from
the
from
the
discussion
with
Eric,
and
that's
that's
this
idea
that
we
could
use.
We
could
use
a
lambda
functions
to
to
actually
to
actually
do
something
very
similar
to
JavaScript,
async/await
and
I'm,
wondering
how
we
can
fit
that
in
there,
because
that
that's
a
really
worthy
call
I
think,
because,
if
it
would,
it
would
give
it
would
give
folks
of
a
very
good
sort
of
handle
on
on
doing
things
in
a
worker
thread.
That's
the
only
thing
it's
it's
very
vague.
F
A
F
B
F
So
that
that
would
be
huge
because
then
then
you
could
you
could
do
almost
what
JavaScript
does
right?
You
do
the
new
async
and
then
later
you
could.
You
could
even
await
it
or
you
could
or
you
well
you'd
get
the
on
okay,
as
you
do
now,
but
just
just
the
ability
to
use
a
lamp
that
there
would
be
huge.
So.
A
I
guess
maybe
I'd
suggest
open
an
issue
just
to
capture
the
idea,
so
we
don't
forget
yeah
yeah,
that's
a
good
point.
Yeah
I'll
do
that
and
then
you
could
sort
of
tag
that
as
a
separate
thing
to
this
issue
to
this
one
here.
So
once
we've
worked
through
the
the
sort
of
tweaks
to
fix
up
some
of
the
problems
pointed
out.
We
can
look
at
that.
One:
okay,.
A
A
A
The
you
know
and
I
just
saw
it
this
morning,
so
I
haven't
had
any
time
to
think
about
it.
I
I,
for
some
reason,
I
believed
it
wasn't
really
possible
because,
like
then,
would
still
like
nan
doesn't
hide
all
the
types
so
I'm
not
quite
sure
how
you
could
use
any
pie
and
and
fix
the
problems
people
run
into
and
and
if
you
don't
fix
that
part,
then
there's
still
changes,
you're
still
subject
to
the
changes
in
v8
and
so
forth.
So
but
the
discussions
seem
to
be
that
hey.
F
It
correct
me
if
I'm
wrong,
but
but
nan
also
has
a
very
poor
threading
of
the
of
the
isolate
right
like
there
are
a
lot
of
nan
methods
which
don't
take
an
isolate,
and
then
they
just
have
like
a
global.
He
stored,
isolate
or
whatever,
so
that
that
that's
also
kind
of
a
hurdle
when
it
comes
to
an
API
right,
because
we
explicitly
pass
right.
What
is
essentially
the
isolate
around
all
the
times,
though
so
yeah
that
that
could
make
things
brittle
as
well.
I,
definitely.
A
F
A
A
If
it's
not
possible
or
feasible,
we
should
you
know
it
would
probably
be
good
to
figure
that
out
that
you
know
it
came
out
of
a
discussion
where
there's
an
issue
opening
core
that
says
these
modules
are
gonna
break.
When
we
go
to
go
to
12
and
it's
it's,
you
know
the
Holy
Grail
would
be
if
men
used
napi
under
the
covers
and
magically
hit
everything.
Well,
then
you
get
all
the
modules
we
haven't
managed
to
get
to
move
over
here
right
well,.
C
F
B
F
And
then,
and
then
nan
itself
would
would
would
find
that
transparently
available.
But
but
it's
that's
that's
also
like
a
huge,
huge
task.
Yeah
you
know,
I
was
I
was
working
my
way
through
through,
like
the
the
add-on
examples
that
were
using
v8
and
and
just
basically
replacing
the
the
just
using
my
include
file
instead
of
the
v8
dot.
H
include
file
and
then
and
then
doing
like
doing
like,
like
an
inline,
a
replacement
for
all
the
VA.
B
A
F
There's
a
problem:
yeah
you'd
have
to
you'd,
have
to
stub
out
everything
that
nappy
doesn't
support
and
complete
the
v8
RH
file
that
way
and
then
and
then
we're,
and
then
you
know
that
would
only
work
for
modules
which
happen
to
use
things
that
are
covered
by
an
API,
but
but
yeah
III.
Don't
think
there
is
there
way
to
well
I
shouldn't
say
there
is
no
way
those.
There
are
a
lot
of
v8
api's,
which
are
basically
just
like
global
static
functions.
F
B
F
So
so
it
the
coverage
would
be
imperfect,
no
matter,
no
matter
whether
we
end
up
rewriting
nan
or
portions
of
man
to
use
to
use
an
API
or
whether
we
end
up
writing
a
v8
shim
that
that
is
backed
by
an
API.
It
would
be
imperfect
and
it
would
cover
some
module.
Some
modules
will
happen
to
work
because
they
happen
to
not
use
and
write.
B
F
F
Gist
man,
but
exactly
yeah,
so,
but
the
fact
that
that
that
somebody
is
asking
for
this
means
that
that
there
is
desire
to
move
to
nan
in
some
way,
shape
or
form
and
of
course,
and
of
course,
add-on
developers
are
realizing
that
that
the
the
burden
is
a
lot
less
on
them.
If,
if
they,
if,
if
man
were
backed
by
an
API,
because
then
they
could
claim,
okay,
I
have
an
API
support
and,
and
my
work
here
is
done.
Yeah.
A
Well,
this
even
comes
from,
like
you
know,
in
the
node
project,
we've
got
things
which
we
are,
which
are
failing
due
to
v8
changes
and
so
they're.
You
know
it
came
in
I,
don't
know
how
nan
got
pulled
into
the
discussion,
but
you
know
you
can
it's
it's
not
even
the
module
maintainer
z--,
but
us
knowing
that
things
will
break
and
saying.
Well,
how
do
we
avoid
that
yeah.
F
F
Much
exactly
and
suppose
suppose
we
release
a
version
of
man.
Right
I
mean
that
can
break
modules
to
because
now
we
were
saying
let's
say
we
have
a
nan,
3.0
right
and
then
and
then
modules
will
upgrade
to
that
and-
and
you
know
we'll
get
feedback
saying.
I
can't
really
move
to
nan
three
because
of
this
this
and
that
you
know
and
we'll
have
to
say,
yeah
sorry,
then
you'll
have
to
stay
with
2.0
and
and
deal
with
the
breakage
like
that.
A
A
F
F
You
know
I,
don't
want
to
I,
don't
want
to
have
to
learn
how
man
does
that
you
know
right,
yep
and
and
in
the
and
and
I
know
that
man
does
it
correctly
for
v8,
because
it
does
end
up
passing
the
isolate
in
the
end
to
all
the
all
the
v8
api's
that
need
it
right.
So
somehow
nan
does
it
great
for
nan
and
now
all
that
it
would
have
to
do
is
store
the
end
instead
of
the
isolate
and
use
its
existing
magic
to
pass
that
everywhere
and
sorry.
F
F
A
F
A
F
A
My
main
motivation
here
was,
you
know:
I,
don't
I,
think
it's
big
enough
thing,
we're
not
gonna
solve
it,
but
it
seemed
like
there
was
a
discussion
going.
We
should
probably
understand
it,
and
at
least
chime
in
and
you've
already
relayed,
a
bunch
of
things.
I
think
would
be
interesting
to
chime
in
with
right,
yeah
yeah
yeah,
you
know
like.
Basically
your
suggestion
is
well
you
shouldn't.
A
F
H
yeah
right
so
yeah,
okay,
I,
think
I
got
I,
got
all
the
way
to
things
like
like
references
and
week
callbacks
and
that
kind
of
stuff,
so
yeah
yeah,
like
exceptions,
are
done.
Obviously
the
the
thunking
is
done,
which
is
really
strange
because
I
mean
you're
going
from
from
something
that
looks
like
VA
to
something
that
goes
like
that
that's
nan
and
then
back
to
b8
yeah.
F
Actually,
actually,
on
our
side
like
on
the
shim
side,
we
it
need
not
be
any
and
I,
don't
think
we
need
to
copy
things
that
anymore,
because
the
the
on
the
v8
side
it
uses
what
looks
like
an
array
right,
and
it
has
like
the
the
square
bracket
operator
and
and
in
the
interim.
The
square
bracket
operator
could
just
be
like
a
memory
offset.
So
so
in
that
sense,
it
shouldn't
add
too
much
more
overhead
right.
C
F
B
F
B
F
And
so
basically,
if
we
want
to
implement
this,
it
would
that
the
function
template
would
end
up
having
to
be
like
a
like
a
collection
object
which
calls
neppy
defined
class
in
a
very,
very,
very
lazy
fashion,
because,
unlike
v8,
you
know
once
you've
called
Nappi
defining
class.
That's
it.
You
can't
add
any
more
methods
yep.
So
so
then,
so
then
this
turns
into
quite
a
quite
certain
sort
of
a
caching
the
plates
before
they
fall
exercise.
B
A
You
know
if
you
have
something
using
well
like,
for
example,
and
that's
something
where
maybe
and
then
you
could
then
I
don't
know,
maybe
there's
an
entry
pointer
right,
I
guess
what
I
was
gonna
start
on
if
like,
if
that
was
the
only
problem,
I'm
sure
there's,
like
you
know,
if
you
said,
oh
and
here
you
add
in
one
method,
call
extra
method
call,
and
now
it
works:
okay,
okay,
yeah.
So
so
so
some
right.
F
A
F
Right,
you're
right,
you're,
right,
yeah,
yeah,
yeah,
that's
true
yeah,
but
but
I
guess
I
guess
we
can
be
lazy
enough
about
about
adding
that
step
as
a
function
of
how
many
add-ons
need
that
step.
So
so,
if
this
happens
to
work
for
like
90
percent
of
the
add-ons
right
and
then
the
we
can
publish
it
like
this
and
then
add
the
step
for
the
remaining
10%
exactly
or
I
mean
you
know,
it
may
even
be
as
simple
as
having
them
rearrange.
The
code,
like
you
know,
don't
define
any
more
functions
after
you've.
F
F
A
A
F
B
A
A
A
F
A
That
sounds
good
till
really
Alice
I
just
put
that
there,
so
that
we
don't
forget-
and
it
sounds
like
we
you've
got
some
good
work
we
can
do.
The
next
issue
is
SQL
late,
nappy,
port
288,
so
I
have
talked
to
any.
She,
unfortunately
she's,
not
making
too
much
progress
and
I
haven't
really
had
enough
time,
like
I
I,
think
I'm
at
the
point
where
I'd
probably
have
to
spend
at
least
four
hours
in
a
row,
which
is
what
I
have
trouble
getting
to
understand
how
the
a
synchronous
asynchronous
function
is
working
there.
A
We
did
work
through
some
of
the
cases
which
looked
pretty
straightforward
and
I,
think
she's
gonna
start
changing
those,
but
there's
a
tracing
I
said
of
tracing
functionality
where
it's
it
there's
enough
wrapper
an
indirection
that
it's
unclear
how
it's
how
it's
working
like.
We
found
two
methods
that
basically
say
this
runs
on
the
the
separate
thread.
This
runs
on
the
main
thread,
but
it's
totally
not
obvious
how
that
happens.
A
B
A
D
A
A
No,
that
would
be
good,
so
we'll
get
you
involved
in
that
and
but
next
time
I
get
together
with
her
to
sort
of
discuss
the
status.
I'll,
try
and
pull
you
in
there
as
well.
Cuz,
okay,
I,
I!
Think
it's
something
that
you
know
for
me.
It's
just
the
challenge
of
finding
a
big
enough
block
of
time
to
yeah
push
it
forward
and
if
you
can
help,
that's
really
good.
Okay,.
A
Next,
one
burned
down
a
list
of
issues
raised
by
module
owners
and
burned
down
list
of
issues
in
node,
repo
I,
don't
know
if
there's
any
particularly
hot
ones.
We
should
talk.
B
F
F
Yeah
I,
like
I
I,
just
I,
just
looked
at
I,
just
looked
at
the
issue
like
the
pull
request
that
they
closed
with
right
with
that,
when.
F
F
A
B
F
In
which
repo?
And
yes.
A
A
B
A
B
F
Set
nappy
version:
two
three:
okay
I'm,
just
following
the
commits
in
level
down:
okay,
oh
I,
think
this:
is
it
540
ya,
nabi,
rewrite
okay,
so
okay,
copy
link,
location
and
we
go
here
and
let's
see
level
down,
okay,
so
Oh
edit
level
down
till
that
tilde,
tilde,
tilde
and
bracket
boom
date
comment:
excellent,
okay,
yeah,
so
I
just
crossed
it
out
and
and
I
put
in
brackets
the
the
PR
that
moved
it
to
anything.
F
Bat
things
what
you
refreshed
and
we
had.
We
now
have
two
things
crossed
out:
okay,
that
is
good,
yeah
and
actually
I
convey
we
we
have
a.
We
have
a
PR
from
the
napi
workshop,
but
it's
kind
of
just
sitting
there,
because
the
person
isn't
following
up
so
I,
don't
know.
Maybe
we
need
to
follow
that
one
up
or
something
and
I
think
that's
that's
been
over.
Twice
is
PR
or
that's
been
notices
repo.
So
maybe
we
can
talk
to
him
because.
F
A
A
A
F
But
but
it
like,
essentially
it's
like
ninety
percent
ready
right.
So
is
it
the
original
author
of
the
PR
who's
not
responding
or
Ben?
Yes,
yes,
yes,
I
mean
I
was
sitting
next
to
him
in
America,
and
we
do
this
together
right,
but
now
we're
not
sitting
together
anymore.
So
I
can't
really
poke
him
and
brought
him.
You
know
it
may
have
been.
It
may
have
been
their
free
time,
so
so
I
don't
know
how
how
how
much
time
they
have
for
a
follow-up
right.
How.
F
C
A
A
F
All
for
one
I
can
offer
another
success
story
or
potential
one
I
mean
not
not
another
add-on
that
was
ported
but
in
general,
I
believe
and
correct
me
if
I'm
wrong-
and
this
is
maybe
something
we
should
announce-
maybe
during
the
TSC
meeting,
because
you
know
we
have
that
announcement
section
is
that
we
can
now
claim
that
native
add-ons
are
as
stable
as
pure
JSON
add-ons.
Why?
F
So
basically,
if
you
write
the
native
add-on,
it
will
it
and,
of
course,
if
you
follow
the
guidelines
for
native
add-ons
now
you
can
you
can
load
it
just
like
a
JavaScript
ad
on
just
to
safely
across
any
number
of
node
major
versions
and
it'll
get
cleaned
up
properly,
along
with
the
rest
of
the
the
JavaScript
engine
when
the
threat
shuts
down.
So
so
we
are,
we
are
as
close
to
being
on
par
with
native
JavaScript
or
with
with
pure
JavaScript
modules,
as
probably
we
ever
will
get
as
far
as
I
can
tell
I.
Think.
A
F
A
Lately,
if
you
want
to
write
that
write
that
blog
post
I'm
I'm,
like
90%
sure
the
the
people
at
the
foundation
will
say
yeah
sure
we'll
publish
that
okay,
so
you
know
I
wait
for
it.
I
says
you
know
you
write
it.
We
just
passed
it
by
the
TSC
to
make
sure
nobody
has
any
any
issues
and
then
I
can
help
coordinate
with
the
the
reps
at
the
foundation
to
get
it
to
get
it
to
go
out.
Okay,.
B
F
F
A
F
A
F
Yes,
yes,
I
was
actually
that
we
have
a.
We
have
a
long-standing
PR
in
know
that
on
API,
for
for
removing
or
for
starting
to
make
use
of,
void,
star
parameters
for
property
descriptors
and
it
we
it's
been
approved
since
I
Tober,
so
which
we
should
probably
land.
That
and
I
was
just
doing.
Some
I
was
doing
it
on
on
nightly
and
I
was
gonna.
Do
the
other
okay.
F
A
A
Any
other
earth
I
know
there's
a
bunch
of
issues
and
discussion,
but
if
there's
any
others,
we
should
highlight
and
talk
about.
Oh.
B
F
B
F
Option
to
four
four
four
four
four
recursive
look
there
right
and
that
ended
up
being
some
ver
minor,
even
though
mcdeere
didn't
change
in
any
way.
Now.
Okay,
I
understand
that
that
the
signature
of
the
options
object
is
like
an
explicit
change,
but
but
in
this
case
we
are,
we
also
have
an
explicit
change
right
because
it's
the
it's
the
it's
JavaScript
type
of
the
of
the
array
buffer
that
you
pass
in
whether
it's
an
array
buffer
or
a
shared
array
buffer.
That
is
also
a
flag
right
to
JavaScript.
So
that
would
be
some
reminder.
F
A
F
F
Yeah
yeah
yeah
so
like
if
you
this
is
a
this
becomes
especially
pointed
if
you
have
an
ad
on
that
that
just
uses
the
typed
array
but
doesn't
actually
create
the
buffers
itself,
it
accepts
a
type
array
from
JavaScript
and
it
just
does
stuff
with
it
right.
You
know,
including
retrieving
the
backing
store
right,
and
so
so,
as
things
stand
now,
it
would
be
an
app
you
get
typed
array
info
right
and
that
would
that
would
return
an
array,
buffer
and
and
the
add-on.
F
A
F
F
A
F
Right
the
test,
but
but
yeah
it
would
probably
fail,
but
I,
don't
think
I,
don't
think
we
should.
We
should
add
if
that's
into
the
into
the
implementation,
like
so
far,
we've
assumed
that
the
implementation
is
built
against
snappy
experimental
so
that
the
implementation
is
always
maximal
right.
So
everything
everything
must
be
available,
because
some
module
on
there
could
be
building
would
not
be
experimental
right
right.
When
we
build
nodejs,
it
has
to
have
all
the
experimental
stuff
right.
A
Yes,
I
I
was
thinking
in
what
six
yeah
okay
I
see
what
you
mean
like.
F
A
F
But
basically
I
think
there
is
a
solution
it
may
it
may
not
be.
It
may
not
be
as
clean
as
we'd
like,
but
I
think,
if
we,
if
we
create,
if
we
create
an
API
like
you
know
like
something
like
nappy,
create
shared
type
array
which
accepts
only
a
shared
array
buffer,
then
then
that
solves
the
problem
you
know
of
dealing
with
with
with
typed
arrays
back
by
shared
array.
Buffers
then,
and
that
creates
a
that,
creates
a
completely
new
chunk
of
API,
which
looks
almost
identical
to
the
to
the
typed.
B
A
F
B
F
F
A
F
The
only
the
only
problem
and-
and
this
is
I
also
mentioned
this
in
the
comment-
and
one
thing
we
should
look
at
because
I
don't
even
know
how
you
do
this
in
v8
like
if
you
get
a
typed
array
from
JavaScript,
and
you
retrieve
the
info
right.
How
do
you
determine
whether
whether
the
stuff
that
you
got
back
is
an
array
buffer
or
a
shared
array
buffer?
F
You
know
it
doesn't
matter,
though,
exactly
yes,
so
so,
if,
if
shared
array,
buffers
will
will
will
pass
through
as
if
they
were
array
buffers,
then
you
in
you
can
call
the
N
API
get
array
buffer
info
to
retrieve
the
actual
pointer
and
all
that
stuff
on
a
shared
array
buffer.
If
the,
if
the,
if
the
engine
makes
them
transparent,
then
we
can
do
this
with
like
semver
patch.
You
know,
because
then
what
that
means
is
that
we
wrote
our
type
checking
things
to
be
too
specific.
F
A
F
That's
right,
yeah,
yeah
and
I
mean.
How
do
you
even
distinguish?
You
know
if
all
you
deal
with
is
all
you
do
if
all
you
deal
with
this
typed
array
is
coming
in
from
JavaScript
actor
is
which
you
did
not
create
right
right
and
about
which
you
you
cannot
assume
what
they
are
backed
with,
and
yet
you
need
to
retrieve
the
data
behind
them.
Then
how
do
you
do
it
so.
F
A
F
B
F
A
F
Yeah
see
we
say:
well,
actually
we
don't
assert,
but
we
call
like
we
call
buffer
equals
array
arrow
buffer.
So
we
so
we
call
the
buffer
method
of
the
typed
array,
object,
instance,
and
but
I
like
you
know,
can
you
is
it?
Is
it
safe
in
v8
to
call
our
array
arrow
buffer?
If
that
buffer
is
a
shared
array
buffer
or
you
know,
because
that
that
function
isn't
there?
Maybe
that
that
thing
returns
on
the
array
buffer
directly
a
v8
local
v8
array
buffer,
you
know.
So
what
happens?
Is
the
typed
arrays,
backed
by.
A
F
F
A
F
Wait,
sorry,
I'm.
Sorry,
there
is
one
thing
that
there
is
one
thing
we
need
to
fix.
We
have
in
Napa
create
typed
array.
We
have
returned
status
if
faults
and
value
is
array
buffer,
not
being
valid
art,
so
that
would
be
wrong.
That
would
be
a
bug
because
it's
not
an
invalid.
Our
gif.
It's
a
shared
array,
buffer
right
right,
so
we'd
have
to
change
this
to
return
status.
If
false
and
value
is
array,
buffer
or
value
is
shared
array
buffer
right.
So.
F
A
A
F
F
B
F
Write
a
test
that
just
creates
a
the
traits,
a
shared
array
buffer-
it's
gonna
be
one
of
those
hybrid
v8
snappy
tests,
because
I'm
just
gonna
cast
the
resulting
value
as
a
as
an
a
p-value
and
then
and
then
see
if
it
passes
through
all
our
api's,
and
if
it
does,
then
we
can
fix
our
api's
to
actually
accept
shared
array.
Buffers,
okay,
okay,.
F
Yep
yep
and
then
that
that
should
do
that
should
clarify
what
we
need
to
do,
because
the
alternative,
correct
me
if
I'm
wrong
is,
is
this.
Is
this
a
templated
approach
where,
where
we
pass,
where
we
passed
our
inability
to
deal
with
them
transparently
through
to
the
native
side
and
then
and
then
to
create
a
typed
array
using
a
shared
array,
buffer
becomes
a
separate
function,
and
that
too,
will
pass
through
the
experimental
towards
version
number
pipeline
I
mean.
A
It's
more
than
once,
you
use
it
once
you've
got
one,
you
should
be
able
to
use
it
without
having
to
know
which
type
it
is
and
well
you're
right.
If
there's
some
there's
some
reason.
Why?
That's
not
true,
then
we
just
it's
but
regardless
of
the
implementation
behind
the
scenes.
It's
like.
Okay,
it's
a
new
API.
Yes,.
A
A
If
not,
let's
move
on,
because
we've
only
got
six
minutes
left
anyway,
create
matrix
of
tested
methods.
I
think
Anisha
did
mention.
She
asked
me
for
other
things
to
look
at
well
over
Christmas
cuz
she'll
have
time
I
won't
be
around
I
pointed
her
at
that
I.
Don't
know
that
there's
been
too
much
else
added,
but
I
haven't
had
time
to
look
so
I.
Don't
know
if
there's
anything
to
talk
about
on
that
front.
E
A
That's
great,
it's
good
to
get
that
updated
and
then
the
last
issue
there
is
how
we
should
advocate
the
use
of
badges
I.
Think
there
was
a
comment:
the
you
added
gabriel's
just.
We
need
to
P
that
PR,
that
into
our
own
repo
I
think
there
was
discussion
in
the
NA
PR.
In
the
note
core
repo,
where
there
wasn't
really
people
didn't
think,
was
a
good
idea
to
do
it
there.
So
we
should
just
do
it
in
our
repo
right
yeah.
F
Yeah-
and
the
other
thing
we
were
talking
about
last
week,
was
the
maybe
like
during
one
of
our
workshops
like
RN
API
workshops.
We
should
we
should
maybe
make
it
part
of
the
PR
that
that
the
person
submits
to
to
the
module
that
they
add
the
thing
to
the
readme
file.
Like
add
the
batch
to
the
readme
file,
yeah.