►
From YouTube: 2022-01-21-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
So
welcome
to
the
node.js
node
api
team
meeting
for
2020
or
january
21st
2022,
just
because
you
can't
see
everybody
who
is
here
I'll,
just
say:
let's
like
myself,
it's
legenda,
cass,
gabriel
jack
nicola
and
vladimir,
and
we
will
pull
up
our
milestone
11
to
take
a
look
at.
But
before
I
do
that,
does
anybody
have
any
announcements
they'd
like
to
share.
B
Yes,
I
just
released
the
new
version
of
all
the
done
api.
The
version
4.3.0.
B
These
this
release
added
so
new
api,
the
iterator
for.
B
Class
and
yeah
some
other
fixes
on
the
tests
and
documentation
so
yeah.
This
is
what
I
want
to
to
share.
A
C
Javascript
engine
is
seems
to
kind
of
about
to
be
finished,
so
already
have
some
draft
pull
requests
out
and
currently
working
on
finishing
up
a
unit
test
suite
and
my
hope
that
after
this
unit
test
suite
been
applied
to
hermes
node
api
and
it's
previously
been
applied
separately
to
the
javascript
engine.
Hopefully
you
can
start
to
work
on
towards
service
vision.
Having
this
unit
test
suite
in
a
separate
repo,
as
we
discussed
a
few
months
ago,
yeah.
A
Okay,
anything
else
before
we
go
look
at
the
issues
tagged
for
the
for
this
week.
A
My
clip
here,
okay,
so
the
first
one,
is
one
that
I
added.
This
is
actually
a
pr
related
to
a
pr
to
add
a
new,
a
new
api
to
node
node
at
the
node
api
in
core,
and
there
was
some
discussion
and
it
reminded
us
that
in
fact
our
guidance
says
we
need
to
before.
We
add
something
we
need
to
discuss
it
in
a
meeting.
So
here
we
are
in
a
meeting.
A
This
is
adding
node
api
symbol,
4,
basically,
a
a
method
to
help
get
symbols
more
easily.
I
mean
the
discussion.
There
was
also
a
pr
for
another
one
which
added
like
five
or
six,
maybe
ten
new
methods
to
add
symbol,
helpers
and
sort
of
the
consensus
in
the
issues.
There
was
like
well
that
that
was
going
too
far
because,
like
our
guidance
is
like
we're
trying
to
keep
node
api
fairly
tight,
so
it
shouldn't
have
like
a
whole
bunch
of
helpers
and
all
that
kind
of
stuff.
A
That
stuff
should
mostly
be
in
node
add-on
api,
but
we
did
figure
that
node
the
getting
a
symbol
was.
You
know
a
common
enough
thing
that
that
one
method
actually
still
made
sense.
So
that's
why
this
one
is
still
like
on
track
for
landing.
Unless
you
know
people
have
objections
and
the
other
one,
we
kind
of
said
that
that
was
too
strained
too
far
into
the
you
know:
sort
of
helper
helper
things
that
you
can.
You
know
and
adding
lots
of
methods.
C
Just
a
quick
question:
yeah
this
new
api
accepts
a
description
as
a
cons
char,
and
we
have
some
other
apis,
especially
concerning
creating
new
strings
and
they
typically
have
size,
and
if
we
really
want
to
have
a
zero
terminated
string,
we
typically
say
like
out
length
right
like
would
it
be
worth
to
to
have
this
api
specified
length
of
the
the
string.
C
A
A
C
If
we
have
say
create
string
lighting,
one,
for
example,.
A
C
Yeah
auto
length
with
case,
if
you
want
to
be
zero,
terminated
or
you
can
specify
explicitly
what
your
when
it's
supposed
to
be
yeah.
I
question
I
guess
back
to
you
if
you
think
it's
worth
to
have
a
length
for
this
special.
A
D
E
D
So,
okay,
so
let's
I'm
going
to.
A
So
I
guess
it's
like
any
other
concerns
like
as
I
could
commented
here.
You
know
we
discussed
in
the
meeting.
People
sounded,
you
know,
okay
with
adding
it,
but
this
was
the
suggestion
that
came
out.
A
Is
that
is
that
or
does
anybody
like
hey?
You
know
we
shouldn't
add
this.
E
A
F
C
Blog,
you
can
do
it
using
an
api,
but
it's
main
kind
of
steps.
You
first
one
need
to
create
string
one
using
one
of
these
apis.
We
we
just
discussed
right.
Secondly,
you
need
to
get
a
global
object
out
of
this
global
object.
You
need
to
take
symbol,
constructor
right,
other
simple
constructor
on
this
static
method
for
this
string,
because,
like
you
literally
needed,
like
five
six
steps,
you
know
yeah.
E
F
We
could
take
a
quick
look,
it
should
be
in
here.
Yes,
yes,
it
uses
v8.
E
C
Right
and
another
concern
we
we
need
to
probably
in
this
api
explicitly
say
what
this
string
and
coding
is
like.
Is
it
lighting
one
versus
utf-8?
I
assume
it's
utf-8,
but
I
just
we
need
to
make
sure
that
api
explicitly
says
it's
utf-8
string,
yeah.
It's
description.
G
A
E
Yeah,
so
so
it
is
documented
to
to
require
a
utf-8
string.
E
E
Uses
utf-8
name,
the
name
of
the
parameter
is
utf-8
name
so
yeah.
That's
that
that's
another
suggested
change
is
to
change
the
the
the
name
of
the
parent.
The
cons
car
start
parameter
to
utf-8,
name
or
utf-8
description
or
whatever,
but
so
so
we
can
only
so,
for
example,
to
create
a
function.
We
can
only
use
a
utf-8
encoded
string.
We
don't
have
a
create
function.
E
There
would
be
conversions,
I'm
just
thinking
if,
if
it
might
make
sense
to
add
a
variance
that
accepts
an
api
value,
that
is
a
string.
G
E
Grid
from
that
one
or
yes,
yes,
yeah,
that's
why
I'm
saying
you
know
like
so
so
now
you
have
you
have
two
choices:
either
you
provide
a
plane
c
utf-8
string
or
you
go
through
all
those
steps
of
you
know,
retrieving
the
global
retrieving,
the
the
constructor,
creating
the
string
and
then
retrieving
the
symbol,
so
I
it
might
make
sense
like
so.
If,
if
you,
if
you
are
stuck
with
non-utf-8,
then
you
have
to
go
through
all
that
right.
E
If
we
provided
an
api
that
is
able
to
to
get
symbol
for
on
an
api
value,
that
is
a
string
rather
than
get
the
symbol
for
a
const
car
star.
That
is
a
utf-8
string,
then
you
could
do
it
in
two
steps
right.
You
create
an
api,
create
string
on
utf-16
and
then
an
api
symbol
for
something,
and
then
you
pass
it
in
there.
E
So
it's
only
it's
still
better
than
having
to
go
through
the
whole
process
of
retrieving
the
global,
etc,
etc,
and
and-
and
it
does
give
you
the
option
to
use
differently
encoded
strings
as
the
as
the
lookup
parameter.
H
All
right,
just
a
question,
are
no
doubt
on
ipsi
doing
adapt
our
api
to
this
once
this
land,
or
probably
yeah.
H
So
the
symbol,
four
eh
yeah
yeah-
so
there's
it
takes
string,
constraint,
constrain
the
string,
object
and
nappy
value.
E
C
A
E
E
So
so
so
so
what
do
you
think?
Should
we
ask
that
that
other
api
be
added
like
node,
api
symbol
for
value,
let's
say
yeah
and
we
can
bike
on
the
name
that
accepts
an
api
value.
C
I
would
probably
use
it
can
we
kind
of
like
we
have
a
precedent
in
our
know,
the
existing
api.
We
have
a
set
property
and
we
have
a
set
named
property
right
and
the
difference
like
set
property
using
value
like
a
named
property
uses
utf-8
string.
Yes,
that's
true.
E
G
Correctly,
these
two
function
have
different
semantics.
One
is
a
shorthand
for
setting
property
like
say
data
property,
and
it's
the
other
one.
We
can
define
a
property
with
property
descriptors,
so
they
are
doing
different
things,
but
the
if
we
add
a
another
variant
for
simple
four,
but
they
are
doing
same
thing
but
for
different
parameters.
E
But
I
think
I
think,
I
think,
because
you're
you're
you're
thinking
of
an
api
defined
property,
we're
talking
about
set
property,
which
is
an
api
and
an
api
object.
An
api
key
and
api
value
so
set
property.
Does
what
what
vladimir
says,
which
is
to
use
an
api
value
as
the
key,
whereas
an
api
set
named
property
uses
a
const
car
star,
utf-8
string
as
the
key.
A
E
It's
it's
not
necessarily
for
for
use
cases
where
we
already
have
an
api
value.
That
is
the
string
description.
It
is
for
use
cases
where
we
have
a
cons.
Car
start
that
is
not
utf-8
encoded
right.
In
those
cases
you
you
have
to
go
through
the
two-step
process
of
an
api,
create
string,
something
other
than
utf-8.
E
You
know
either
latin
one
or
utf-16,
and
then
you
would
say
an
api
or
node
api
symbol
for
value
and
then
that.
E
E
Just
thinking,
okay,
there.
E
Workaround
there
is
another
one
around
you
can
say
you
can
say
an
api,
create,
string,
utf
or
create
string,
utf-16
and
then
an
api
get.
I
forget
what
the
name
is:
an
api
gets
string,
value,
utf-8
and
then
you're
using
v8's
own
conversion,
library
to
to
re-encode
the
string,
and
now
you
have
the
string
and
now
you
call
whatever
you
want.
I
mean
sorry,
you
called
node
a
symbol
4..
So
then
that
would
be
three
steps.
C
A
I
guess
I'm
like
I'm
just
thinking
coming
from
the
perspective
of
aren't
most
of
these
like
when
we,
when
you
create
a
symbol
or
whatever,
are
we
really
going
to
be
getting
it
from
somebody
else
or
is
it
like
99
percent
of
the
time
just
gonna
be
like
hey?
I
want
to
define
a
symbol
that
I'm
using
or
it's
a
well-known
symbol
in
which
case
is
just
like.
F
E
Utf-8
encoded
yeah.
I
think
I,
I
think
yeah,
that's
that's
kind
of
a
good
point.
I
think
the
correct
me
if
I'm
wrong.
The
use
case
here
is
where
you
have
where
you
have
different
entities
in
control
of
creating
the
symbol
versus
using
the
symbol
and
then
and
then
they
agree
on
the
name
of
the
symbol,
and
then
you
retrieve
it
and
so
like
you
need
you
need
to.
E
A
E
E
If
you
like,
you
know,
just
dump
the
object
and
then
check
its
keys
and
stuff,
and
then
even
in
that
case,
why
not
have
that
the
utf-8
yeah
yeah?
I
mean
most
likely
it's
going
to
just
be
plain
ascii
right,
in
which
case
it
is
utf-8
de
facto
yeah
yeah.
Well
I
mean
look.
We
can
always
add
it
later.
I
mean
it's
additive
right,
it's
some
minor.
We
can
add
it
that
needed.
C
So
about
length
just
a
quick
question:
would
it
create
additional
issues
if
we
call
v8
api,
like
does
v8
api
allows
to
this
file.
E
Yes,
yes,
I
mean
that's
how
we
do
it
for
for
for
regular
strings
right.
So
I
mean,
if
you
look
at
the
implementation,
I
have
to
roll
the
shared
screen,
but
I
can't
grow
my
own
copy,
so
here
we
go
so
on
the
yeah,
so
so
in
in
the
implementation,
it
actually
creates
a
v8
string.
C
E
And
it
creates
it
from
utf-8,
so
it
says
check
new
from
utf-8.
It
uses
that
macro,
so
it
does
create
a
javascript
string
first
and
then
it
gets
the
symbol
for
the
javascript
string.
So
internally
it
does
do
that.
So
then,
however,
we
create
a
javascript
string
in
get
string
or
create
string.
Utf-8
is
the
way
we
would
do
it
here.
A
E
The
other
side
yeah,
let
me
see,
I
think,
create
string.
Utf-8
is
not
a
preamble
one
right
because
it
doesn't
call
into
javascript.
So
I
mean
this.
The
implementation
of
this
api
could
fairly
cheaply
call
an
api,
create
string
utf-8,
instead
of
calling
like
check
new
from
utf-8
or
it
could
just
duplicate
the
implementation
or
or
it
could
create
an
inline,
and
they
both
call
the
same
inline.
E
There
are
a
million
ways
of
implementing
it.
Is
it
it
is.
It
is
partially
a
wrapper
around
existing
node
node
apis
right
right,
the
string
creation
one
in
particular,
so
it
could
call
the
string
creation
one
and
if
that
doesn't
return
an
api
okay,
then
this
just
returns
that
guy's
status
and
and
it
would
still
not
be
slower-
it
would
be
just
marginally
minimally
slower
if
it
did
that,
but
I
don't
see.
E
Well,
I
mean
if,
if
we
add
the
parent,
the
length
parameter,
which
I
think
we
should
then
then
it
it.
It
turns
into
a
copy
of
an
api,
create
string,
utf-8
right
right,
okay,
so
so
that's
why
it
means
it
may
just
be
simpler
to
just
call
that
function
and
then
just
say:
js
value
from
v8,
local
value,
v8,
symbol,
4
and
isolate
and
then
low
v8,
local
value
from
js
value,
and
then
description
string.
E
And
okay,
I
okay
back
in
the
day,
we
had
a
security
vulnerability
with
strings,
but
I
think
that
was
that
was
for
retrieving
the
string
right.
We
had
some
buffer
issues
which,
which
we
fixed
right.
So
it
wasn't
the
creation
that
was
the
problem.
It
was
the
retrieval
of
the
c
string
that
was
problematic
right.
So,
okay,
just
trying
to
remember,
because
in
that
or
do
you
remember,
michael,
I
don't.
E
Yeah,
I
think
it
was
the
retrieval
of
the
string.
I
I
can
double
check,
blame
blame
the
header
or
not
the
head
or
the
implementation.
A
E
Yep,
yep
and
and
maybe
maybe
change
the
the
name
of
the
parameter
to
utf-8
description
instead
of
instead
of
just
description
to
make
it
clear
that
it
has.
Oh,
oh
you
did
there.
A
F
Description
for
consistency.
Sorry,
like
this
yep.
E
A
E
Yeah,
yes,
you
may
also
want
to
like
request
changes
because,
like
five
different
people
have
already
approved
this,
so
you
don't
want
this
to
land.
I
think
I
already
marked
it
as
blocked.
E
Drag
over
I
don't
know
what
happened,
but
there's
no
request
changes
right
now,
so
this
might
accidentally
land,
as
is
sure
I'll,
say:
okay,
request
changes.
E
Yeah,
I
think
you
need
to
go
back
to
the
to
the
files
thing.
D
D
Let's
take
a
quick
look,
this
is
the
last
one
that
was
added
a
while
back.
C
I
put
in
the
end
this
big
break.
Okay
well
have
like.
I
was
looking
through
this
standard
myself
and
also
I'll
ask
our
internal
visual
c,
plus
plus
discussion
group
special
interest
group,
and
they
have
a
bunch
of
different
ideas
and
stuff,
but
anyway,
on
the
on
surface.
C
What
pretty
much
says
like
if
we
have
close
qualifier
for
a
function,
cons
qualifier
effectively
affects
how
this
this
pointer
looks
like,
and
there
is
think
if
somebody
tries
to
modify
const
fields
it
may
they
may
kind
of
observe
some
kind
of
so-called
undefined
behavior
and,
for
example,
visual
c
plus
plus
can
just
simply
put
some
fields
and
satisfied
only
memory.
If
you
scroll
down
a
little
bit,
there
is
pro
kind
of
sample
of
the
programs
like
one
of
visual
c
plus
plus
developers.
C
As
shown
like
you
see
this
pretty
much.
E
C
C
But
in
our
case,
I'm
showing
this
pretty
much.
How
in
our
case,
this
code
might
look
like
just
kind
of
as
a
sample.
If
you
scroll
down
a
little
bit
more
sure,
we
don't
really
modify
any
fields.
We
pretty
much
just
use
this
field,
which,
inside
of
the
object
this
field,
we
never
modify.
We
pretty
much
modify
what
whatever
this
field
points
to
and
according
to
most
people
on
this
discussion
list,
people
said
that
we're
not
doing
anything
illegal
and,
as
you
can
see
this
this
this,
this
code
is
written
here.
C
It
runs
and
compiles
without
issues,
and
we
don't
do
any
kind
of
conscious
casting
here
and
stuff.
It
just
works.
H
C
Go
ahead,
the
summary
is
actually,
if
we
mark
all
methods
const,
we
don't
really
violate
anything
and,
as
we
talk
about
any
possible
code
optimizations,
I
didn't
find
any
explicit
clause
anywhere
inside
of
standard
but
standard.
Pretty
much
says
like
that.
Pretty
much
implementations
means
like
if
they
have
any
kind
of
implementation.
Specific
optimizations
must
not
change
any
kind
of
external
observable
behavior,
so
I
would
say
if,
based
on
a
cost
qualifier,
they
decide
not
to
call
certain
methods.
C
They
would
actually
may
change
externally,
observable
behavior,
so
good
compiler
implementation
will
be
prohibited
to
it.
C
So
const
qualifier
in
c
plus
plus,
does
not
say
that
is
not
the
same
as
saying
like
we're
retrieving
some
immutable
values
so.
B
E
I
I'm
thinking
the
const
const
tends
to
be
sort
of
viral.
If,
if,
if
you
like,
let's
say
like,
for
example,
one
one
classic
example
is
is
trying
to
do
like,
like
mem
copy
right,
mem
copy
takes
void,
star,
not
const
void
star.
So
if
you
have
a
const
void
star
as
the
source
right,
then
you
still
have
to
const
cast
it,
because
the
compiler
will
complain
right
because
the
in
mem
copy
takes
a
plain
void
star,
even
as
the
source,
even
though
it
doesn't
modify
it.
E
You
pass
it
into
a
node
api
like
a
c
api
right
now,
it's
the
compiler
is
going
to
complain
because
the
c
api
isn't
defined
as
const
and
api
value
right,
and
so
the
an
api
value
is
stored
in
a
const
class
and
therefore,
when
you
pass
it
into
into
the
c
api
it
it
takes.
The
const
miss
with
it
and
it
will
be
passed
in
as
a
const.
An
api
value.
C
So
if
you
scroll
all
the
way
down
to
this
example,
like
that's
what
I
try
to
kind
of
emulate
this
behavior
in
small-
let's,
let's,
let's
look
at
this
so
first
first
pre
aligns
the
code
is
pretty
much
analogous
to
what
we
have
in
a
node
api.
Like
I
say,
we
have
get
property
and
set
property
which
accepts
just
okay,
it's
not
void
star,
but
imagine
it's
like
void
star
right,
yeah,
yeah
yeah,
because
I
just
it's
just
for
brevity.
I
want
to
have
something
which
like
where
is
minimal
and
it
works.
C
G
The
statement
about
the
const
in
the
example
I
have
stated
in
about
that
why
the
current
way
we
market
market
as
constant
is
working
is
because
we
define
not
b
method,
not
p
functions
as
c
declarations,
and
we
don't
have
const
marks
in
c
declarations,
so
super
express
compiler
doesn't
and
just
simply
ignore
the
cons.
G
The
fact
that
we
may
we
are
calling
non-const
c
plus
plus
function
in
our
not
p
implementations,
so
it.
The
fact
is
that
we
are
called.
If
we
mark
this
method
as
const,
then
we
are
calling
non-const
c
plus
plus
functions
from
const
c
plus
plus
functions,
which
we
which
to
I
was
understanding,
is
violating
the
c
semantics.
E
Vladimir,
I'm
wondering
what
flags
did
you
compile
this
with?
You
know
like
if
you,
if
you
compile
this
code
with
the
strictest
possible
c
plus
flags,
would
it
not
complain
about
constantness.
C
E
C
I
tried
like
different
compilers,
like
says
c,
plus
plus
fourteen
c
plus
plus
twenty,
and
it
was
like
permission
minus
so
I
I
used
to
do
it
in
visual
c
plus
plus.
Could
you
try
this
this
small
example
with
self
self-contained
examples?
So
thank
you.
Ideally,
if
you
just
simply
copy
and
paste
it
and
compile
with
your
compiler,
you
should
see
it's
working.
It's
working
program,
yeah.
E
A
F
E
No,
I'm
just
I'm
just
worried
that,
with
with
with
certain
very
very
strict
flags,
it
will
pass
the
const-ness
of
the
pointer
into
well.
It
does
pass
the
constants
of
the
pointer
that
is
stored
inside
the
const
object
into
the
c
api,
but
only
with
certain
flags
does
it
complain
when
you
do
that
it
always
does
that.
C
And
just
to
be
on
the
same
page,
the
proposal
here
is
put
const
in
the
end
of
function,
kind
of
methods.
So
in
this
case
our
value
object
can
be
used
say
in
some
lambda
captures
and
stuff,
because
all
the
kind
of
lambda
captures
by
default.
It's
actually
const
unless
we
say
immutable
qualifier
in
the
end
of
london.
G
Yeah,
otherwise,
the
motivation,
but
my
question
is
that
we
are
calling
we
we
why
the
reason
we
are
adding
the
cost
mark
in
this
method
is
that
we
are
trying
to
call
in
this
method
from
constant
lambdas.
But
the
fact
is
that
this
this
method
is
calling
the
properly
non-const
engine
c,
plus
implementations.
C
In
our
case,
literally,
if
we
look
at
the
value
object,
state
is
only
an
api
value
effectively.
The
point
pointer
with
value
objects,
stores
so
think.
As
long
as
this
method
does
not
modify
this
pointer
in
wrapped
by
kind
of
value
class,
we
should
be
fine
from
this
definition
point
of
view,
because
we
what
we
saying
that
we
we're
calling
some
c
functions
which
do
something
around
this
with
this
pointer
right.
But
we
don't
really
modify
this
class
right.
C
A
A
But,
but
I
guess
it's
like
is
there?
Is
there
somewhere
in
the
spec
that
specifically
says
that,
like
if
the
specs,
the
spec
had
a
section
that
said
the
state
of
the
object
is
just
the
in-memory
representation
of
the
object
itself?
For
example,
you
know
calling
a
method
on
an
object
that
it
points
to
which
changes.
The
state
of
that
method
does
not
affect
the
state
of
the
object
that
you
know
it's
it's
that
transitive
state
is,
I
think,
we're
at
what
we're
talking
about
right.
A
C
Right,
I
guess
there
is
a
kind
of
definition.
Then
we
declare
a
class,
so
think
of
class
says
like
it
has
different
members,
including
fields,
so
think
the
state
of
the
object
is
just
fields
inside
of
the
soldier,
so
just
the
way
c,
plus
we,
I
can
probably
find
like
what
exactly
this
class
definition
is.
But
it's
I
guess
it's
no
difference
from
what
in
c,
if
you,
if
you
take
extrapolate
content
of
the
struct,
is
the
only
thing
like
which
really
controls
it.
C
A
C
So
here's
just
by
recognition
as
pretty
much
just
they
just
I
tried
to
look
for
the
spec
to
find
something
that
was
unfortunate,
but
not
so
much
about
this
con
stuff,
and
this
will
one
of
the
things
I
found
that
this
observer
functions.
I've
got
spec
uses
in
some
other
text
down
down
down
the
line,
but
I
just
felt
like
I
can
pull
here
for
completeness.
C
C
Saying
what
what
some
somehow
like?
What
const
really
means?
Sometimes
it's
more
like
to
define
a
term
in
this
brain,
but
but
what
really
kind
of,
if
you
look
on
this
spec,
what
what's
really
important
the
constants
on
the
method?
Pretty
much
says
how
exactly
this
pointer
treated
inside
of
inside
of
this
method,
what
it
exactly
means
and
what
it
pretty
much
says
that
it's
a
it's
a
pointer
to
severe
qualified
sequence
x,
so
think
it's
a
pointer
to
cons,
qualified
x.
C
On
a
method,
it
means
it's
expected
that
the
whole
class
was
declared
as
constant
as
we
can
see,
for
example,
in
this
example,
const
s1,
so
typically.
A
A
C
Then
I
can
modify
this
example.
That's
pretty
much
the
same
with
what
we
already
have,
because
in
c
plus,
plus
struct
in
class,
the
interchangeable
keywords.
It's
just
control
default.
Visibility
of
the
members
class
classes
default
visibility
is
private
and
structures
default.
Visibilities
right,
I'm
just
I
was.
A
Just
like
these,
these
are
not
part
of
like
these
methods
are
not
part
of
a
pointer
that
this
class
points
to
right
or
unless
I'm
reading
now
instruct
okay.
Now
there
are
these.
C
So
say:
set
property,
you
see,
we
may
define
member,
let's
say
of
another
class,
so
it's
pretty
much
as
we
would
call
non-cons
method,
and
you
see
we
don't
do
any
cons
cast
like
it's.
It's
totally
illegal
to
do
it.
C
A
G
Yes,
I'm
sorry,
but
I'm
a
little
bit
confused
about
it
is
that
if
we
can't
call
const
if
we
can't
cope,
non-const
c
plus
plus
functions
in
c
plus
constant
supers
from
class
functions,
then
why
should
we
allow
calling
non
calling
a.
G
A
c
function
which
delegate
into
a
non-constant
c
plus
plus
function
in
a
const
c
plus
plus
functions,
and
I
I
know
they
are
why
c,
plus
plus
compilers
allowing
this
is
that
we
have
to
make
this
c
plus
plus
programs
to
be
compatible
with
this
c
headers
defined
apis
so
that
we
can
reuse
this
see
how
c
see
how
those
defined
apis
without
any
modifying
modifications,
but
if,
if
in
the
fact,
is
that
we
are
calling
non-constant
c
plus
plus
functions
in
this
c
apis,
we
know
that,
even
though
that
c,
plus
plus
compiler
don't
complain
about
that
since
c
classifier
compilers
have
no
knowledge
about
it.
G
If
this
c
functions
are
calling
calling
non-constant
c
plus
plus
functions,
so
it's
the
fact
that
this
c
functions
is
calling
non-constant
it
has,
then
why
should
we
to
escape
about
the
rules?
That
c,
plus
constant
c
plus
price
function
should
not
call
non-constant
c
plus
function?
G
I
mean
compilers
are
definitely
not
allow
us
calling
c
functions
in
our
c
plus
class
functions
marked
as
const,
but
if
we
don't
have
these
c,
plus
plus
definitions
in
between
the
non-constant
c
plus
first
function
under
these
constant
c
plus
functions,
then
compilers
will
complain
about
it.
G
So
since
currently
we
have
a
api
c
definition,
c
declarations
in
between
the
engine
and
the
node
add-on
api
and
see
the
c-plus
compilers
had
no
acknowledge
no
knowledges
about
the
engine's
implementation.
Since
we
allow,
we
only
expose
these
the
sea
headers,
which
don't
have
the
which
don't
have
like,
say
const
marks
in
c
headers.
A
C
So
my
answer
to
this
question
is:
yes,
it's
only
way
it's
only
time
when
it
will
be
prohibited
when,
if
this
pointer
to
be
itself,
con
declares
as
const
so,
for
example,
in
this
small
code,
as
we
see
on
screen,
ss1
pointer
is
not
const,
so
think
any
methods
on
s1
object
s,
even
if
the
non-const
allowed
to
be
called.
A
A
C
I
I
can
provide
this
with
my
child,
as,
as
you
wrote
in
this
description,
let
me
add
later
today,
example
just
concerned
with
c
plus
plus
classes,
if
you
like
right,
that's,
but
I
kind
of
99.999
sure
that
percent.
A
A
Because
I
think
if
the
compiler
allows
that
like,
if
effectively,
you
can
call
a
non-const
method
on
some
other
class,
even
if
you
have
a
reference
to
it,
that
confirms
like
the
compiler
isn't
considering
like
it.
Isn't
it
isn't
flowing
that
const
through
to
other
things
that
you
make
on
other
on
other
classes,.
E
Right
yeah,
I
think
so
yeah
I
think
I
think,
const
on
on
cpp
value
just
means
you
cannot
assign
a
value
to
to
s
which
is
a
member
of
cpp
value.
You
cannot
assign
a
value
to
that
pointer,
but
the
pointer
that
you
already
have
you
can
pass
that
into
functions
that
require
a
const
pointer
or
into
functions
that
record
that
don't
require
a
const
pointer.
You
can
pass
it
in
either
way
and
and
to
get
proper
to
get
underscore
property
and
get
set
underscore
property.
E
They
do
not
require
a
const
pointer,
which
is
fine,
because
you
don't
have
a
const
pointer
and
you
can
pass
it
in
just
fine
right.
The
the
the
class,
the
the
the
constantness
of
the
entire
class
and
the
constantness
of
the
method
does
not
propagate
to
s.
That's
the
thing.
I
guess
like
what
sorry
go
ahead.
I
it's
like
like
the
constant
ends
with
s,
and
I
think
I
think
what
what
what
what
makes
it
not
propagate
is
the
fact
that
s
is
a
pointer
right,
because
then
you
cannot
follow
you
can
you.
E
A
I
guess
just
what
you
know.
What
would
make
it
convincing
to
me
is
if
we
see
it's
like
purely
c
plus
plus,
but
we're
effectively
doing
the
same
thing
and
the
compiler
is
not
complaining
about
it
like,
then,
I
think
it's
that
that's
the
thing
that
makes
me
say:
okay,
yeah
I
can.
I
can
see
that
the
compiler
is
not
and
whereas,
if
we
switch
to
c
or
whatever,
then
you
start
to
worry,
we're
like
well
wait
a
sec.
Is
it
because
we're
breaking
that
barrier
or
whatever?
A
But
if
it's
purely
c
plus
and
it's
like?
Basically,
I
can
construct
the
c
plus
plus
code.
That
is
a
const
method.
That
says
you
know
I
can
do
you
know,
get
get
x
on
the
class.
I
can
then,
and
that
and
that
get
indirectly
gets
the
state
from
some
other
c
plus
object.
And
then
I
do
a
another
const
method,
and
then
I
call
the
get
again
and
it's
a
different
value.
Then
I
think
you
know
c
plus
plus,
isn't
enforcing
things
and
therefore
couldn't
be
wrote.
E
Yeah
for
what
it's
worth
one
one,
one
thing
that
you
can
do
to
make
sure
that
constantness
is
is
kosher,
so
to
speak,
is
to
compile
with
minus
w
cast
dash
qual,
which,
which
means
complain
whenever
there's
an
unsafe,
cast
that
discards
qualifiers,
whether
that
cast
is
explicit
or
implicit.
So
sometimes
there
are
implicit
casts
that
happen
right
and
if
you
add
this
minus
w
cast
dash
qual,
then
you'll
get
a
warning
whenever
you
do
an
unsafe
cast
and
most
often
that
is
casting
away
const
accidentally.
E
A
A
E
I
think
in
general,
what
what
we
should
aim
for
when,
when
we're
making
these
like
language-based
decisions,
is
to
keep
in
mind
that
there
are
folks
out
there
who
come,
who
compile
this
code
with
the
most
pedantic
and
most
paranoid
flags
available
in
the
compiler,
and
our
code
has
to
pass
that
check
and
then
and
then,
based
on
that,
we
can
make
this
decision,
which
makes
me
think,
maybe
we
should
crank
up
the
the
paranoia
on
our
on
our
build
system.
E
G
1000,
it's
number
one
thousand.
G
G
G
A
Yeah
yeah
like,
if
you
think
it's
relatively
low
risk,
you
know
I
I
think,
like
basically
providing
a
pr
with
the
back
port
and
having
the
discussion
in
that
issue
is
probably
the
the
best
bet
you
know,
and
if
it's
relatively
low
risk
and
in
sk
and
low
in
scope,
then
I
suspect
it's
got
a
it's
got
a
reasonable
chance
of
landing.
I
think
12,
maybe
not
like
12,
is
close
enough
to
being
out
of
service
that
maybe
it's
not
worth
doing
it
there,
but
14
still
has
more
than
a
year
left.
A
E
Okay,
but
it's
worth
the
the
more
the
more
versions
we
can
cover
the
better
right
I
mean,
even
if
it's
not
perfect,
sooner
or
later,
these
versions
will
be
the
lts
version
that
sooner
or
later
they
will
be
to
maintenance
versions.
So
it's
it's
benefit
either
way
it's
just.
How
much
can
we
maximize
the
benefit
right,
yeah.
D
A
A
But
you
know
that's
where
like,
if
it's
small
enough
and
it's
in-
and
it's
in,
you
know
low
enough
risk,
then
maybe
you
know
people
will
be
like
comfortable
if
it
was
huge.
The
answer
would
probably
be
no,
but
I
think
that
one's
worth
like
submitting
the
pr
if
you
you've
pretty
much,
got
it
and
see
what
other
people
think
as
well.
A
Yeah
sounds
good.
Then
it's
already
fixed
in
16
right
yeah.
It's
ended
with
the
beard
version
bump
right,
yeah,
okay,
so
right
so
yeah.
I
think
just
the
back
port
to
14
could
make
sense,
and
so
I'd
open
the
pr
and
see
what
what
people
think
yeah
sounds
great.
Okay,
yeah!
No
thanks
for
digging
into
that
and
identifying
the
specific
thing
and
jack
also
for
like
getting
it
down
to
the
point
where
we
knew
it
was
in
where
to
look
in
at
the
v8
change
changes
by
any
other
things.
A
We
should
talk
about
before
we
close
out
otherwise
we'll
defer
everything
to
next.
A
Time,
good
with
that,
okay!
Well,
thanks
everybody
for
your
time
and
the
good
discussion,
we
will
talk
to
everybody
next
week,
talk
to
y'all
later.
Thank
you.