►
From YouTube: 2021-05-14-Node.js Node-API Team meeting
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
A
No,
I
will
share
my
screen
with
that
list.
Then
we
can
go
through
the
list.
The
talk
submissions
for
openjs
world-
I
know
I
guess
gabriel-
you
and
kevin-
were
working
on
that
right.
B
Yeah,
so
so
in
that
email
that
he
sent,
he
also
mentioned
that
he
needs
help
finishing
the
slides.
So
I'll
probably
have
a
look
at
them
and
see
what
else
I
can
put
on
there.
A
B
A
B
C
C
B
A
That
that
we
found
that
useful
in
some
other
one,
so
cool,
okay,
so
okay,
nothing
more
to
talk
about
and
that
one
stale
issues,
I
don't
think
I've
added
anything.
So
I
don't
think
we
have
any
stale
issues
to
talk
about
modules.
You've
noticed
supported.
I
don't
think
we've
seen
any
new
modules
that
were
ported.
A
E
A
Yeah
yeah,
thanks
for
adding
that
in,
I
think
otherwise
we
should
be
pretty
much
ready
to
go
so
and
thanks.
I
I
thanks
for
the
suggestion.
Last
time.
Vladimir,
I
did
end
up,
you
know,
building
a
a
class
and
we
now
have
it
so
that
it's
based
on
the
liveness
of
the
the.
What
do
you
call
it
lambda
as
opposed
to
the
the
rough
and
unref
before
and
after.
A
I
will
do
that
after
we
speak
after
we
finish
here:
okay,
thanks,
okay,
so
that's
that
one
are
there
other
issues
that
people
want
to
pull
out
or
call
out,
in
particular,.
F
F
F
See
it's
hpr
number
3,
3,
86
24.
A
F
F
A
Okay,
because
we
generate
an
abort
anyway
yeah,
just
because
in
a
lot
in
a
lot
of
cases
for
node
report,
if
we
can't
get
the
information,
the
preferred
thing
is
to
just
not
generate
that
section
that
we
can't
create
versus.
But
this
looks
like
we
should
at
the
end,
we
do
an
abort
anyway
right.
So
this
is
just
saying
we
should
do
it
earlier.
F
Yeah
but
it
try
to
use
generating
another
part
anyway,
but
it
requires
a
lot
of
changes
in
the
non-import
code
base.
So
I'm
just
adding
the
test
case
in
node
api
and
then
we
can
continue
the
work
on
another
part
to
generate
as
far
as
possible
right.
A
F
F
No,
it's
not
the
exception,
exceptionally
related
to
athlete
and
javascript.
So
we
just
uploading
with
feature
which
doesn't
come
with
a
exception.
F
A
F
A
F
F
A
A
G
F
Oh
this
one,
it's
just
a
reward
on
the
previously
just
now
made
on
the
object,
but
it
there
is
still
double
use
of
three
issue
in
the
place.
So
I
just
removed
it,
but
there
seems
a
failure
on
the
right.
Okay,
so
I'm
not
sure
if
it's
ready,
but
I
will
try
again.
F
A
A
A
A
A
A
B
Yeah
yeah
yeah
yeah,
I
think
so
yeah
you're
right
yeah,
the
I
mean
the
the
the
issue
is
root
cause.
The
fix
is
on
its
way
there's
and
it's
not
a
node
and
an
api
fix.
So
there's
nothing
we
can
do.
We
know
that
on
api,
so
yeah,
I
I
think
I
think
I
agree
with
you.
There's
no
reason
to
hold
up
the
release
for
this.
D
What
is
in
the
main
branch?
I
can
start
to
create
the
three
two
zero
yeah.
Yes
yeah,
maybe
you
can
add,
forecast
999..
It's
only
a
doc
documentation,
paragus.
A
Sounds
good
yeah,
it's
pretty
small
too
right.
D
And
when
you
land
these,
I
don't
know
later
or
tomorrow,
I.
D
Start
to
make
these
okay:
these
are
a
release.
A
A
D
Okay,
I
I
can
change
when
I
will
make
the
release,
because
I
need
to
change
the
current
version.
So
if
you
agree,
I
can't
change
the
these
either.
A
D
A
A
G
Yes,
so
what
proposal
here?
What
if
we
so
think
what
we
discussed
last
time
like
yesterday,
that
we
want
to
have
we
essentially
need
to
create
a
part
of
node.js
infrastructure
to
be
able
to
load,
javascript,
execute
javascript
and
bunch
of
different
modules
like
assert
common
and
for
each
native
module.
G
So,
thankfully,
if
you
think
that,
as
we
go
through
this
kind
of
each
test,
because
test
driven
from
javascript,
we
have
to
do
a
lot
of,
there
are
a
lot
of
moving
parts
effectively
before
we
even
execute
something
very
first
line
of
node
api
test.
We
still
have
to
do.
G
We
should
assume
that
a
lot
of
infrastructure
already
works,
and
if
some
of
it
is
broken,
we
can
be
in
trouble
actually
understanding
what
exactly
is
broken,
because
nothing
would
work
at
all
like
we
would
not
even
know
where
this
error
is,
because
we
didn't
get
to
this
test.
Yet
so
one
of
the
proposals
I
have
like
what,
if
we
have
be
more
like
a
c
plus
plus
driven
test,
so
thankfully
imagine
have
g
test
and
g
test
start
to
test
basics.
G
Like,
for
example,
can
I
run
small
script
as
I
start
with,
like
I'm
saying
like,
I
have
escaped
a
two
plus
two
I
now
I
expect
them
to
receive
four
as
a
result
in.
If
I
can
see,
I
can
run
simple
tests,
then
I
can
do
very
interesting.
Things
like
I
can
probably
create
the
evolve
function,
so
I
can
maybe
do
some
small
things
like,
for
example,
every
time
I
want
to
compare
two
two
javascript
values.
G
I
can
just
simply
execute
a
small
snippet
inside
of
javascript
and
see
result
so,
rather
than
having
all
these
tests
to
be
driven
from
from
javascript
what,
if
they'll,
be
driven
first
from
c
plus
plus
g
test,
and
here
I'm
giving
examples
like
what
facebook
did
with
the
gsi,
the
javascript
inter
interface,
which
essentially
just
two
files
like
one
of
them
header
file.
G
If
you,
if
you
click
on
this
first
link,
please
you
will
see
that
literally
the
whole
testing
suite
for
for
this
api
is
just
two
files
test,
leave,
cvp
and
tesla
h
and
they
kind
of
test
as
a
whole.
This
surface
pretty
much
in
similar
way.
G
What
we
need
for
no
node
api,
but
what
I
kind
of
like
about
this
approach,
its
simplicity
and
one
of
the
goals,
what
we
discussed
yesterday,
it
should
be
able
to
grab
this
testing
suite
to
bring
into
different
reverb
for
different
implementation
of
our
node
api
and
just
embed
it
into
any
kind
of
building
system.
G
You
like
using
cmake
visual
studio,
but
not
it
would
work,
and
I
think
at
some
point
I
tried
to
mimic
the
approach,
but
the
issue
was
like:
I
had
to
convert
some
of
these
javascript
tests
into
c
plus
plus,
and
it
was.
It
was
big
work
and
while
I
was
doing
it,
the
question
like
was
like
okay:
if,
tomorrow,
no
the
api
team
changes
test,
what
do
I
need
to
do
how
to
synchronize
it
and
stuff?
So
I
stopped
doing
it
instead
of
just
adopting
javascripts?
G
Yes,
so
it's
it's
more
like
a
topic
for
discussion.
It's
is
something
what
we
may
want
to
consider
to
have
with
tests
in
the
end
to
be
not
javascript,
driven
but
rather
c,
plus,
plus
driven.
A
A
If
you
run
one
of
these
tests
and
it
fails,
you
may
have
a
hard
time
knowing
what's
going
on
at
all,
because,
like
some,
you
know
you're,
not
even
to
the
point
where
you
can
run
tests.
So
I
could
see
an
extra
test
suite,
which
just
basically
was
there
to
try
and
get
you
to
the
point
where
you're
confident
you
can
then
run
the
bigger
test.
G
A
good
point
actually
in
in
a
testing
suite
which,
which
currently
exists,
what
I
was
showing
the
last
time
we
do
have.
I
do
have
a
a
small
set
of
tests
for
a
third
module
because,
instead
of
bringing
the
whole
node.js
a
certain
implementation
which
responds
from
multiple
javascript
files
only
have
small
subset,
but
I
want
to
make
sure
that
this
small
sub
set
works
in
a
way
that
I
want.
G
A
A
B
And
the
and
the
cool
thing
is
that,
if
we
go
with
like
the
dll-based
approach
that
we
discussed,
then
we
can.
We
can
test
anybody's
implementation
of
these
of
these
prerequisites
right.
So
we
can
test
whether
the
implementation
of
the
prerequisites
on
jerryscript
works,
right
or
or
on
on
what
is
it
javascript
core
or
whatever
they
call
it
in
in
in
os,
10
or
or
whichever
one
apple
provides
so
yeah?
That's
that's.
That's
a
great
idea.
A
B
And
the
thing
is-
and
the
thing
is
since
you
mentioned
snippets
right
in
in
that
sense,
the
the
qualification
test-
suite
is
just
a
bunch
of
snippets
right,
but
then
so
is
so.
Is
the
the
js
native
api
test
suite
it's
just
that
the
snippets
are
much
larger
right.
So,
however,
however,
you
test
your
qualifying
test
suite,
you
can
also
test
js
native
api.
Afterwards,
you
just
feed
it
larger
snippets.
G
Yeah
good
point,
and
actually
I
should
say
that
while
I
was
running
this,
these
tests,
especially
with
in
an
api,
run,
run
script.
I
found
that
the
missing
one
important
parameter
kind
of
become
whatever
script
name,
because
for
me,
in
order
to
report
errors,
I
didn't
know
where
this
error
came
from
right.
I
was
finding
that
having
some
kind
of
source
url
was
something
that
was
a
big
mission
in
this
api.
So
I
had.
A
It's
it's
like
this
kind
of
I
because
yeah,
I
don't
know
if
this
like
matches
kind
of
what
you
were
like,
I
was
thinking
we
need
to.
We
can
probably
compile
like
as
it
gets
back
to
that.
Can
you
separate
out
the
build
systems
yeah?
We
can
probably
compile
the
the
each
test
down
to
something
that
has
a
function.
We
can
pass
to
a
to
a
you
know.
I
said
library
instead
of
shared
library,
because
I
think
we
might
be
able
to
support
either
just
depends
what
you
link
on.
B
I
I
also
suspect
that
it
might
be
useful
if
we
made
the
test
suite
a
little
more
consistent,
so
one
one
thing,
for
example,
would
be
to
give
the
the
add-on
the
same
name
like
I
know
we
have
like
hello,
dot,
node
and
binding
dot,
node
and
and
right
you
know.
So
if
we,
if
we
just
pr
this
upstream,
like
on
in
node.js,
to
make
sure
all
the
bindings
have
the
same
name,
then
you
could
just
hard
code
that,
and
you
wouldn't
have
to
have
this.
A
E
E
A
B
E
A
B
B
B
With
so
then
so,
then
so,
then
we
already
have
the
name
of
the
directory
somewhere
in
a
list
over
which
it's
iterating
right,
and
so
that's
the
one
that
distinguishes
one
test
from
another
right,
and
so
we
might
as
well
make
the
contents
of
the
directories
identical
in
terms
of
what
files
are
in
there
and
and
what
what
the
names
of
the
add-ons
are
declared
to
be
right.
We
need.
A
B
Directory,
no
not
as
a
directory
right,
because
the
the
dot
there
is
the
directory
right,
because
it's
off
of
the
current
directory,
which
is
different
for
each
test
right.
So
the
current.
B
A
All
yeah-
I
guess
like
it's
just
in
terms
of
this,
whatever
this
name
is
passed
in
yeah
needs
to
match
this
guy
here
and
so
whatever
that
is
like
yeah,
if
you're
saying
you're
right
like
if
we
don't
have
it
to
be
binding.note
or
whatever,
that
might
make
it
easier.
Although
is
that
true
like
this
should
be,
this
actually
needs.
This
can't
be
binding
that
node
in
every
case.
A
A
Yes,
and
no
so
when
we're
doing
this,
when
we're
calling
set
entry
point
yes,
we
will
be
looking
through
the
directories
when
the
javascript
is
run
like
if
we
pass
the
javascript.
So
we
just
read
the
the
characters
from
the
file
and
we
pass
it
to
the
engine
to
say,
run
this
yeah.
This
exact
string
is
going
to
be
like
the
exact
string
is
going
to
be
what's
passed
to
the
require
function,
yep
and
the
required.
B
A
I
guess
I'm
not
quite
like
if
every
time,
if
every
single
time
require
is
called
it's
dot,
dot,
slash,
build
common,
build
type
sus
x,
the
binding
dots
node,
then
the
require
itself
will
not
know
how
to
fit
match
that
back
to
the
set
entry
point,
because
it
will
be
that
exact
string
like
it's
not
going
to
be
any
other
strain.
It's
going
to.
A
A
B
B
A
B
B
B
Yeah
yeah:
okay,
that's
that
this
is
actually
not
bad,
because
because
conceivably,
you
could,
you
could
have
a
binding.jib
that
creates
not
one
add-on,
but
that
creates
all
the
add-ons
right
and
they
all
have
different
names.
And
the
name
happens
to
be
the
name
of
the
test
right
and
then
and
then
you
know
you
could
you
could
just
have
one
subdirectory
of
js
native
api
technically
right.
G
Yeah,
it
makes
sense.
I
also
found
that
it
was
much
easier
if,
if
this
module
name
is
kind
of
very
specific,
I
actually
had
more
trouble
with
a
generic
one.
As
far
as
I
remember,
and
you
write
like
one
of
the
benefits,
if
you
compile
all
these
tests
in
one
single
dll,
it
will
be.
I.
A
A
This
is
basically
like
for
each
test
like
so
today
for
each
test.
We
build
a
separate
add-on
right,
but
in
this
case
it's
basically
we
want
to
have
a
separate
entry
point
for
each
test,
so
we
could
build
it
all
into
one
binary,
but
this
is
telling
the
run
time.
Basically,
we
need
to
map
the
require.
A
You
know
in
the
test
itself.
It
says
require
this,
and
out
of
that
require
we
need
a.
We
need
a
an
object
right
and
a
node
api
object,
and
so
the
set
entry
point
basically
says:
well,
here's
the
function
to
call
to
get
me
the
object
that
I
need
and
it'll
have
to
do
a
little
bit
more
but
like
basically,
it
can
call
that
function,
and
I
think,
in
that
function
in
the
function
that's
passed
in
there.
A
It
effectively
needs
to
so
in
test.
Resections
called
set
entry
point
free
entry
points
right,
the
name
will
be
the
directory
test,
so
that
gives
us
the
link
and
it
will
be
past
the
function,
the
function
that
we
need,
that
that
the
runner
needs
to
have
provided.
Is
this
snappy
this
init
value?
Because
that's
already
in
the
test
too,
and
that's
how
the
current
add-ons
return-
an
exports
object
right
and.
G
A
The
object
that
you
can
then
use
in
the
javascript
to
you
know
call
the
methods
that
have
been
bound
to
the
native
add-on,
but
in
this
case
you
know,
when
you
require
it'll
end
up
calling
this
it'll
return.
This
exports
the
require
basically
returns
that
object,
and
then
that
should
now
be
usable,
just
like
it
was
in
an
add-on.
Even
though
it's
running
you
know
in
the
in
the
javascript.
G
Yeah,
I
think
I
implemented
something
very
similar
okay
mechanism.
Yeah
yeah
like
we
can,
what
what
definitely
we
need
to
have
for
for
each
if
we,
if
we
start
to
build
targeted
and
node
api
implementation
for
hdl,
we
need
at
least
another
two
required
methods,
one
of
them
to
create
environment,
another
one
to
destroy
environment,
so
something
which
pretty
much
not
part
of
a
node
api,
but
something
which
will
require
for
tests.
So
then,
we
create.
A
Definitely
right
so
set
entry
point
the
name
rule,
so
we
pass
in
so,
but
I
think
what
I
was
thinking
is
that
the
require
implementation
is
where
it
should
basically
create
the
m.
So
the
test
runner
doesn't
necessarily
need
to
know
anything
about
the
m's,
but
when,
when
the
set
entry
point
is
called,
it
needs
to
take
that
function,
so
it
basically
needs
to
store
that
function
somewhere
when
it
when
the
engine
is
then
running,
javascript
and
caesar
require
the
required
implementation,
says:
okay,
I've
got
to
look
up
that
function
great
now.
A
I've
got
to
invoke
it
with
an
m,
so
it's
got
to
create
an
m.
However,
it
wants
to
it'll,
actually
need
to
create
an
m
and
create
an
an
exports
object
and
then
invoke
this
function.
So
the
test
runner
wouldn't
know
about
an
m
necessarily.
A
Is
that
does
that
make
sense
like
it's
that
the
the
require
is
basically
hiding
that
bit,
because
when
you
require
them,
the
the
it's
not
actually
an
add-on
in
this
case,
but
you're
requiring
that
particular
function?
I
guess
it's
equivalent.
It's
a
virtual
module
you're
saying
require
this
behind
the
scenes,
whatever
it
needs
to
do
in
terms
of
being
able
to
provide
an
m
and
providing
exports,
as
the
implementation
would.
G
Do
yeah,
I
see
a
point
I
think
like
in
this
case,
if
we
have
a
standalone
like
if
we
have
requirement
to
run
generic
script
like
you,
you,
you
wrote.
C
G
A
Right
and
you're
right
for
the
the
the
the
pre-validation,
although
even
in
the
pre-validation
one
it
would,
it
might
need
to
say
just
it's
going
to
validate
like
I
could
call
set
entry
point
and
then
I
can
run
javascript
and
in
that
javascript
there's
a
require,
and
as
long
as
that
require
returns,
the
matching
thing,
that's
what
it
would
be
trying
to
validate
right.
A
G
I
honestly
had
a
lot
of
issues
with
this
function
because,
especially
if
we
want
to
have
all
our
tests
to
be
compiled
in
single
dll
effectively,
it's
the
same
symbol
exported
from
multiple
c
units,
so
in
in
implementation
I
have
I
had
to
define
this
macro
in
it
to
for
each
individual.
So
it's
it
was
one
of
the
reasons
that
I
couldn't
run
all
tests
from
one
single
cpp
file.
G
I
had
to
create
one
cpp
file
to
each
test
directory
because
inside
of
each
test
before
I
include
this
see
my
annotation,
I
had
to
redefine
this
init
as
a
macro
with
some
unique
symbol.
If
you
like.
A
A
G
Well,
at
least
if
we
can
somehow
probably
add
some
macros
that
makes
this
symbol
to
be
kind
of
local,
because.
G
And
if
effectively
have
multiple
c
files
with
global
symbol
we
need,
and
actually
it's
the
linker
will
be
not
happy
about
it.
A
B
Yeah
yeah,
but
the
way
the
way
this
entry
point
works
is
it
see
it
just
assumes
that
there's
an
init
function
right,
which
is
visible
globally
right,
so
so,
basically,
the
way
we've
structured
our
test
suite
encourages
that
each
test
be
its
own
binary
in
this
case
right,
whereas
we
cannot
really
load
all
of
them
into
one
binary
without
making
changes
and
without
naming
the
entry
points
differently.
B
G
C
B
G
B
You
try
to
link
these
together.
It's
going
to
say
you
know,
the
symbol
is
already
defined
here
right
and
it's
going
to
say
you
know
it's
defined
in
like
27
different
places.
G
B
So
yeah
this
this,
this
discourages
having
having
them
all
in
one.
A
G
A
G
Alternative
can
be
a
little
different.
Like
I
mentioned,
the
network
compiled
this
c
c
c
function.
We
just
simply
pass
the
compiler
with
definition,
c1
saying
like
in
it
is
actually
macro
and
we
define
it
to
something
blah.
So
thank
you
in
this
case.
B
B
G
Okay,
so
the
only
caveat
that
it,
whoever
wants
to
bring
this
test
file
now,
like
their
own
environment,
like
we
discussed
last
time
like
they
had
to
do
it
every
time
themselves,.
B
Only
only
only
if
they
only
if
they
want
one
binary
for
all
tests,
if
they
want
one
binary
for
each
test,
then
they
need
to
do
nothing
right
because
then,
then
in
it
will
be
unique
to
the
binary.
So
it
depends
on
how
they
design
their
their
test.
Suite
right,
like
we've,
chosen
to
sort
of
bundle
them
all
together,
and
then
you
need
the
minus
d
in
it.
But
if
you
make
one
binary
for
per
test,
then
you
don't.
B
G
We
can
probably
iterate
on
it
and
see
how
how
it
goes
like.
So
currently,
I
just
simply
define
the
inner
code
this
as
a
macro
yeah.
I
definitely
don't
like
ideas
that
we
change
in
source
codes
is
the
first
step.
A
B
Yeah
init
capital,
I
lowercase
everything
else
equals
and
then
I
don't
know
in
it
same
thing:
equals
itself
underscore
test
name:
oh
no,
not
minus
d,
right,
okay,
right,
yeah,
yeah,
okay,.
A
E
B
A
B
Well
well,
four
for
directory
name
in
subdirectories,
gcc
minus
d,
init
equals
initial.
A
G
Basically,
as
we
talk
about
like
us
all
these
special
cases,
it
was
one
test
which
I
I
couldn't
run
at
all.
If
you
go
inside
of
our
test,
gener
generic
or
generic
right,
there
is
some
kind
of
code,
and
especially
you
mentioned
somewhere
here
we
or
test
general
test
general.
Yes,
one
of
the
reasons
we're
using
this
file
systems
and
stuff.
You
know
it's
basically
we're
going
inside
of
v8
unit
test
suite
and
we're
actually
bringing
in
v8
tests
and
running
them.
G
So
thankfully
it's
one
thing
which
I
couldn't
do
it's-
why
I
kind
of
I
didn't
even
need
to
do
this
file
system
and
stuff.
So
I
guess
we
need
to
decide
what
what
we
want
to
do
before
this
v8
tests,
so
we
can
just
simply
have
a
copy
of
them.
If
you
look
inside
of
test
general
you'll
see
how
they've
been
used.
A
A
B
Yeah
yeah
yeah
yeah,
so
so
yeah.
The
same
thing
happened
when
I
was
when
I
was
porting
to
to
jerryscript,
there
was
sort
of
a
there
was
sort
of
a
back
and
forth
like
a
cross
pollination.
On
the
one
hand,
I
was
changing
jerryscript
to
support
what
we
needed
and,
on
the
other
hand,
I
was
changing
the
tests
right,
not
use
so
much
node.js
specific
stuff.
B
So,
yes,
this
is
going
to
have
to
happen
again
like
we're
going
to
have
to
we're
going
to
have
to
feel
which
way
the
push
goes
like
is
the
push
towards
the
the
test
run,
are
implementing
these
things
or
is
the
push
towards
more
towards
no,
the
the
upstream
test
suite
removing
these
things
because
they
are
not.
You
know,
javascript
engine
related,
so
we're
going
to
have
to
make
that
judgment
call
as
as
reporting
the
tests
one
at
a
time.
I
think.
B
A
And
then
you
look
at
each
of
these
and
say
well:
do
we
actually
need
it
to
run
exactly
like
you
said
which
do
you
do?
Is
it
that
you
can
you
simplify
the
test
in
the
node
front
so
that
it
doesn't
require
fsn
path,
which
I
think
that
one
may
be
the
case
and
then
like
the
ones
that
use
child
processing
you
know
be
like
well,
maybe.
E
B
Like
it
should
go
under
node
api
instead
of
js
native
api,
so
so
one
one
of
the
one
of
the
tools
on
our
belt
stream
is
to
move
these
things
to
know
the
api.
If
they
seem
more
appropriate,
you
know
like
if
they
agree,
you
know.
If
they
know
about
the
wider
world
than
just
javascript,
then
they
belong
in
node
api.
B
B
A
G
B
G
G
Need
to
understand
what
are
you
using
cmake?
What
will
be
kind
of
suggestion,
how
the
whole
is
struggling.
A
G
Okay,
so
because,
currently,
what
what
we
do
in
you
know
we're
kind
of
the
gsi
we're
just
using
whatever
our
tool
set
came
from
the
id,
but
here
we
just
start
like
we'll
say
it
will
be
cmake
driven
the
whole
thing.
That's.
A
G
And
compiler
using
the
gcc
for
all
platforms.
So
how
does
it
work.
B
No
windows
uses
a
visual
c
plus
plus,
I
think,
and
so
on,
windows
on
windows.
We
generate
like
the
dot
sln
and
whatever
thing,
and
then
we
build
that
and
we
have
like
a
batch
file
that
that
that
builds
node
instead
of
instead
of
like
python
and
and
jip
and
finally
make
files.
G
And
you
know
like
because
I
was
playing
with
cma
a
couple
of
years
ago,
a
lot
technically
today,
msvc
or
even
like
visual
studio
code.
They
both
support
direct
cmake
in
the
case.
So
thankfully
we
don't
even
need
a
clan
creation
anymore,
like
visual
studio
today
capable
to
open
directory
with
with
rc
make
whatever
like.
A
Yeah,
I
would
just
do
the
simple
one
if
you
can
do
one
thing
for
everything
that
that
would
be
good,
because
this
isn't
really
going
to
be
part
of
node
core
or
whatever
right.
It's
yeah,
you
know
so
I
I
yeah
doing
something.
That's
that's
easier
and
more
consistent
using
the
newer
stuff,
I
think,
is
good.
G
Yep,
okay
and
another
question:
okay,
I'll
start
with
she
make
here.
Another
question
I
have
like,
because
I
need
to
have
something
to
kind
of
really
run
against
and
what
we
agreed
that
it
will
be
definitely
some
kind
of
version
of
v8
which
we
use
inside
of
node.js.
G
How
we
would
build
this
kind
of
target
dll
like
a
target
shared
library
which
includes
this
v8
inside,
like
a
is
kind
of
the
easiest
way
to
do
it.
Just
using
v8
tool,
set
right
or
not
like
any
kind
of
convolutions.
A
A
G
It
wasn't
me
it
was
tutor
from
our
team
who
established
this
build
system.
I
just
piggybacked
and,
like
I
literally
brought
some
files
from
node.js
about
this
node
api
and
it
just
compiled.
I
didn't
even
know
details
myself.
A
Although
it's
the
yeah,
I'm
just
thinking,
is
there
any
reason
why
we
wouldn't
just
the
problem?
The
challenge
we've
had
is
like
v8,
you
know
they
used
one
set,
then
they
use
something
else,
and
then
they
use
something
else,
and-
and
I
guess
part
of
our
problem
is
that
there
was
a
lot
of
extra
stuff
like
we
have
in
node.
We
have
other
dependencies
right
so
changing
to
what
v8
used
every
time
was
harder
than
just
you
know,
changing
it
for
v8,
it
was
changing
for
those
other
dependencies.
A
B
G
Okay,
so
just
to
summarize,
a
car
we'll
have
a
c
maker
which
will
drive
the
whole
process.
Cmake
at
some
point,
will
kind
of
bring
over
the
whole
savvy
repo
plus
some
few
files
from
node.js
for
much
implementation
of
a
node
api,
js
native
underscore
api
for
v8.
G
I
will
put
it
there
and
we
use
something
to
see.
Make
will
drive
the
whole
thing,
but
at
some
point
it
will
use
whatever
v8
build
process
to
build
this
dll
which
we're
going
to
test,
and
then
we
have
our
testing
suite
will
be
made
using
cmake
and
then
we
use
probably
c
test
to
kind
of
run.
The
whole
thing.
A
Like
ideally
like
this
repo
wouldn't
know
about
the
v8
wrapper
like
it
it
we
could
set
up
something
that
just
says
get
a
binary
from
here
like
get
a
dll
from
here,
run
the
test
right
and-
and
so
you
know,
I
I
see
long.
You
know
this
is
the
first
step.
The
next
that
might
be
a
prob
would
be
a
project
that
has
the
v8
and
the
wrappers
and
all
that
and
but
those
they
should
kind
of
be
decoupled
right
so
that
you
can
say
yep
this
one
builds
a
shared
library.
A
The
project
that
it's
testing
can
be
whatever
it
just
needs
to
end
up
with
a
library
that
has
the
right
exports
right
and
then
for
this
you
know
the
ci
we
would
set
up
for
here.
We
would
grab
a
library
from
from
somewhere
like
in
you
know
longer
to
from
the
next
step.
It
would
be
that
that
other
project
that
would
be
building
a
binary
on
a
regular
basis
that
it
could
pull
in
and
use
the
test
or
a
dll.
G
Right
right
but
yeah
well,
let's
say:
is
it
okay,
it'll
be
not
the
first
step
like
if
this
first
step
will
be
just
simply
kind
of
going
all
the
way
through
and
then
yeah?
I.