►
From YouTube: Node.js N-API Team meeting - Feb 3 2019
Description
A
A
A
No
sounds
good
I
expect.
Most
people
have
been
out
pretty
much
over
the
holiday,
so
we'll
continue
to
push
on
that
to
275
for
investigate
an
API
to
avoid
future
breakages.
I
do
see
some
there's
some
come
on
comments
and
it
was
that
yeah
Glenn.
You
were
the
one
who
basically
took
a
stab
at
porting.
The
NPM
time
function
right.
Yes,.
C
So
see,
I'm,
never
quite
sure
which
form
so
yeah
I
got
it
to
work,
I
contacted
the
owner
and
he
was
like
yay
great
I,
told
him
everything
we
were
doing
I
one
of
the
things
I
think
we
have
to
be
aware
of
when
we
start
doing
this
conversion
from
nan
to
basically
the
node
add-on
using
a
node
add-on.
Api
module
is
that
a
lot
of
these
modules
were
written
at
a
time
when
by
Travis
that
didn't
do
Windows,
testing
and
other
thing.
C
So
when
I've
actually
run
things
using
Travis
yeah,
it
works
great
online
Express
platforms,
but
some
of
the
unit
tests
actually
don't
pass
and
it
does
perhaps
for
another
discussion,
but
as
we
convert
them,
we're
actually
going
to
start
seeing
there
are
problems
with
well
used
packages.
Well,
this
is
perhaps
only
two
thousand
downloads
week.
I
didn't
want
to
start
particularly
big,
I'm.
C
C
Came
oh
yeah,
I,
remember
so
they're,
actually,
there's
actually
quite
a
lot
of
things
they
didn't
realize.
So,
basically,
if
you
want
to
convert
an
from
a
project
from
nine,
you
actually
have
to
have
some
idea
of
how
nine
works
great
and
I
hadn't
I
just
read
up
on
the
new
stuff,
so
this
may
be
for
a
future
discussion
as
we
convert
more.
C
A
C
A
C
Didn't
I
did
not
know
there
was
a
tool,
so
it's
I've
plenty
to
learn.
I,
basically,
I
just
read
the
documents
that
they
were
quite
good.
One
of
the
things
I
would
say
about.
The
documents
are
very
good
on
api's,
but
I
think
most
developers
mostly
go
from
example.
So
the
work
examples
you
gave
at
node
some
II
on
the
west
coast
at
the
end
of
last
year.
The
the
workshop
was
the
best
help.
Ok
me.
C
C
Add
on
API
helped
a
great
deal
because,
like
switch
between
the
two,
so
that
she
was
a
big,
oh
so
that
workshop
and
it
may
take
time
for
the
payoff
to
come
with
people
and
me
coming
on.
But
at
the
time
you
you
maybe
didn't,
get
a
pay
back,
but
now
that's
that's!
That's
how
I
learned
how
to
do
this
from
your
workshop?
Okay.
A
Now
that
that's
great
feedback,
and
so
it
really
says
we
need
to
continue
to
add
to
the
node,
add
on
examples:
yeah
I'm,
so
well,
I,
just
you
know
just
thinking
what
we
can
sort
of
take
out
from
your
experience
is
one.
We
should
make
it
publicize
more
the
conversion
tool,
because
I
was
wondering
like
if
you,
if
you
found
there,
were
some
things
that
you
needed
to
know
about
man
if
we
can
codify
any
of
those
into
that
tool
that
helps
now.
A
It's
not
it's
not
perfect
and
sometimes
I
think
it
might
be
easier
not
to
use
tool.
So
it's
it's
it's
a
balance
and
then
the
other
thing
is
like.
If
there's
any
specific
examples
that
you
can
think
of,
think
of
that
weren't
covered,
maybe
opening
at
least
an
issue
in
the
know
down
on
examples
to
say:
hey,
you
know
in
converting
this,
these
were
some
examples
that
might
have
been
used
focus.
It's
that's
a
good
point.
People
do
like
you
know
the
comparing
between
the
different
ones,
yeah.
C
That
and
the
fact
I
think
perhaps
I
took
a
module
that
have
been
lost
changed.
You
know
over
five
years
ago,
and
things
have
changed
a
lot
in
five
years.
Yeah
right,
imagine
how
much
JavaScript
has
changed,
but
more
than
that,
like
the
ability
to
test.
So
this
did
have
Travis
yanil
file,
but
now
you
can
do
Windows
and
stuff
and
those
hadn't
been
running.
What
do
we
do
with
a
module
when
we
have
to
say
to
the
owner
yeah?
This
works
great
on
OS
X,
Linux,
probably
on
a
PI.
C
C
C
A
A
C
C
That
this
might
take
it
take
a
small
one
find
out
so
I
think.
Perhaps
what
I'd
like
to
do
and
on
these
meetings
going
forward.
I've
talked
to
people
here
or
I.
Work
will
have
more
people
on
a
package
maintenance
core
and
if
we
can
get
some
more
people
involved
in
this
I
I
will
but
I
think
there's
quite
a
lot
of
interest.
But
a
lot
of
people
didn't
didn't
know
about
what
was
going
on
and
I'm
just
walking
around.
Might
we
have
a
thousand
developers
here
on
my
floor
and
just
telling
them.
A
A
C
C
So
so
so,
okay,
so
as
consumers
in
that
the
package
of
consumers
of
napi,
we
need
to
discuss
how
we
go
about
it.
We
we
can
get
the
package
owner's,
consent
and
they're
happy
with
it
yeah.
Then
we
have
to
say
when
we
raise
a
PR,
do
we
highlight
things
with
sound
that
are
wrong
yeah?
Do
we
just
wait
for
them
to
publish
a
package?
Do
we
know
some
I
think
this
guy
tornado
owns
no
time
we'll
just
go
and
publish
it
once
I
I
I
raised
a
PR
I
didn't
want
to
do
that.
C
So,
let's
all
talk
to
him
or
the
maintenance
group
and
with
you-
and
it's
just
saw
the
process.
I
know
this
is
the
first
one.
Maybe
we
just
went
and
contacted
the
guys
at
hey
that
thing
you
wrote
some
time
back.
They've
got
this
new
interface.
He
apparently
knew
about
it
when
I
wanna
checked
up,
he's
still
very
much
involved
in
technology,
and
he
was
just
great.
That
was
his
answer.
Yeah.
A
Nikola
has
has
done
some
some
similar,
you
know
portraits
and
packages
and
reached
out
so
I
mean
because
we've
done,
we've
been
doing
it
in
the
scope
of
the
the
napi
team.
In
terms
of
you
know,
trying
to
help
to
do
what
we
can
do
to
enable
sort
of
adoption,
so
I
think,
like
I
I'd,
encourage
you
just
to
pursue
that
one
in
terms
of
like
hey.
If
you
can,
if
he's
happy
to
land
it
and
land
it,
that
would
be
great
I'll.
A
C
A
A
A
Sql,
a
part
I
don't
have
an
update
on
there.
I
I
haven't
had
a
chance
to
get
together
with
the
nation.
She's
probably
been
away
like
I
have
over
Christmas,
but
we'll
try
and
get
back
and
connect
with
the
maintainer
there,
because
we
really
need
some
more
insight
into
how
the
how
the
logging
is
done,
because
it
uses
something.
That's
not
obvious
and
Jim
also
mention
ruse
back.
You
might
get
involved
to
help
burning
down
a
list
of
issues
raised
by
module
owners.
B
B
A
A
Was
some
discussion
of
see
make
the
thing
in
my
mind
is
like
it
may
be
one
thing,
and
this
came
to
me
after
so
I-
don't
really
comment
in
the
issue.
It
may
be
one
thing
to
switch
the
billed
slash
test
of
note,
add-on
API
to
see
make,
but
there's
a
fair
amount
of
integration
with
chip,
I
think
in
terms
of
like
downloading
header
files
and
stuff
like
that
that
make
add-ons
build
in
general
yeah.
B
A
A
And
that
that's
where
you
know
I
I
rekindled,
the
discussion,
a
note
core,
Ben
Norris
had
done
some
work
to
explore
using
see,
make
and
note
core,
but
there's
not
consensus
on
that,
but
the
the
reaiiy
rekindled
that
discussion,
because
it
would
have
been
an
easier
decision
if,
like
oh
yeah,
the
long-term
direction
of
no
coracii
make
then
okay,
it
makes
sense
to
you
know,
look
at
it
for
add-ons
and
and
so
forth.
Yeah.
B
B
B
D
A
B
A
A
D
A
D
B
Except,
unlike
no
chip,
I
believe
that
very
few
developers
use
chip
as
installed
globally
for
their
own
projects,
whereas,
whereas
see
make
is
a
tool,
they
might
already
be
using
right.
So
if
we,
if
we
ship
a
version
of
C,
make
with
node-
and
they
already
have
a
version
of
C
make
because
of
their
own
project,
then
we
might
get
a
conflict
and
we
might
get
into
issues
where,
depending
on
what
version
of
C
make
is
first
on
the
path,
it's
gonna
do
different
things
and
build
differently.
The.
A
B
I
mean
I
I.
Remember,
I,
remember
a
time
when,
when
when
no
add-ons
were
compiled
using
like
a
shell
script,
yeah
you
know
so
so
you
know
it.
We
there
was
a
time
pre,
no
chip
right
so
I
guess
we
we've
we've
derived
a
heck
of
a
lot
of
utility
from
from
having
switched
to
no
chip,
but
I
mean
we
do
have
to
switch
away
at
some
point
right.
B
Well,
I
I'm,
not
a
hundred
percent
sure,
because
my
understanding
is
that,
like
nvm,
for
example,
it
downloads
the
headers
when
it
installs
a
new
version
of
note
right,
like
it
just
puts
the
headers
in
in
all
the
right
places
and
then
and
then
no
chip
takes
care
of
making
sure
that
the
include
paths
are
there
right.
So
in
that
sense,
you.
A
B
Oh
I
see
I
see
so
you
mean
you
mean,
like
you
mean
like,
if
you
okay,
but
but
correct
me,
if
I'm
wrong
anytime,
you
install
node,
whether
it
be
from
from
from
from
a
debian
package
or
from
nvm
I
mean
okay
with
a
debian
package.
Do
you
have
things
like
no
dev
or
or
whatever,
but
I'm
assuming
you're,
installing
that
right
like
if
you
are
installing
that
you
are
getting
two
headers
right
well,
but.
A
C
Yeah
Trey
I
trust
it.
So
this
is
a
problem.
I
live
actually
give
talks
on
how
tough
it
is
to
other
thin
tape,
type
people
we
we
have
to
Drew
in
some
of
the
builds
now
I've
noticed
what's
happening.
Is
this
automatically
downloading
the
headers
yeah
back
more
than
that?
Even
if
you've
got
the
headers
it'll
try
and
get
them
anywhere
right,
the
ones
you've
got
and
as
a
return,
if
you
have
to
tear
it.
These
are
my
headers
on
this
path.
C
When
you
actually
are
doing
at
the
you
have
to
set
up
an
environment
variable
to
to
actually
overcome
this
yeah
and
for
people
actually
behind
the
firewall
for
a
lot
of
us,
where
there's
a
lot
of
node
work
that
goes
on,
that
it's
not
really
publicly
viewable,
we
have.
We
have
to
do
exactly.
As
you've
said,
we
have
to
go
out,
we
have
to
get
the
headers
yeah,
we
have
to
put
them
somewhere
in
our
network,
so
they
can
bigger
or
we
have
to
check
them
in
somewhere,
that's
accessible
from
us.
C
C
A
C
A
C
A
A
Okay,
cuz
I
mean
I
think
in
the
community,
be
great
to
have
a
list
like
that,
because
that
would
give
us
something
to
focus
some
attention
on
and
say.
These
are
the
problems
that
you
know.
People
are
reporting
in
terms
of
they're
struggling
with
this.
What
can
we
do
to
help
out
with
those
not
not
necessarily
related
to
any
API
yeah.
D
E
F
A
A
F
F
B
A
F
A
So
well,
that's
a
little
bit.
That's
interesting
as
well
so
like
if
there's
already,
people
who
are
using
C
make
to
to
build
their
add-ons
it'd
be
interesting
to
know
how
how
pervasive
that
is
but
like
if
you
know,
if
there's
enough
people
using
that,
that
would
be
an
argument.
Maybe
for
no
dad
on
API
to
support
that
and
no
Jeff
right.
A
B
No
I
I
think
I
think
we
need
both
at
least
in
core.
We
definitely
need
both,
because
if
you
yeah,
you
know
in
a
way,
if
you,
if
you
have
people,
if
you
tell
people
to
only
include
an
API
headers,
then
then
node
or
an
API
version
should
actually
not
be
defined
right
and-
and
so
you,
when
you
say,
not
be
experimental
and
then
you
include
napi
headers,
then
then,
then
the
the
preprocessor
should
crank
up
the
version
to.
A
B
At
that
point,
you
need
not
be
experimental
because,
because,
as
you're
checking
other
preprocessor
variables
for
for
different
things
inside
node,
against
which
you're
building
for
perhaps
completely
orthogonal
reasons
to
an
API,
the
sighted
effect
is
that
now
your
n
API
version
is
set
to
3,
and
so
so
you
need
not
be
experimental
to
now
to
actually
get
the
experimental
API
is,
if
you're
using
them
right,
though
so
I
think
I
think
we
need.
You
need
the
two
I
don't
think
we
can.
B
We
can
get
away
with,
with
restricting
or
with
making
decisions
based
on
whether
that
be
experimental
is
defined
or
not.
We
need
to
base
it
on
that,
even
though
technically,
the
only
reason
why
we
define
that
be
experimental
is
so
that
we
might
crank
up
the
version
of
nappy
fur
or
the
value
of
nappy
version
right.
A
B
A
F
Actually
that
it's
interesting
to
run
some
Newton
Cotes
naked,
but
maybe
it's,
although
very
interesting,
to
have
something
like
a
multi-threaded
naked
module
and
you
want
to
make
a
call
back
to
JavaScript
and
there's
some
hours
to
be
here
birthday
and
because
of
that
and
like
I,
don't
know-
and
maybe
you've
done
some
from
Android
developing
or
something
like
this.
You
always
have
the
problem
with
and
there
is
only
one
thread
which
is
allowed
to
make
phone
calls
and
they
have
something
like
a
run
in
name.
F
A
A
F
B
So
I'm
just
wondering:
do
you
guys
see
this
as
as
coming
in
to
sort
of
focus
in
the
sense
that
we've
got
this
we've
got
this
situation
where
either
you
want
to
run
something
asynchronously
from
the
main
thread
or
you
want
to
call
into
the
main
thread
from
a
secondary
thread.
Can
we
sort
of
unify
this
because
I'm
thinking
like
four
four
async
worker
right,
if
you,
if
you
want
to
just
run
like
a
lambda
acing
right,
then
then
the
threading
is
already
done
for
you
by
nodejs.
B
But
on
the
other
hand,
if
you
have
your
own
threading
and
you
want
to
call
into
into
the
main
thread
then
then
you
have
to
use
thread
safe
function
right,
so
you
know.
Do
we
keep
these
things
separate,
or
do
we
just
or
can't
can't?
Is
there
a
way
to
unify
these
things
so
that
you
know
you
can
you
can
just
you?
B
A
B
The
thing
is,
I
was
thinking
like
if
you,
if
you
have
something
like
async
worker
bracket,
lambda,
something
something
right.
Yeah.
If
you
do
something
like
that,
then
then
from
inside
that
the
way
a
sink
worker
works
is
that
you
cannot
call
back
into
the
main
thread,
and
you
have
to
wait
for
the
for
the
async
stuff
to
finish
and
and
and
then
it'll
it'll
say:
okay,
I'm
done
and
it'll
it'll
run
the
on
okay,
Handler
and
so
forth.
B
Right,
but
I've
seen
instances
where
I've
had
at
least
one
example
or
I
gave
one
example
to
one
person
where
you
want
to
call
back
from
from
like
the
thread.
That
is,
that
is
a
thread
pool
thread,
and
you
want
to
call
back
during
execution
rather
than
an
after
execution.
So
then
you
use
a
thread
safe
function,
but
then,
but
that,
but
now
you're
talking
about
calling
in
from
a
secondary
thread.
So
what
difference
is
there
between?
Whether
that
is
a
node
thread,
pull
manage
thread
or
whether
that
is
your
own
thread?
B
You
know,
the
only
difference
is.
Is
that
in
one
case
you
don't
have
to
create
the
thread.
An
old
will
create
it
for
you
right,
but
but
you
have
to
use
a
thread
safe
function
in
either
case
right,
though
so
you
know
I'm
thinking
like.
If
we
do
this
lambda
thing
to
do
to
launch
something
on
a
secondary
thread,
then
then
we
have
two
choices.
We
can
either
launch.
C
B
And
you
create
the
thread
safe
function,
conditionally
on
which
signature
was
used
and
and
so
that
I
think
would
be
a
first
step
towards
unifying
these
two
concepts.
But
then,
but
then
the
thing
that
you
pass
into
the
async
function
should
be
the
same
thing
that
you
can
pass
into
that
you
can
just
create
on
its
own
without
having
to
create
the
async
function,
and
then
you
can
use
it
with
an
existing
threading
implementation.
B
B
I
think
Philip
Philip
had
had
had
some.
You
had
some
really
really
elegant
code
there
in
a
few
examples
where
you
can,
just
like.
You,
have
like
really
really
intuitive
way
of
calling
across
threads,
and
so
that's
why
I'm
kind
of
glad
that
you're
here
so
I
see
that
I
see
that
this
example,
for
example,
is
it's
also
very
elegant
because,
because
it
simply
runs
stuff-
and
you
know
that
it's
gonna
eventually
at
some
point,
run
in
in
the
node.js
main
thread,
and
so
so
so
so
I
think
it
was.
B
It
was
it
Eric
who
was
here
a
few
weeks
ago,
and
he
had
he
had
an
idea
for
the
for
the
opposite,
which
is
to
just
to
just
sort
of
fire
something
off
onto
a
secondary
thread.
So
so
so
these
two
are
sort
of
complementary
to
each
other,
and
we
should
really
think
about
doing
an
API
that
can
do
both
of
these,
and
that
can
realize
both
of
these
very
intuitively,
for
people
to
use.
B
B
A
F
A
B
A
And
certainly
your
comment
about:
can
we
come
up
with
an
API
that
lets
you
do
either
yeah
I
think
is
nice
so
that
you
can
say.
Oh
if
you
want
to
start
your
own,
manage
your
own
threads
great.
Do
this.
If
you
have
you
know,
if
you
just
want
to
use
one
of
the
existing
thread,
pool
things
and
not
have
to
worry
about
that.
Well,
okay,
used!
You
know
you
don't
have
to
learn
something
completely
new.
You
can
do
the
same
thing,
just
maybe
a
few
different
parameters
or
whatever
yeah.
B
I'm
thinking
you
know
Philip
this,
this,
this
running
notes
right
thing,
I'm
thinking.
If
we
made
this,
if
we
made
this
into
like
a
it's
like
a
callable,
then
then
that
would
that
that
would
give
us
really
nice.
That
would
give
us
a
really
nice
interface,
because
you
could
set
up
like
a
like
a
subclass
of
nappy
thread,
safe
function.
Right
like
assuming,
we
have
like
a
C++
class
nappy
thread
safe
function.
B
You
could
set
up
a
subclass
which
is
call
a
ball
and
then
and
then
does
the
subclass
would
define
the
the
marshalling
between
between
the
the
native
and
the
Jas
and
back
right
and
then
and
then
you
would
simply
call
it
as
if
it
were
a
function
and
you
would
pass
it
the
parameters.
The
function
would
just
be
like
the
the
the
native
stuff,
like
you
know,
your
integers
or
pointers
to
data
structures
or
whatever
and
then
and
then
it
would,
it
would
result
in
a
JavaScript
function,
call
on
the
on
the
JavaScript
side.
B
You
know,
and
then
that
would
be
like
a
running
note
thread,
but
it
would.
It
would
look
like
a
like
a
normal
function.
Call
you
know
at
so
so,
basically,
the
reason
I'm
thinking
about
formulating
it.
This
way
is
that
if
it
is,
as
you
say,
you
have,
you
have
like
a
really
old
called
code
base
right.
B
You
know
void
star
data
is
here.
You
know
that
kind
of
thing,
and
so
you
just
inject
one
line
into
into
that
big
giant,
threading
thing
and,
and
it
just
fires
a
callback
to
JavaScript
and
it's
as
clean
as
possible
and
all
the
all
the
implementation
of
how
that
call
actually
happens
is
in
the
binding
code
rather
than
in
the
in
the
threading
code.
You
know
what
do
you
think
about
that
yeah.
F
F
F
B
F
B
Yeah
we
we
have,
we
have
async
handles
right.
That's
that's
how
that's
done
you're
you're
you're,
basically,
the
like
the
thread.
The
the
the
main
loop
itself
is
not
thread
safe.
However,
it
does
have
a
type
of
handle
which
is
thread
safe
and,
and
all
that
does
is
basically
allow
you
to
to
make
a
function.
B
So
if,
if
you
execute,
if
you
execute
the
function
which
results
in
in
waking
up
the
the
main
thread,
if
you
execute
that
function,
you
call
it
like
59
times
on
the
secondary
thread,
you
may
not
get
59
calls
on
the
main
thread.
You
may
only
get
one
if
the
secondary
thread
is
fast
enough
right,
so
so
in
terms
of
in
terms
of
ensuring
one
to
one.
This,
that's
where
thread
safe
function
comes
in,
but
of
course
it's
still
like
you.
It
has
to
be
asynchronous.
So
so
there's
there's
just
no
way
around
that.
B
B
F
I
can
try
an
implementation
within
a
I.
Also
did
it,
and
but,
for
example,
the
design
of
this
energy
is
a
function.
There
are
two
parameters,
one
is
the
JavaScript
object
and
one
the
neighbors
call
that
and
I
think
it's
not
possible
to
only
have
a
native
call
deck,
so
the
child
could
call
that
is
mandatory,
and
this
JavaScript
call
that
it
is
is
a
parameter
of
automated
call
that
them
it's
like
me.
You
can
use
it
and
what
I
did
is
like
I
have
pass
on
no
operation,
call
that
JavaScript
and
yeah
yeah.
F
B
B
F
B
Enough,
the
thread-safe
function
is
not
granular
enough,
I
guess
I
guess,
ideally,
I
should
have
made
the
the
the
javascript
parameter
or
the
javascript
function
parameter
optional,
because
it
does
have
a
native
function,
I'm,
not
even
sure.
If
that's
not,
if
that's
not
possible
anymore
like
it,
it
might
be
possible,
though
I'm
not
sure
what
the
somberness
of
that
is.
If
we
all
of
a
sudden
made
that
optional,
it's.
A
D
A
A
F
B
A
Implementation
yeah
because
I
mean
it's:
it's
not
very
much,
not
very
big
yeah,
it's
pretty
good,
so
I
think
you
know
it's
from
that
perspective.
It
doesn't
seem
to
be
a
concern
like
adding
tons
of
code.
The
only
question
would
be:
how
do
we
you
know?
How
does
it
fit
in
with
other,
like
you're
saying
you
know,
as
opposed
to
having
different
concepts?
How
does
it
fit
in
with
the
other
concepts
that
we
have
for
going?
The
other
direction.
B
F
B
A
E
B
F
Maybe
what
about
this
pointer,
stuff
I
think
we
need
it,
because
the
class
has
to
look
on
the
heap
and
it
has
to
be
more
attached
to
live
until
the
the
lender
is
called
or
destroy.
So
we
will
somehow
it
must
be
underneath
and
I
think
there
is
no
no
need
for
any
share
point.
Our
unique
wanted,
no
Danite
API,
no.
B
F
B
Yeah
well
I
mean
once
like
once
you
have
the
PR
right
we
can
we
can.
We
can
run
this
on
the
we
can
run
the
the
PR
on
the
CI
and
then
we
will
get
like
pretty
wide
testing
of
it,
because
I
think
Michael,
you
added
you
added
all
kinds
of
platforms.
Now
we're
not
just
running
on
on
Linux
anymore
right,
oh
yeah,.
B
A
D
B
A
D
A
E
B
A
A
A
B
That
there's
something
that
needs
to
change.
That's
that's
a
very,
very
good
point,
and
actually
everybody
who
uses
it
now
will
provide
one
because
it
wasn't
optional
before
so
right.
So
it's
not
gonna
break
anybody's
cold.
It's
just
gonna!
Well,
I!
Guess
it
might
break
new
code
like
if
you
write
new
code.
A
B
B
A
A
B
A
D
A
B
For
sure
yeah
yeah,
so
yeah
yeah,
it's
it's
hard
to
it's
hard
to
gauge
cuz.
You
know.
On
the
other
hand,
if
we
do
introduce
any
sort
of
change
you
know,
then
then
you
know
we
cannot.
We
cannot
stabilize
it
like
immediately
afterwards,
because
we
do
need,
like
the
incubation
time
to
to
gauge
the
to
gauge
the
ramifications
of
the
change
right,
because.
B
It's
stable
and
then
you
know
ask
questions
later,
but
on
the
other
hand,
I'm
just
thinking
like
given
given
given
what
we
just
saw
from
Phillip
that
all
it
takes
is
like
a
dummy
function.
I,
don't
think
that's
such
a
high
price
to
pay.
You
know
like
it
would
be
nice
to
have
it
elegant,
but
I'm,
not
sure
if
it's
worth
the
upheaval
of
of
these
two
rounds
of
PRS
yeah.
B
You
know
is
just
have
a
dummy
function
and
I
mean
Phillip
Phillip,
did
it
with
a
native
function,
but
you
can
just
as
easily
do
it
with
the
JavaScript
function
just
just
take.
Whatever
function
is
available
to
you,
because
the
chances
are
when
you're
dealing
with
threads
you're
gonna
have
a
callback
coming
in
from
JavaScript
anyway,
because
otherwise,
like
what
do
you
do
with
it?
You
know
like
what
do
you
do
with
the
information
coming
back
from
the
thread,
if
not
to
somehow
inform
JavaScript
right?
B
A
A
F
F
A
F
A
F
A
F
B
I
I
kind
of
I
think
I
kind
of
get
Phillips
point
like
if
we
just
have
the
the
thread
safe
function
calls
it's
that's
not
very
useful.
On
its
own,
you
know,
like
run
running,
notes,
read
sort
of
wraps
up
the
the
functionality
you
know
sure
so.
Take
my
threats,
a
threat,
safe
note
colleges
like
the
plumbing
basic.
A
Right
but
that's
all
we
given
the
core
API
right
yeah,
so
it's
sort
of
like
the
building
blocks
so
like
it
comes
back
to
that
line.
Where
I
saw
a
fillip
commented
on
one
of
the
things
like
that
did
the
json.parse
and
stuff
maybe
doesn't
belong
and
know
that
on
API,
yeah
and
I
think
the
context
on
that
one
is
I
think
it's.
We
were
only
considering
that
because
it
was
in
then
already
and
as
a
transition
from
man.
It
might
have
made
sense
from
that
perspective,
but
it's
this.
A
F
Or
a
utility
that
you
can
call
into
a
node
that
or
you
can
have
a
call
deck
of
the
on
the
load
side,
I
think
simply
provided
by
the
node
add-on
API.
But
the
problem
is
that
we
have
to
make
one
thread:
set
called
any
guide,
presses
or
create
thread
set
function
only
one,
and
we
can
reuse
it
every
time.
So
we
only
need
one
globally,
not
thread
called
object
and
we
can
reuse
it
for
all
lender
right.
A
Of
starting
that,
my
starting
point
is
that,
like
it's
probably
a
no-brainer
to
say
well,
we
just
land
a
wrapper
for
the
thread
safe
stuff,
and
then
there
might
be
more
discussion
that
goes
on
in
terms
of
what
the
API
should
look
like,
how
it
fits
in
with
a
sink
worker.
So
by
having
them
as
a
separate
one.
A
While
we
have
more
discussion
on
the
other
concept,
that's
all
yeah,
that's
what
I
was
just
suggesting
like
if
there
was
to
PR
as
one
which
sort
of
gives
you
the
wrapper
that
mirrors
what
we
have
in
the
the
C
API
and
then
a
separate
PR,
which
adds
the
extra
level
functionality
on
top.
That
would
let
us
land
one
without
you
know
concluding
the
whole
discussion.
If
we
want
to
that
mix,
it.
B
Up
I'm,
looking
at
the
definition
of
thread-safe
note
calls
on
your
on
your
nappy
in
your
nappy,
experimental
repo
and
it
I
could
be
mistaken.
But
but
it
looks
to
me
like
pretty
much
run.
Running
note
thread
is
pretty
much
the
business
end
of
of
threat.
Safe
note
calls.
So
you
know
you
could
even
like
you
know
you,
you
could
even
make
this
like,
like
I
cut
like
a
method
on
on
on
thread.
Safe
note
calls
it
doesn't
have
to
be
separate
because,
because
you
already
have
a
the
thread
safe
note
call
right.
B
So
so
you
would
have
something
like
you
know,
a
thread
safe
note
called
X,
and
then
you
would
have
like
X
dot,
R
on
lambda,
so
on
and
so
forth,
and
then
and
then
that
that
would
convey
the
meaning
that
this
runs
in
a
thread
safe
fashion.
You
know
so
running
note
thread.
It
is
very
explicit
in
saying
that
it
runs
in
the
notes
thread,
but
but
the
thread
safe
function
also
conveys
that
meaning,
because
that's
the
point
of
the
thread
safe
function.
B
It
is
to
call
node
right
so
and
given
that,
given
that
the
the
the
JavaScript
callback
is
is
not
optional,
then
if
you
modify
thread
safe
note,
calls
to
to
optionally
accept
the
call
back
and
use
the
know
up.
If
none
was
given
right
then
then
you
can,
then
you
can
just
add,
add
a
method
that
says
run
and
then
you
would
have
run
run
in
node
thread
as
part
of
thread
safe
note
calls,
and
then
it
would
be
one
PR,
because
I.
F
B
F
E
B
F
B
Yes,
okay,
I
see
what
you're
saying
so
so
this
is.
This
is
sort
of
like
a
sort
of
like
a
channel
for
for
for
going
between
the
between
the
secondary
thread
and
the
nodejs
thread,
yeah
yeah
yeah,
and
actually
it's
funny
that
you
should
mention
that,
because
because
this
sort
of
behavior
I
noticed
when
I
was
writing
the
the
example
where
you
have
like
the
round
trip
function,
it's
an
it's
an
old
add-on
examples.
B
Were
you
calling
to
no
js'
and
then
nodejs
returns
a
value
and
you
asynchronously
retrieve
the
return
value
and
on
the
secondary
thread.
What
what
I
noticed
there
was
that
that
yeah,
you
can.
You
can
have
many
different
reasons
to
call
nodejs
and
you
can
use
the
same
thread
safe
function
for
all
those
reasons
and
and
what
what
ends
up
happening,
though,
is
that
you
can
have
as
much
contention
as
you
want.
B
So
you
can
basically
ease
things
by
by
having
multiple
multiple
points,
but
on
the
other
hand,
you
were
using
more
system
resources
or
you
can
have
one
point,
and
then
you
have
higher
contention
and
or
your
load
or
your
load.
Behavior
changes
depending
on
that,
but
basically,
basically
being
able
to
tune
how
many
thread-safe
functions
you
use
is
is,
is
generally
a
desirable
thing,
but
but
of
course
that's
up
to
application.
B
Programmers
not
not
up
to
us
to
decide
it,
but
I
I
see
what
you're
saying
like
you
basically
want
to
have
just
one
way
of
calling
nodejs
and
then
you
can
pass
different
lambdas
for
different
reasons:
right,
yeah,
yeah,
okay,
yeah,
and
you
can
do
that
right.
If
you,
if
you
also
like
with
each
Lam
that
you
can
pass
like
a
like
a
reference
because
I
believe
it's
okay
to
have
references
on
secondary
threads
as
long
as
you
don't
as
long
as
you
don't
pass
them
to
to
n
API
calls
just
having
the
reference
is.
B
B
A
Okay,
so
I
think
we're
well
we're
10
minutes
over
so
I
think
at
this
point
we
should
just
take.
We
was
good
to
get
into
some
of
the
details
there.
I
don't
think
we
have
too
much
to
create
matrix
of
tested
methods.
I,
don't
think,
there's
too
much
to
say
discussing
how
we
advocated
use
of
batch.
Isn't
our
documentation.
Anything
you
want
out
on
that
front,
Gabriel!
No!
No!
No!
That's!
That's!
That's
the
back.