►
From YouTube: Next Generation N-API: A Hands-on Workshop - Nicola Del Gobbo, Packly & Jim Schlight, Inspiredware
Description
Tooling for Node native add-on development continues to rapidly evolve. After widespread adoption of N-API last year, the Node native add-on ecosystem is gaining momentum as the underlying technology advances.
This workshop describes important new features critical to the performance of your native add-on. These features include asynchronous operations which permit you to safely and reliably spread your work across multiple threads. Context awareness permits your add-on to be loaded multiple times without the copies interfering with each other. Finally, adopting thread-safe functions insures your functions run reliably regardless of the thread from which they are called or in which they run.
Bring your project or work through the workshop tutorials under the helpful guidance of the N-API experts. You’ll leave this workshop with a solid understanding of these important new technologies.
B
Okay,
yeah
hello.
Everybody
welcome
to
our
workshop
we're
going
to
be
talking
about
an
API
and
new
stuff
going
on
in
there
and
sort
of
introducing
the
concept
of
of
native
modules
and
porting
native
modules
to
an
API.
So
let's
introduce
ourselves
so
I'm
Gabriel
I
work
at
Intel
and
on
an
API
by
the
way,
I'm
also
part
of
the
technical
steering
committee,
and
these
are
some
of
the
things
that
I
implemented
when
we
were
developing
an
API
I'm.
C
Michael
Dawson
IBM's
Camille
lead
for
nodejs.
That
means
I
get
to
spend
a
lot
of
time.
Work
in
the
community
I'm
on
the
technical
steering
committee
and
in
particular,
work
as
part
of
the
napi
team
as
well,
and
I
also
get
to
work
with
a
lot
of
great
teams
within
IBM.
We
do
things
like
keep
no
GS
running
on
our
platforms.
Make
sure
our
cloud
is
a
great
place
to
deploy
node
and
you
know,
use
any
PI
in
building
some
of
our
modules.
D
My
participation
is
primarily
on
the
build
tools
and
documentation
as
part
of
the
N
API
team.
Our
company
is
particularly
interested
in
the
adoption
of
node
and
javascript
in
the
scientific
and
engineering
communities,
and
to
that
end,
we
are
working
on
an
automated
tool,
a
tool
that
will
automate
the
creation
of
n
API
bindings.
So
if
that's
of
interest
to
you,
your
company,
we
should
really
talk.
A
Hi
everybody
thank
you
to
be
here.
My
name
is
Nikola
Delgado
I
work
as
developer
parky,
a
small
company
in
south
of
Italy
him
for
most
part
of
the
time,
I
take
care
of
implementing
back-end
systems,
and
to
do
that
there
was
a
lot,
no
js',
JavaScript
and
sometimes
C
or
C++.
In
my
spare
time,
I
try
to
give
my
contribution
to
open-source
project
time
for
more
in
parts
of
an
API
team.
A
C
D
So
here
are
the
objectives
of
today's
workshop,
so
we'd
like
to
give
you
a
brief
orientation
to
napi
background
on
napi.
Why
we
have
it
and
then
we're
hoping
that
you
leave
with
an
awareness
of
the
available
tools,
and
we
hope
today,
through
the
workshop,
you
get
a
good
start
on
your
own
projects
or
supporting
a
current
module.
D
So
what
we
will
do
is
speak
briefly
to
give
you
a
live
presentation
about
napi
and
its
counterpart,
node
add-on,
API,
and
then
what
you
will
have
is
a
chance
to
work
on
online
tutorials
at
your
own
pace.
So
if
you're,
a
beginner
they'll
be
options
for
you.
If
you're
already
in
eighth,
an
API
and
interested
in
some
of
the
newer
features,
the
tutorials
will
guide
you
through.
That
you'll
also
have
a
chance
to
work
on
your
on
a
virtual
projects
or,
if
you're
interested.
A
Okay,
so
the
purpose
of
this
workshop
is
to
teach
you
how
to
implement
an
event
on
using
an
API
but
before
to
start
to
need
to
know
what
is
on
its
own.
We
carry
far
too
this
definition
that
came
from
not
just
documentation
and
don'ts
are
defined
like
dynamical
English
error
object
that
can
be
loaded
as
any
other,
just
Emoto
so
required
function
and
they
are
return
CC
bus
pass.
A
This
definition
is
very
complete
and
precise
because
say
us
that
Madonna
returned
Jesse
bus
pass
and
you
need
to
compile
your
code
and
at
the
end
of
this
process,
you
will
obtain
sherry
library
that
node
will
be
able
to
load
using
a
query
function.
So
you
don't
need
any
boilerplate
code
to
load
this
particular
module,
usually
native
a
John.
A
Are
you
said
the
two
binding
two
to
bind
CNN
C++
libraries
or
application
and
to
speed
up
your
node.js
application,
especially
if
you
won't
execute
CP
bound
operation
like
image
processing,
but
how
is
it
possible
call
native
code
direct
from
Joseph?
The
answer
is
another
question:
what
is
a
know
jazz
when
jazz
is
a
jasiel
runtime?
It
uses
just
Eng
to
pass
and
execute
your
JavaScript
application,
and
there
is
a
binding
between
the
API
exposed
by
the
engine.
A
A
D
D
D
D
So
the
problem
with
man
is
that
was
so
tightly
tied
to
the
v8
engine
that
when
there
were
changes
in
the
v8
engine,
it
could
potentially
break
the
the
ABI
stability
of
your
native
add-on,
and
at
that
point
your
users
would
see
a
message
like
like
the
one
shown
there,
which
is
not
understandable
to
them,
which
would
then
land
as
a
issue
for
for
maintainer
x'.
So
this
fragility
and
the
ABI
was
one
of
the
primary
motivating
factors
for
creating
an
API
which
we
have
today.
B
Okay,
so
so
so
what
exactly
is
an
API
right?
That's
what
we're
going
to
be
talking
about,
so
what?
What?
What?
What
we
did
was,
instead
of
instead
of
trying
to
basically
expose
the
the
v8
C++
API
to
native
add-ons
and
have
people
use
that
directly
or
through
nan,
which
is
basically
the
same,
but
with
a
with
a
few
more
abstractions.
B
B
You
know
c
c
library,
that
kind
of
thing
basic
basic
functions,
but
they
they
cover
pretty
much
everything
that
you'd
want
to
do
in
a
native
add-on,
and-
and
so
that's
how
we
sought
to
achieve
this
binary
stability.
So,
like
you
know,
if
you
look
at
our,
if
you
look
at
a
plain
Windows
application
right,
it
was
written
for
like
Windows
95,
and
it
still
runs
today
right.
That
will
not
fail
because
the
the
the
windows
api
has
remained
so
stable.
The
same
thing
can
be
said
with
with
with
unix
apps
right.
They
do.
B
They
will
still
run
today,
because
all
they
do
is
things
like
F,
open
and
and
IO
control,
and
these
things
and
those
things
have
been
around
forever
and
they
haven't
changed
that
they
haven't
broken
in
like
30.
Forty
years
well,
we
don't
yet
have
thirty
forty
years
under
our
belt,
but
that's
the
idea.
Basically,
that's
why
I
rewrote
it
in
C.
So
so,
when
you
have
an
API
in
the
picture,
basically,
instead
of
going
directly,
you
can
see
here
from
the
v8
engine
to
the
v8
public
API
right.
B
Instead
of
doing
that,
your
your
code
talks
to
n
API
instead
and
we
do
the
talking
to
the
to
the
v8
engine.
And
so,
if
the
v8
engine
changes,
we
have
the
opportunity
to
change
the
implementation
of
v8
a
of
an
API
without
actually
changing
the
interface
of
an
API.
So
so
you
still
call
the
same
function
with
the
same
parameters
that
have
the
same
meanings
and
you
get
the
same
return
value
as
you
did
in
an
earlier
version
of
node
right.
B
So
so
your
your
binary
interface
doesn't
change
at
all,
but
we
change
our
implementation
right
so
so
that
that's
the
difference
between
nan
with
with
nan
you.
The
interface
remains
the
same,
but
once
you
compile
your
code,
the
compiled
code
would
only
work
with
it
with
a
certain
version
of
nodejs,
because
the
meanings
of
things
change
function,
parameters,
change,
and
so
you
have
to
recompile
your
code
when
the
next
version
of
node
comes
out.
Although
you
don't
have
to
change
your
code
anymore,
because
nan
changes,
your
code
doesn't
change,
you
still
have
to
recompile.
B
So
with
any
API,
you
don't
even
have
to
recompile
you
just
release
it
and
everybody
uses
it
for
the
next
eternity,
basically,
so
so
okay.
So
this
is
an
illustration
of
that
right.
So
without
an
epi,
this
is
what
happens
right.
This
is
no
js'
version,
six
v8
version
5.1
and
then
the
node
module
version
is
48
right.
So
what
happens?
B
A
new
version
of
node
comes
out
and
the
a
the
ABI
is
completely
different
right
and
it
no
longer
matches
so
in
in
in
the
best
case,
you
get
something
like
unresolved
symbol,
blah
blah
blah
I
can
no
longer
overload
your
module
right
in.
In
the
worst
case,
you
get
something
like
your
module
works
perfectly,
but
in
this
very
obscure
coroner
case,
because
the
meaning
of
this
parameter
changed
right,
you're
passing
zero,
which
used
to
be
an
enum
value,
meaning
X.
B
Now
it's
an
enum
value,
meaning
Y
the
engine
does
something
else,
and
you
set
fault
right.
It's
like.
Why
did
that
happen
right?
So,
to
avoid
these
mysterious
sort
of
failures,
we
have
node
module
version
right,
which
is
basically
like.
Okay,
look
I'm
going
to
fail.
You,
because
I
can
no
longer
trust
that
your
ABI
matches
this
one,
even
though
it
looks
like
it
does.
We
know
that
the
ABI
has
changed.
B
Therefore,
we're
going
to
increment
this
node
version,
node
major
version
or
node
module
version,
and
then
we
will
simply
refuse
to
load
one
that
that
was
compiled
with
the
lower
one
right.
So
this
was
a
conscious
decision
on
the
part
of
nodejs,
so
with
an
API.
What
happens
is
the
initial
state
is
the
same
right?
I
mean
you
know
when
you
build
your
module,
it's
freshly
built.
B
Obviously,
it's
going
to
run
against
the
version
against
which
it
was
built
right,
but
the
difference
is
because
you're
you,
you
now
have
the
C
API,
which
we
have
promised,
will
not
change
in
meaning
or
in
or
in
structure.
We
can
later
add
new
a
api's,
but
we
cannot
change
the
existing
ones
right.
So
what
we
do
when
we
add
new
or
once
is
we
do
this
right?
You
have
the
surface
that
remains
the
same,
but
now
there's
other
functionality
right
like
in
in
in
N
API
version
one.
B
There
was
no
threat
safe
function
right
so
in
any
P
I
version.
Four.
Now
we
have
a
thread
safe
function,
it's
a
new
nodejs
interface,
it's
great,
but
anybody
who
hasn't
used
it
will
not
be
affected
by
it
because
it
doesn't
change
things
like
how
you
create
an
integer
that
that
doesn't
change
right.
How
you?
How
do
you
create
an
object
that
hasn't
changed
right?
It's
the
same
C
function.
B
So
so,
but
one
thing
did
change,
especially
in
the
last
year
and
it's
called
worker
threads
right,
so
so
nodejs
used
to
be
a
runtime
that
that
was
basically
start.
The
process
require
require
require,
require
and
then
run
forever
right
in
practice.
That
means
run
until
something
crashes.
You
shut
it
down.
You
start
another
instance.
You
start
fifteen.
Other
instances
doesn't
matter
right,
it's
like
a
micro
service.
So
so
so
so
you
don't
have
to
worry
about
about
what
happens
to
the
process.
B
B
And
you
can
have
this
any
number
of
times,
so
you
end
up
with
this
right,
whereas
before
you
had
these
little
chunks
of
memory
that
were
left
over
when
the
process
died,
now
you
end
up
with
with
a
bunch
of
leaks
in
your
modules
because
they
don't
clean
up
absolutely
everything
after
themselves
right,
so
so,
so
how
do
you?
How
do
you
go
about
cleaning
stuff
up?
So
we
have.
We
have
several
mechanisms
right.
B
First
of
all,
in
the
core,
we
well
unload
the
module
right
because
I
mean,
if
you
don't
unload
the
module
the
module
will
be
so
so
that's
that's
one
of
the
most
important
things.
The
other
thing
is
you
have
to
tell
the
module
hey
you're
about
to
die.
You
know
you
better
do
stuff,
because
so
far
we
didn't
have
such
a
mechanism.
We
had
one
we
had
like
the
in
it.
B
Everybody
knows
if
you've
done
any
native
add-ons,
you
know
that
there's
an
init
function
in
which
you
get
past,
it's
kind
of
like
it's
kind
of
like
a
common
GS.
You
have
like
module
dot
exports
right
in
a
native
add-on.
You
get
out.
You
get
an
object
and
then
you
attach
nice
little
properties
which
are
all
implemented
in
your
C
or
C++
code,
and
then
you
give
back
the
object
and
then,
whatever
somebody
calls
a
function
on
that
object.
It
actually
goes
into
your
C
C++
code
right,
that's
and
that's
all
done
in
in
it.
B
But
what
about
like
you
know
on
in
it?
You
know
like
died
or
whatever
it's
like.
We
didn't
have
that
because
we
didn't
need
to
write,
but
now
we
need
to,
and
and
this
requires
buying
from
all
the
native
add-on,
maintainer
z',
because
all
of
them
need
to
be
aware
that
these
add-ons
can
be
removed.
Now,
and
so
you
know,
if
you,
if
you
have
like
I,
don't
know
like
a
static
giant
structure
pointer
equals
null
at
the
top
of
your
file
and
it
in
init.
You
say
new
giant
structure.
B
B
Do
some
cleanup,
I,
don't
I,
don't
believe
you
can
run
JavaScript
anymore
at
that
point,
but
you
can
do
things
like
like
nappy,
remove,
wrap.
You
know
to
get
rid
of
native
pointers
that
kind
of
thing
now.
The
other
thing
that's
experimental
now
is
is
this
thing
called
nappy
set
instance
data
right-
and
this
is
a
little
bit
easier
to
nappy,
add
and
clean
up
hook
for
for
technical
reasons.
B
The
technical
difference
between
the
two
is
that
when
you
add
a
clean
up
hook,
all
it
does
for
you
is,
is
just
you
know,
you
give
it
a
pointer
and
at
the
end
of
the
environment
that
gives
you
the
pointer
back
and
says
hey.
This
was
the
pointer
you
gave
me
so
you
know
you
better
clean
it
up.
That's
it
right,
but
but
so
what
right?
B
Like
that
point,
there
is
not
going
to
be
available
in
your
binding
right
and
you
don't
want
to
store
it
statically,
because
then
you
know
if
you
have
five
instances
and
five
different
threads,
all
those
static
pointers
are
gonna,
be
clobbering
each
other
right,
so
so
that
what
you
do
right,
if
all
you
have
is
nappy
and
nappy
Adam
clean
up
hook.
Well,
when
you
create
a
binding,
you
can
pass
a
void
start
there,
which
gives
you
back
when
it
gets
called.
B
So
so
that's
a
nice
way
of
sort
of
threading
this
global
State
through
instead
of
using
a
global
static
right,
you
can
thread
it
through
UK,
pass
it
to
a
sink
workers
and
so
forth.
But
but
it's
you,
you
still
have
to
sort
of
pass
it
around
and,
and
you
have
to
like
change
your
whole
init
function.
Now
it's
like
you
don't
have
to
create
form.
So
that's
what
you
had
so
far.
Now
you
have
nappy,
create
function,
giant,
structure,
pointer,
and
you
have
to
do
that
for
everything
right.
B
So
to
avoid
having
having
to
do
all
this
threading
by
hand,
we
have
nappy
set
instance,
data
which
is
now
experimental
and
going
towards
becoming
part
of
any
pi6,
and
that's
basically
like
hey.
We
know
that
the
the
nappy
environment
that
you
get
like
you
know
the
nappy
end
that
everybody
uses
inside
an
API
is.
There
is
a
different
one
for
every
module
instance,
so
you
might
as
well
just
hook
this
pointer
on
it
with
nappy
set
instance
data
and
then
anywhere.
B
You
can
just
say,
hey,
give
me
the
data,
and
then
it
gives
you
back
the
pointer
right
and
when
you
hooked
it
you
you,
by
the
way
you
can
attach
a
finalizar
so
that
when
the
environment
goes
down,
you
can
delete
it
right.
So
so
so
it's
a
it's
a
little
bit
cleaner
than
than
the
cleanup
hook,
and-
and
it's
also
it's
also
more
spec
compliant
in
in
terms
of
like
ECMAScript.
B
So,
okay,
but
there
are,
there
are
still
some
things
that
that
are
not
covered
by
this.
So,
for
example,
references
references
are
one
thing
that
is
not
covered
by
this.
If
you,
if
you
hook,
data
to
individual
JavaScript
objects
and
the
lifetime
of
your
native
data
is
supposed
to
equal
the
lifetime
of
the
JavaScript
object,
then
what
happens
when
you
have
these
javascript
objects
left
over
when
the
engine
dies
right?
B
B
You
can't
do
that
for
very
complicated
reasons
which
I
don't
fully
understand,
but
I
took
their
answer
for
granted
and
I
said:
okay,
fine,
yes,
sir,
you
know,
and
and
so
so
we
have
to
do
it
and
they
said
explicitly
that
the
implementers
of
the
environment,
not
even
the
engine
the
engine
can't
handle
it.
The
environment
in
which
the
engine
run
has
the
engines
run
have
to
handle
this
right.
So
so
what
we
did
was:
okay,
fine!
Let's
do
that.
You
know.
Let's
let
us
do
that.
B
Fine
Iran,
because
we
know
the
references
that
are
hooked
up
to
all
the
native
objects.
We
hooked
them
up
right.
So
all
you
have
to
do
is
keep
a
tally
like
okay,
this
thing's
still
hooked
up
this
thing's
still
hooked
up
environment
dying,
no
problem
go
die,
die,
die,
die,
die,
die,
die,
die,
die,
basically
right,
and
so
so
we
tell
everybody
to
die
so
so
this
is
also
a
new
feature,
and
this
can
also
break
things
because
believe
it
or
not.
People
were
not
cleaning.
These
up.
B
Surprise
right,
so
so
so
now
that
that,
now
that
we
are
calling
these
functions,
which
we
were
never
calling
before,
because
the
garbage
collector
wasn't
calling
them
now
we're
finding
things
like
wait,
a
second,
oh
you
want
to
close
the
database,
but
wait.
I
have
a
query.
Handle
open
still,
so
I
need
to
close
a
query
handle
then
the
database
handle,
but
what,
if
the,
what?
If
the
finalizar
gets
called
in
the
wrong
sequence,
wha
right
so
I
think
with
level
down.
We
have
some
of
these
issues,
but
we're
working
on
them.
A
Improve
the
native
adjourn
Mecca
is,
after
request,
all
ragas
requests
that
we
receive
it
from
native.
Don't
want
a
nurse
about
the
effort
to
keep
up
with
the
changes
in
a
v8
engine,
and
then
we
started
to
work
to
shape
this
new
API
and
most
important
was
the
collaboration
with
the
chakra
core
team,
because
we
started
to
validate
and
test
the
API
using
two
different
implementation
and
in
December
2016
we
ship
the
enhancement
proposal
for
an
API.
A
Then
we
started
to
port
some
of
key
modules
for
the
ecosystem,
like,
for
example,
nazia,
port,
unknown
SAS,
secure
ID,
and
then
we
fix
it,
something
in
the
API
and
in
May
2016.
An
API
has
been
reached,
the
like
experimental,
API,
we've
node,
eight
after
data
in
July
at
a
new
VM
summit
we
agreed
on
which
shall
be
the
exit.
A
If
you
want
to
create
2008
John
using
an
API,
you
have
two
choices:
you
can
use
the
plane.
C
API
exported
the
directive
from
the
core
or
no
J's.
You
need
only
to
include
in
your
code
a
node
and
this
core
API
dot,
H
and
start
right,
you're.
Not
yet
done,
or
maybe
you
can
use
other
than
API.
That
is
it's
not
part
of
the
API
stable
API
and
it's
distributed
through
NPM.
A
Another
twenty
I
is
a
C++
wrapper
over
the
C
API
exported
by
the
coral
node,
and
it's
a
collection
of
function,
classes
and
markers
that
help
you
to
simplify
your
code
using
C
pass
pass.
All
the
code
is
aligned.
This
means
that
when
you
compile
your
native
ads
on
the
compiler
will
replace
all
the
code
with
any
P
the
n
API
function,
and
the
most
important
thing
is
that
Elton
IPI
depends
only
on
napi.
A
Here,
I
reported
the
the
usage
of
these
two
API
on
your
left.
You
can
see
the
C++
API
provided
by
the
Don,
API
and
I'm,
creating
an
object.
It
D
API
is
very
intuitive
and
simple,
and
then
I'm.
Attaching
this
object,
our
property
foo
and
set
string
value
bar
all
this
code
will
be
expanded
in
17
hands
of
code
of
C
API,
and
in
this
code
you
can
recognize
a
pot.
Every
almost
every
n
API
functions
take
as
parameter
our
environment
value
and
the
return
Estados
and
you
have
to
check.
A
A
The
these
guarantee
same
promise
of
an
API
compile
once
and
run
on
multiple
version
of
nodejs,
and
these
yeah
reduce
the
likelihood
to
to
change
your
code,
which
is
a
different
version.
Ojs
we
always
work
on
improving
api
and
all
the
native,
a
don't
ecosystem
and
I
won't
tell
what
happened
in
last
year,
we
ship
add
to
new
version
of
an
API
in
an
API,
for
we
had
the
dress,
a
function
that
help
you
to
call
the
main
thread
from
an
external
threat
and
we
found
API
5.
We
added
the
data
object.
A
We
promoted
the
like
state
like
stable,
API,
the
finalize
a
callback
function
to
clean
up
the
memory,
use
it
by
negative
or
resources
by
NATO
and
made
option
the
callback
a
for
thread,
safe
function.
You
know
that
Don
API,
we
added
a
lot
so
start
stop.
We
started
from
the
documentation,
then
we
are
the
newest,
increment,
API
and
trace
a
function
wrapper
and
thanks
to
feedback.
A
That
that
we
received
from
other
developers,
we
work
at
a
lot
on
I,
think
worker
API.
And
if
you
are
curious,
you
can
see
all
what
we
did
on
the
issue
reported
in
the
slide.
And
then
we
added
our
new
I
think
worker
kool-aid
I
think
progress
Volker.
That
internally
is
implemented
using
the
trace,
a
function
and
help
you
to
report
on
the
main
threat.
The
progress
that
happen
in
an
external
threat
and
then
we
added
a
wrapper
for
the
data
object.
D
Outside
of
node
itself,
we
also
improved
some
of
the
build
tools.
So
in
the
past
year
we
added
a
piece
of
an
API
support
for
pre-built
pre.
Build
is
a
tool
that
will
combine
our
compile
your
native
add-on
into
a
binary
that
gets
uploaded
to
github
as
a
release
and
we've
also
added
support
for
an
API
builds
in
C,
make
jeaious.
A
This
project
will
be
composed
by
two
part:
one
written
in
JavaScript,
and
no
there
everything's
CSE
bus
pass
and
use
only
the
sea
bass,
bass
bass
part
will
be
used
by
the
justed
part
to
explore
so
infusion.
Here,
I
reported
the
structure
that
we
use
it
on
the
example
tutorials
and
it's
a
normal
JavaScript
project.
But
there
is
something
new.
A
There
is
a
folder
called
SRC
where
there
is
the
native
code,
we
see
a
C++
code
and
a
special
folder
called
built
that
contains
intermediary
and
finally
build
product,
and
then
we
have
binding.
That
is
a
special
file
that
contains
all
the
sad
things
to
build.
Your
native
at
all,
yeah
binding
chip
is
used
by
no
chip
and
and
internally
it
used
by
chip.
A
That
is
the
default
building
tool
that
an
old
use
to
build
native
at
door
banging
chip
is,
is
a
fight
that
use
a
json
syntax
and
allows
you
to
set
all
the
flags
libraries
that
you
need
to
build
your
android
or
the
most
important
things
here
are
targeting
the
score
name
that
represent
the
name
of
your
natural
dog
and
sources
that
easily
so
your
native
files.
That
you
want
that
to
need
to
to
build
your
natural
tone.
Some
developers
don't
like.
C
Want
to
use
modules
which
have
been
ported
ten
API,
so
we
came
up
with
this
concept
of
being
able
to
add
badges
to
your
project
so
that
people
can
find
modules
which
are
gonna
orally
more
easily
use
with
be
able
to
be
used
with
with
different
versions
of
node
and
keep
working
when
you
upgrade.
So
we
have
these
badges
we've
created
for
the
different
versions,
it's
as
simple
as
adding
the
URL
tin
into
your
readme,
and
really
you
want
to
start
with.
C
You
know:
what's
the
earliest
version
of
any
PI
that
you
support
with
any
PI
version,
3
being
a
good
choice,
because
that's
the
one
that
was
supported
by
all
the
existing
LTS
is,
and
so,
unless
you
need
to
have,
you
know,
use
some
of
the
newer
features.
That's
the
best
place
to
start
and
there's
just
some
of
the
the
URLs
that
you
may
need,
and
so,
when
we
send
out
the
slide
deck
you'll
be
able
to
get
those
directly.
C
D
D
All
right
so
on
the
left
is
the
is
the
URL
if
you'd
like
to
start
looking
at
the
online
tutorials.
So
when
you
bring
it
up,
you'll
see
on
the
left,
there's
a
table
of
contents
and
if
you're
brand
new
to
napi
there
there's
some.
There
are
some
topics
for
getting
started,
but
if
you're
actually
doing
an
API
work
and
you're
interested
in
more
of
the
advanced
topics,
for
example,
the
the
context
awareness,
then
you'll
see
that
there
are
advanced
topics
further
down.
D
So
the
four
of
us
are
here
ready
to
help
you,
if
you're
working
through
a
tutorial,
if
you're
working
through
your
own
project-
and
you
have
a
question-
or
you
have
a
suggestion-
please
please
signal
one
of
us
and
we'll
be
happy
to
work
with
you.
If
you
don't
have
your
own
project
and
you'd
like
to
contribute
to
the
node
project,
then
on
the
right
is
a
list
of
existing
native
modules
that
are
eligible
to
be
converted
to
napi
and
some
are
easy
and
some
are
very
complex.