►
From YouTube: Node.js N-API Team meeting - July 6 2020
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
B
C
B
D
A
A
D
A
E
F
A
Okay,
that
sounds
good,
so
maybe
we
can
take
a
look
this
week
and
come
back
next
week
and
discuss
whether
we
think
it's
time
or
not,
but
I
mean
or
even
just
discussing
that
other
issue
that
we
opened
like
we
should
take.
You
know
whoever
gets
the
chance
to
take
a
look.
First
can
take
a
look
and
say:
yeah,
there's
been
some
stuff:
let's
do
one
or
whatever
makes
sense.
A
B
A
D
A
B
The
ones
I've
seen
will
they'll
they'll
broadcast
it
and
then
they'll
have
a
chat
channel
and
then
the
the
presenter
is
available
on
the
chat
channel.
So
people
might
ask
questions
on
the
chat
channel
and
then
the
the
presenter
can
respond
in
real-time,
as
the
video
is
playing
is
where
I've
seen.
But
for
us
it
might
be
helpful
if
we
have
the
ability
to
break
out.
So
if
somebody
needed
hands
on
hands
in
our
one-on-one
help
that
we
could
direct
them.
Okay
go
to
this
same
channel
and
an
expert
will
be
waiting
for
you.
Yeah.
A
G
B
A
A
Sort
of
like
it'd,
be
more
like
the
workshop
is
on
add-on
development
for
nodejs
and,
like
that,
you
know,
will
will
take
you
through
the
key
things
you
need
to
know
and
some
and
some
key
examples
for
what
you
will
want
to
do
when
building
a
native
add-on.
So
as
opposed
to
saying
any
PI
add-ons
just
say
you
know,
you're
building
an
add-on
for
node.
This
workshop
is
gonna
help.
You
understand
that
right,
yeah
and.
A
G
A
A
A
It's
more
of
just
like
hey,
you
want
to
write
add-ons.
Maybe
it's
even
like
you
know
a
little
bit
around
why
you
want
to
write
add-ons
yeah
and
then
you've
got
that
middle
paragraph
has
some
of
the
key
things
about
like
context,
awareness
or
I'd
say
functions
right
and
the
last
one
can
be
just
be.
You
know
this
workshop
is
brought
to
you
by
the
N
API
team
or
whatever,
but
perfect.
G
A
Like
the
you
know,
the
intro
should
just
maybe
be
you
know,
and
not
too
long,
but
like
what's
new
on
this
front
and
then
yeah
the
the
the
workshop
takes
people
through
from
the
basics
all
the
way
up
to
the
the
end
yeah
the
tutorials
yeah
cuz.
We
don't
need
too
much
of
an
intro,
like
some
workshops.
Don't
have
any
it's
kind
of
like
okay
dive
in,
but
I
do
think
some
some
intros
good,
because
I've
had
feedback
from
people
on
different
ones.
That
mm-hmm
like
frame
frame.
A
A
G
That
even
happen
didn't
release,
but
the
big
question
is
yeah,
exactly
like
you
said.
If
we
need
to
if
we
need
node
in
debug
mode
as
well
and
ideally
I
think
we
should
have
it
right,
but
that
that
means
that
we
would
have
to
build
node
as
well.
Prez
know
that
on
API
right
and
that's
that's
a
rather
large
job
yeah,
it's
a
significantly.
A
G
D
G
Of
that
short
of
that
having
you
know,
if
we
do
have,
if
we
do
have
a
core
CI
job,
that
if
we
do
end
up
having
a
core
CI
job
that
tests
in
debug
mode,
then
it
would
be
kind
of
wasteful
to
then
throw
away
those
binaries
that
have
been
built
with
debug
symbols.
You
know
it
would.
It
would
almost
make
sense
to
just
store
them
somewhere,
so
that
we
can
use
them
downstream
right
and
then
not
have
to
rebuild
them,
but
then
again
that
that
is
also
a
sort
of
an
infrastructural
change.
Yeah.
G
G
A
A
C
A
G
D
G
A
G
E
A
G
G
A
So
let's
keep
this
on
our
list
I'm
going
to
it's
tagged
in
our
agenda.
So
if
people
have
time
to
look
at
it,
I
think
this
would
be
our.
The
first
thing
we
should
look
at
is
getting
enabled
in
core.
Then,
following
that
we
could
look
at
enabling
a
debug
version
where
we
build
node
and
the
the
add
ons
in
debug
mode,
yeah,
okay,
okay,
so,
let's
just
say:
first
step,
first
step.
D
A
Yeah
and
like
if
we
do
all
the
combinations
that'll
add
up
to
a
lot
more
testing,
which
is
not
impossible
but
like
we
only
run
the
debug
mode
for
regular
node
in
one
in
on
one
platform,
so
I
think
that's
okay
and
then,
if
we
just
do
it
I
don't
know
that
we
do
that
for
old
were
I.
Guess
we
probably
do
do
it
for
like,
if
we're
doing
a
10
or
12,
but
I.
A
C
G
G
H
B
So
I
have
been
continuing.
My
work
on
the
Gatsby
implementation
and
I
have
been
able
to
successfully
publish
the
site
on
my
fork
using
github
pages,
so
we
we
are
now
able
to
publish
it
on
github
pages.
Okay,
so
my
my
plan
now
is
to
do
a
PR
on
to
our
examples,
repo
of
the
get
of
the
of
the
github
of
the
gatsby
directory,
the
directory
that
has
all
the
gas.
D
B
In
it
and
then-
and
then,
if
there's
not
an
objection
from
the
group,
I
would
like
to
publish
it
on
the
examples
on
our
exam,
those
repo
okay.
So
the
technique
we
use
is
we.
We
use
the
idea
of
a
github
pages
branch,
and
this
is
an
orphan
branch.
It's
just
a
branch
all
by
itself.
It
doesn't
share
anything
with
master
at
all.
B
B
Yes,
now
the
one
there
there
was
one
request
to
do:
search
and
and
I
looked
at
that
exhaustively
and
for
somebody
I'm
convinced
at
this
point
for
somebody
who's
who's
familiar
with
Gatsby.
It's
not
that
difficult,
a
test
to
put
in
there,
but
it
requires
an
understanding
at
Gatsby
and
and
that's
just
not
what
I'm
able
to
do
at
this
point.
B
B
They,
the
nodejs
dev
site,
does
not
have
search
okay,
the
one
thing
the
one
thing
we
have
is
this
idea
that
we
can
pull
in
live
code
into
the
pages
existing
source
code
and
that
might
be
of
benefit
to
the
to
the
other
project
to
the
nodejs
dev
group.
We
could
show
them
how
to
do
that
so
anyway,
that's
that's
my
plan.
Okay,.
A
B
A
B
B
A
B
B
Okay,
so
what
I
did
is
I
adopted
a
theme
that
that's
focused
on
documentation,
so
that
that
would
you
have
that
theme
then,
as
long
as
you
make
markdown
files
that
are
compatible
with
that
theme,
then
there's
really
not
that
much
work
to
do
the
work
that
I
did
is
getting
getting
another
Gatsby
plugin
that
where
you
could
specify
your
source
file
and
then
it
brings
that
source
file
into
a
code
block.
So.
D
D
F
A
B
A
A
C
D
D
D
A
A
Right,
like
I,
don't
think
it
was
asking
about
documenting
no
Dino
API
itself,
but
like
say
the
package
exports
two
or
three
things
and
that's
a
bit
different
I
mean
that's
it,
but
it's
the
same
as
with
any
package
that
you
know.
I,
don't
know
that.
There's
things
that
automatically
tell
you
what
the
exports
functions
are
right.
D
H
A
D
A
Because,
like
there
are
functions
and
classes
exported
by
a
package
right,
they
you
know
so
basically,
yes,
you
have
an
API
in
JavaScript.
That
is
what
you
actually
use
from
the
module
C++.
Is
that
really
doesn't
matter
to
the
JavaScript
so
for
the
JavaScript
user?
What
they
probably
want
is
some
sort
of
JavaScript
documentation
of
those
methods.
A
A
B
A
H
E
D
B
D
A
D
F
F
E
B
D
E
D
D
E
A
We
don't
know
let.
B
B
D
D
A
A
Yeah
I
think
the
originator
had
said
they
checked
the
prototype
chain
and
it
looked
okay,
but
there
clearly
like
under
Jess.
They
seem
to
be
different
objects
because
I'd
done
some
instrumentation.
That
said
like,
if
you
run
under
just
even
using
instance,
instance
of
told
me,
they
were
different,
yeah
right
so
like
if
you
run
on
your
own
and
if
you
run
outside
adjust,
it
says
nope.
These
are
the
same.
A
E
G
A
D
A
That
I
I
think
your
you
know
when
you
open
the
issue.
I
was
like
yeah,
that's
exactly
what
we
should
do,
because
they
should
be
able
to
answer
that,
like
you
know
very
quickly
right,
if
you
know
just
you
should
know.
Yes,
they
tamper
with
them
or
they
don't
tamper
with
them
or
whatever
right,
whereas
for
us
to
try
and
figure
out
the
same
thing,
that's
probably
going
to
be
a
lot
of
work
yeah.
So,
okay,
so
we'll
see
what
comes
from
that
one.
A
That
was
quite
interesting,
though
a
callback
and
object
that
finest
removable.
A
D
G
Yeah
yeah
we
found
the
by
Adi
I
mean
I
I
added
these
tests,
just
because
we
should
test
all
the
other
branches
right
just
to
increase
the
branch
coverage.
But
when
we
added
when
we
had
a
test
like
these
just
spontaneously
in
the
past,
we
did
uncover
bugs
I.
Don't
think
this
one
uncovered
anybody!
It's
good
news,
yep.
G
G
A
G
So
you
can
just
get
your
data
using
variables
that
are
local
to
the
instance,
and
so,
but
you
know
to
avoid
duplicating
all
the
other.
You
know
nappy
function,
you
and
and
property
descriptor,
and
all
that
I
realized
that
object,
wrap
already,
has
all
the
methods
and
stuff
that
you
need
right,
because
it
has,
like
instance,
method
instance,
access
or
an
instance
value
right
and
those
methods
they
receive
a
C++
object
instance
as
their
this
right
as
their
C++.
This,
not
the.
F
G
And
so
so
you
know,
if
you
were
to
rip
out
all
the
instance
stat
a
instance
access
ur
instance
method
and
an
instance
value
into
its
own
class.
Then
you
can
write
the
second
subclass
of
it,
one
of
which
is
object,
wrap
right,
so
object,
wrap,
becomes
a
subclass
of
this
I'm
sorry
becomes
an
object,
wrap
becomes
a
subclass
of
this
new
class,
okay
to
be
specific
and
and
and
so
can
add
on
right,
and
then
you
can
say
things
like
you
know.
My
add
on
you
know,
instance
method,
and
then
that's
your
binding.
G
G
Does
it
basically
rips
apart
the
object,
rep
class
and
and
create
and
injects
a
new
base
class,
for
it
called
a
call
instance
wrap,
which
is
also
templated,
just
like
object,
wrap
and
then
it
creates
a
subclass
of
instance,
wrap
called
add-on,
which
is
also
templated.
The
same
way
that
object
is
and
the
only
difference
between
between
object,
wrap
and
an
add-on.
G
Is
that
an
object,
wrap
you
unwrap
the
JavaScript
this
to
retrieve
the
C++
instance
before
you
call
the
C++
instance
method,
whereas
in
add-on
you,
you
Napa
get
instance
data
to
retrieve
that
same
pointer,
because
that's
stored
on
the
it's
stored
on
the
environment,
not
on
any
JavaScript
object
right
and
that's
it
other
than
that
you
can
reuse.
Although
all
the
methods
that
object
wrap
used
to
have
that
there
are
now
in
this
in
the
superclass,
so
that
you
can
reuse
it
in
two
different
places.
So
that's
the
idea.
G
Data
requires
a
template
parameter
so
that
it
knows
what
to
cast
the
resulting
pointer
to
right
and
if
you
accidentally
pass
the
wrong
class,
because
you
know
you're
lost
in
a
myriad
of
C++
classes,
then
you
get
a
sect
fault
or
very
mysterious
seg
fault.
And
then
you
know
you
have
to
track
that
down,
whereas
if
you
do
it,
this
way
provide
it's
a
nice
clean
abstraction
right,
it's
it's!
It's
an
instance
of
an
add
on
and
and
you're
in
it
is
just
an
it's
just
a
factory.
G
In
fact,
I
wrote
the
macro
where
you
just
give
it
the
class
name
saying
this
is
my
add-on.
This
is
the
name
of
the
class
that
represents
my
add
on,
and
it
will
instantiate
it
for
you
and
and
and
you
can,
you
can
ice
nicely
and
cleanly
like
you,
do
with
define
class
in
an
object,
wrap
there
is
define
add-on
for
it
for
add-ons
which
do
all
the
decorating
for
you.
So
that's
the
that's
the
skinny
on
it.
Basically,
okay
and
so.
E
G
A
D
A
D
G
And
that
will
have
you
use
get
instance.
You
can
still
use
get
instance
data
right.
They
retrieve
that
instance
of
your
class
all
right
so
so
it
doesn't
preclude
that,
of
course,
if
you
do
it
that
way,
then
you
don't
have
access
to
the
private
stuff
right
which,
which
you
know,
which
you
can
argue,
is
good
or
bad
or
whatever,
but
I
mean
you
are
in
control
of
your
add-on.
So
yeah.
G
G
There
is
one
aspect
which
this
doesn't
cover,
which
is
static
methods
in
an
object,
wrap
if
you
have
an
object,
wrap
with
that
has
like
a
if
you
have
a
JavaScript
class
that
has
a
static
method
that
is
backed
by
a
native
class
using
object
wrap.
Then
there
is
absolutely
no
way
to
avoid
having
that
method
be
static.
G
On
the
C++
side,
meaning
you
have
to
get
instance
that,
and
you
have
to
cast
to
the
right
point
or
yourself,
because
the
method
is
static
and
and
so
it
will
not
read,
it
will
not
receive
of
this
no
matter
or
C++
this,
no
matter
what
you
do
right.
So
that's
that's
the
only
thing
this
doesn't
cover.
This
is
alright
and.
G
Well,
well,
I
mean
you
know,
nothing,
nothing
prevents
you
from
using
object,
wrap
you
know
and
and
then
just
defining
the
the
resulting
class
constructor
as
one
of
the
properties
of
your
add-on
right.
So
if
you,
if
you
scroll
down
a
little
bit,
it
says,
define
add-on
right.
You
have
instance
method
and
you
have
instance
value
right.
G
So
at
instance
value
it's
a
sub
object,
defined
property,
snappy,
object,
new
and
then
decorate
the
Nappy
object
new
right,
but
nothing
prevents
you
from
from
from
you
know,
doing
defined
class
there
instead
of
defined
properties
right
and
then
you
just
assign
to
the
sub
object.
You
assigned
a
constructor
that
you
get
from
from
your
from
your
object,
rep
class
and
then
expose
that
anything.
G
A
G
D
G
Functions
that
it
creates-
and
we
would
say,
define
add-on
instance,
value
dysfunction
instance
value
that
function
instance
for
that
function.
You're
done
and
you're
not
really
using
you're,
not
really
using
this
class
at
all
right
because
you're
just
defining
three
values
which
which
are
that
but
right.
G
From
from
from
clearing
that
using
an
instance
method
on
the
add-on,
rather
than
using
a
P
function,
you
because
right
side
nappy
function
new.
You
have
to
retrieve
the
instance
that
of
yourself
right,
whereas
if
you
do
it
with
instance
method,
you
get
that
for
free,
because
they
are
instance,
methods
of
your
C++
class.
F
G
A
G
G
G
G
But
if
you,
if
you're
gonna,
call
nappy
get
instance
that
I
anyway,
then
you
might
as
well
just
make
it
an
instance
method.
With
this
change,
you
know:
cuz
you're
gonna
be
paying
that
price
anyway
right
and
then
you
know
this
way,
you
avoid
you
avoid
passing
a
template
parameter
to
navigate
instance,
data
which
may
or
may
not
be
wrong
right.
G
A
G
I
mean
a
lot
of
the
code.
Change
is
basically
like
you
know
just
moving
stuff
around,
so
so
that
makes
it
really
confusing,
even
though
it
doesn't
need
to
be
so
so
I
was
thinking
to
reduce
the
diff
I
I
could
I
could
restore
the
order
in
which
these
these
these
methods,
implementations
were
declared
because
I,
like
I,
moved
them
around
like,
for
example,
this
instance
Rapti
right.
It's
basically
just
renaming
object,
wrap
t
to
instance,
wrap
t,
because
now
it's
a
method
of
a
different
class
right.
D
G
I've
moved
it
elsewhere
in
the
code,
it
like
blows
up
the
dish.
So
but
of
course
the
flip
side
is
if
I
move
it
back,
then
then
you'll
have,
like
instance,
Rapti
and
object,
wrap
tea
methods
interspersed
you
know,
and
so
that
would
make
the
code
look
ugly
for
at
least
one
commit
and
then
I
could
do
a
second
commit
which
cleans
it
up
and
moves
all
the
instance
rap
into
one
part
of
the
file
and
all
the
object
wrap
into
another
part
of
the
file.
You.