►
From YouTube: 2020-10-30-Node.js N-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
A
Okay,
so
the
first
one
is
this
crash
reported
due
to
node.js
34839.
We
talked
about
this
last
week.
I
did
submit
the
pr
revert
and
it's
going
through.
The
process
like
it
needs
to
be.
It's
landed
in
master
it'll,
be
needed
to
be
backported
to
14
and
12.,
but
I
think
we
can
probably
close
out
this
since
it's
it's.
I
just
opened
it
to
make
sure
that
we
discussed
it,
and
I
think
it's
now
in
hand.
B
So
I
I
I
looked
at
it
again
at
the
previous
solution
and
basically
the
problem
is
that
so
one
when
you
have
a
strong
reference
right,
you're
you're
not
really
supposed
to
unref
it
before
you
delete
it,
because
there's
no
point
like:
what's
the
point
of
unwrapping
a
strong
reference
making
it
weak,
there
is
no
finalizer
right
that
is
attached.
So
why
would
you
do
that
right?
B
B
It's
gonna
get
finalized.
So
so
that
was
the
problem.
The
reference
was
being
unlinked
from
the
from
the
list
and
it
was
placed
into
like
a
waiting
for
the
finalizer
to
run
state
right
and
that
that
never
happened.
So
that's
why
it
was
leaking
so
so
then
we
have.
We
have
several
choices
as
to
how
to
fix
the
leak.
Now
we
can
either
say
you
know:
you're
not
allowed
to
unref
a
strong
finalizer,
because
that
doesn't
make
any
sense.
B
B
A
Well,
like,
basically,
if
you
in
the
finalizer
so
in
the
finalizer,
you
could
delete
the
ref.
So,
let's
see
so
you
have
a
weak
reference.
A
It
doesn't
have
a
finalizer,
I'm
thinking
that,
like
it
clean
itself
up.
B
A
B
At
all,
okay,
yeah,
yeah,
okay,
I
see
what
you're
saying
so
so
you
want
to
retain
yeah.
But
that's
that's
why
you
have
a
finalizer
right
is,
if
you
want
to
retain
the
ability
to
delete
it
on
your
own
terms
and
at
your
own
convenience,
then
you
keep
it
strong
right,
but
if
you
also
want
to
be
notified
when
when
javascript
doesn't
need
it
anymore,
then
you
keep
it
weak
right,
but
then
you
keep
it
weak
and
you
keep
a
finalizer
on
it
right.
B
A
A
B
Yeah
yeah,
okay,
well,
anyway,
that
that's
just
this
is
one
possible
way
of
approaching
it.
Right
is
to
to
say
you
know,
don't
don't
unref
before
deleting
if
it's
a
strong
reference,
the
other
approach
is
to
to
track
this
particular
sequence
of
events.
You
know
a
a
reference
becomes
weak
while
the
environment
is
being
torn
down
right
right.
B
Excuse
me,
so
I
actually,
I
actually
re-fixed
the
bug
that
way
right.
So
basically,
I
added
a
new
flag
that
says
you
know
weakened
during
teardown
and
then
you
know
if
it's
weakened
during
teardown,
then
don't
defer
deletion
delete
right
away
because
the
finalizer
is
gonna
get
called
anyway
right.
It
doesn't
matter
if
there's
a
finalizer
attached
during
environment
teardown
it
doesn't
matter.
If
the
reference
is
strong
or
weak,
all
the
finalizers
will
get
called
right.
That's
that's!
That's!.
A
B
B
Yeah
yeah.
Never
I
forgot
to
mention
a
crucial
piece:
okay,
so,
okay,
so
okay!
So
during
nappy,
what
is
it
well
during
unref
right?
B
You
you
pass
in
whether
the
environment
is
being
torn
down
or
not
right,
okay,
so
so
you're
passing
unref
so
far
has
had
no
arguments
right
now
we
pass
in
an
argument
that
says:
is
environment,
tear
down
right,
and
so
you
know
the
unref
code,
basically
decrements
the
the
the
value,
and
if
the
value
is
zero,
does
a
set
week
right
right,
so
so
so,
in
addition
to,
in
addition
to
not
deferring
deletion,
you
also
don't
set
the
week
right
right
because
because
set
week
set
set
week
is
a
v8
mechanism.
B
Me
when
your
garbage
collect
right,
yeah,
but
there's
no
point
in
doing
that
anymore,
because
the
environment
is
being
torn
down
right.
So
there's
no
point
in
calling
set
week,
so
just
so
just
put
that
behind
an
if
statement
right,
if
the,
if
the
environment
is
going
down,
then
don't
call
set
week
right
and
so
so
what
ends
up
happening
is
if
there
is
a
finalizer,
if
there's
a
user-provided
finalizer,
it
will
be
called
during
environment
teardown
because
of
finalize
all
right.
If
there
is
no
user
finalizer,
then
it
will.
B
It
will
not
be
called
because
well,
there's
no
user
finalizer,
but
the
invite,
but
either
way
the
reference
will
be
deleted
right
going
through
all
the.
A
B
So
so
yeah,
that's
that's
that's
something
that
I
haven't
tested
yet
I
I
suspect-
and
I
have
to
write-
I
have
to
write
a
test
for
this-
that
if
there
is
a
finalizer,
it
will
get
called
because
the
the
reference
will
remain
on
the
will
remain
linked
to
the
linked
list
of
references
that
are
being
maintained
by
the
environment
and
the
environment
is
going
to
walk
over
it
during
finalize
all
and
it
will
call
the
finalizer,
but
I'd
have
to
double
check
that
and
and
that
that
would
be.
B
That
would
be
a
modification
to
to
the
original
test
which
which
showed
this
leak,
because
in
the
original
test
it
is
basically
nappy
create
reference
during
during
a
function
call
coming
in
from
javascript
and
then
there's
also
a
nappy
wrap
of
an
object
that
is
also
coming
in
from
javascript
and
when
the
finalizer
for
that
object
gets
called
in
the
body
of
that
finalizer.
There's
a
nappy
reference
unref
and
that
be
delete
reference.
B
So
that's
that's!
What's
causing
the
leak
right
and
if
you,
if
you
comment
out
the
nappy
reference
unref,
then
everything
works,
fine
right,
and
so
so
that's
why
I
special
case
nappy
reference
on
ref.
I
add
that
flag
right
so
that
we
flag
the
situation
where
you're,
unwrapping
or
weakening
more
specifically
weakening
something
during
environment
tear
down
right.
B
So
but
but
there
is
a
way
to
attach
a
strong
reference
with
a
finalizer
right,
because
if
you
just
do
nappy
create
reference,
it
doesn't
allow
you
to
attach
a
finalizer.
But
you
can
also
do
a
nappy,
add
finalizer
now
which,
which
creates
a
weak
reference
with
a
finalizer
by
default,
but
it.
But
it
allows
you
to
to
receive
the
reference
back
and
then
you
can
just
call
an
appy
reference
ref
and
then
you
will
basically
have
created
a
nappy,
strong
or
a
strong
reference
with
a
finalizer
right.
A
A
A
I
don't
understand
this
well
like
so
you've
written,
you
can
add
a
finalizer
which
runs
and
I'm
I
haven't
thought
it
through,
but
I'm
wondering
if
there's
any
case
where
that
finally
is
or
which,
what
as
you're
saying,
will
run
anyway
right
because
we're
doing
shut
down
yeah.
A
B
A
B
A
B
A
B
Condition
exactly
so,
basically
we're
we're
basically
lying
to
the
user
right,
because
the
other
choice,
the
other
choice
that
we
have
is
in
nappy
reference
on
ref.
We
say:
okay,
if
it's
environment
shutdown,
then
don't
decrement
the
counter
and
just
return
one
instead
of
zero
right,
but
that's
also
a
breaking
change,
because
if
you
nappy
on
ref,
you
expect
the
counter
to
go
down
by
one
right.
I
think
so.
B
Yes,
yes,
but
okay,
so
so,
basically,
let's
say
you
have
a
a
strong
reference.
It
has
ref
count
one
and
you
call
nappy
nappy
reference
unref
during
environment
shutdown,
right
yep
with
the
change
you
still
decrement
the
counter.
It
reaches
zero
right,
but
you
don't
attach
the
set
week
right
right.
Okay,
because
it
you
you
you,
you
know,
you
are
aware
of
the
fact
that
this
is
environment,
shutdown.
So
there's
a
special
case
right.
B
You
don't
set
the
week,
so
nothing
will
happen
later,
but
you
still
return
zero
to
the
user
as
expected
right,
and
so
so
you
store
the
flag
that
this
reference
was
weakened
during
environment
shutdown,
right
inside
the
reference
right
and
so
during
delete.
We
have
this.
We
have
this
series
of
conditions
under
which
we
delete
immediately.
Otherwise
we
defer
right
right
so.
D
B
Of
them
is
that
it's
a
strong
reference.
If
it's
a
strong
reference,
we
delete
right
away
right.
The
other
one
is
if
delete
self
was
set
or
sorry.
If
finalizer
ran
right,
that's
the
other
condition
and-
and
we
have
a
third
one-
I
I
think
it's
delete
itself
so
anyways
so
to
this
list
of
ord
conditions.
You
add
one
that
says
if
it
was
weakened
during
shutdown,
then
delete
right
away
right
right,
but
then.
B
B
Okay,
so
delete
itself
is
being
called
from
where
oh
come
on,
call
and
call
and
delete,
is
how
you
would
call
that,
because
it
is
static.
Okay,
so
reference
delete
reference.
Okay,
so
we
call
that
from
unwrap
okay,
but
this
is
this
is
not.
B
This
is
not
specific
to
okay,
so
we
call
it
for
nappy,
delete
reference
explicitly
and
set
instance
that
what
the
heck,
where,
where
is
this?
Oh,
it
might
be
v8
dot
h.
B
So,
let's
the
way
we
call
delete,
I
believe,
is
that
we
call
finalize
and
then
finalize
calls
delete.
That's
if
I
remember
correctly
so
then
call
and
call
and
delete
no.
Where
do
we
do
that.
A
B
Okay,
all
right,
so
here
it
is
here
it
is
so
okay,
so
we
have
a
protected
inline
void.
Finalize
example
tear
down
right
so
so
then,
okay
finalize
calls.
If
we
have
a
user
provided
finalizer,
we
call
the
finalizer
and
then
we
call
delete
so
so
then
you
know
if
if
this
is
being
finalized
via
via
the
this
is
being
yeah.
If
this
is
being
finalized
via
the
the
finalizer
loop,
that's
at
the
end
of
the
environment,
then
the
finalizer
will
be
called.
A
B
In
fact,
no
no
no
and
we
don't.
We
don't
right
because
remember
we're
talking
about
unref
right.
So
so
unref
means
normally
unref
means,
add,
add,
add,
add
a
week
reference
to
it
right
right,
but
then,
but
then
afterwards
the
user
explicitly
calls
nappy,
delete
reference
right
right,
wait
a
minute!
I
just
realized.
A
A
B
Yeah
yeah,
so
that's
good!
So
then,
so
then
whether
there
is
a
finalizer
or
not,
you
must
not
call
the
finalizer,
because
that's
what
you
would
do
during
regular
operations.
A
B
A
Basically,
what
you're
saying
is
not
responsibility.
If
you
weaken
during
environment,
then
yeah,
then
basically
it
says
well,
okay,
if
you're
doing
that,
would
you
expect
the
finalizer
to
run
or
not.
B
A
Right
so,
and
if
you
call
delete,
it
gets
deleted
immediately
and
the
finalizer
will
not
run,
but
actually
the
finalizer
won't
run
at
all.
D
B
A
B
Be
interesting
to
yeah,
basically
yeah,
because
because
right
now,
right
now
with
this
with
this
with
this
change,
the
leak
is
fixed
right
and
the
finalizer
doesn't
run
because
there
is
no
finalizer.
There's
there's
nothing
to
run
it's
just
a
reference
without
a
finalizer
right
that
is
being
weakened
and
then
destroyed
so
right.
So
this.
D
B
I
believe
is
correct
as
it
is
right,
but
we
have
to
further
explore
the
behavior
that
this
causes,
when,
when
you
do
have
a
finalizer
right
so
so,
basically
as
it
is
currently
on
main,
if
you,
if
I
were
to
create
this
reference
using
using
nappy
ad
finalizer
rather
than
nappy,
create
reference,
then
I
have
to
double
check
whether
the
finalizer
runs
or
doesn't
run.
B
B
So,
okay,
so
this
is
what
happens:
okay
in
currently
on
main
okay.
So
when
you
unref
it
sets
the
week
right
and
then
and
then
the
the
add-on
explicitly
calls
delete
right
right
and
then
that
calls
delete
on
that
explicitly
calls
delete
on
the
reference
which
causes
it
to
be
removed
from
the
linked
list.
But
then
it
doesn't
get
deleted.
It
gets
removed
from
the
linked
list,
but
it
doesn't
get
deleted
because
the
reference
count
is
zero
and
the
finalizer
hasn't
run
yet
right
right,
and
so
it's
waiting.
B
B
We're
going-
maybe
it's
so
but
you're
going
through
and
running
all
the
finalizers
right
on
all
the
objects.
Yes,
but
this
one
is
unlinked
because
it
it
is
with
the
code
as
it
is
now
it.
It
gets
unlinked
from
the
list,
because
it
expects
that
it
will
not
be
the
finalize
all
that
will
remove
it,
but
rather
the
gc's
finalizer,
but
the
gc's
finalizer
never
runs
so
yes,
another
solution
is
to
just
leave
it
on
the
linked
list,
but
I
guess.
A
A
B
D
B
Right,
you
would
be
able
to
tell
the
engine
that,
but
but
for
some
ecma
script,
standard
reasons
that
does
not
happen.
A
A
B
Well,
that's!
That's
it
right
that
that's
the
problem
right
now
is,
is
that
you
know
we're
expecting
the
the
the
the
gc
to
to
run
those
finalizers,
but.
A
D
B
A
B
Okay
hold
on
hold
on.
Let
me
check.
Let
me
check
okay,
so
this
is
my
change
here.
Okay,
so,
let's
see
okay
so
enter
finalize
all
yep,
finalize:
okay,
okay,
so
unrefined
ref
and
then
deleting
ref
okay.
So
it
so
unrefined
unrefined,
yeah,
okay,
wait
a
minute!
So
when
you
unref
it
it
doesn't.
B
Okay,
okay
9400
is
the
reference
I'm
interested
in,
so
you
unref
it,
but
you
don't
unlink
it.
Okay,
so
unrefined
with
this
change.
Unreffing
will
not
unlink
it
first
of
all
and
then,
when
you
call
delete
yeah
so
yeah,
so
when
you
call
delete
it
will
delete
because
the
flag
is
set.
So
so
that's
how
this
works.
B
So
then,
if
you
were
to
not
call
delete,
but
just
on
ref,
then
I
haven't
tested
what
happens
and
and
and
what
you
would
expect
is
that
unrefined
with
this
change
will
not
unlink
good.
It
remains
on
the
list,
meaning
that
it
will
be
deleted
with
a
finalizer
call
during
finalize
all
so
yeah.
That's
what
you
would
expect.
B
A
A
B
D
B
To
do
txt,
okay,
so
okay!
So
if
you
merely
unref,
the
finalizer
must
run
if
you
delete
check
whether
the
finalizer
runs
during
normal
operations.
B
A
Other
k
is
there
any
other
case
where
we
could
run
into
a
similar
problem
where
an
object
becomes
weak
yeah,
but
but
the
there's
there's
no
like
there's
no
gc
that
runs
to
clean
it
up.
A
No
in
situations
where
we're
in
environment
tear
down
but
we've
been
running
some
yeah
we've
been
running
some
user
code
and
it's
just
before
going
into
tear
down.
It
makes
a
bunch
of
things
weak
and
then
we
go
into
the
environment,
tear
down.
Unless
there's
from
what
I'm
here
hear
you
saying,
unless
there's
a
gc
between
those
two
finalizers
may
not
be
running
no.
B
B
B
A
B
And-
and
we
look
no
different
right
so,
but
in
so
basically
basically
okay,
okay,
I
think
I
think
I
think
I
know
what's
going
on
okay.
So
if
you,
if
you,
if
you're
in
normal
operations,
you
set
weak
and
then
immediately,
you
start
the
environment
to
tear
down
right,
then
you
can
be
certain
that
that
the
that
the
the
the
set
week
that
you
set
will
never
run,
because
there
will
be
no
more
gc,
because
environment
tear
down
has
started
right.
B
So
so
then,
so
then,
let's
see
when
you
get
to
delete
what
happened?
Okay,
yeah!
So
then
you
do
the
finalize
all
okay!
Okay,
I
think
I
think
I
can
trace
this.
So,
okay,
okay,
finalize
all
calls
finalized
for
everybody
which
calls
to
finalize
callback
and
then
okay
and
then,
if
delete
self
or
is
and
tear
down,
delete
this
okay.
So
then,
when
you
set
week
when
you
set
week
okay,
so
then
you
go
into
this
you're
going
to
delete,
which
is
an
h.
No
it's
here,
isn't
it
find
delete.
B
I
think
it's
ref
something
delete
reference.
Okay,
so
then,
here
you
are
so
then
so
then
you
unlink!
You
get
into
unlink,
okay,
so
then
ref
count
is
zero,
so
this
is
false,
delete
self.
I
have
to
check
if
okay
so
delete
self.
B
I
don't
know
what
that
is.
We
can
during
tear
down
is
false
because
you
weakened
it
before
tear
down
and
finalize
ran
is
also
false.
Okay,
so
so
I
have
to
double
check
whether
that
leaks,
because
it
is
possible
that
it
will
leak
because
it'll
it'll
it'll
defer
it'll
defer,
but
it
will
not
delete
and
there
is
no
more
opportunity
to
delete-
and
this
is
already
happening
from
finalize
all
okay.
So
this
is
a
good
thing
to
check.
So
this
is
a.
A
B
Oh
and
you
do
so
so
so
during
during
environment
down
the
finalizer,
will
run
right.
The
question
is:
will
the
delete
be
aware
that
the
finalized
duran
wait
a
minute?
That's
a
good
point:
let's
go
back
to
okay!
Where
did
I
come
from
okay,
finalize
finalize
bracket
bool,
I
think
yeah?
Okay.
B
A
A
B
A
B
A
It's
kind
of
like
the
the.
I
think
what
I
think
what
might
have
been
happening
here
is
that
something
so
in
the
in
one
of
the
finalizers,
so
in
environment
teardown,
all
you're
doing
is
running
finalizers
right
yeah,
so
in
one
of
the
finalizers
you've
basically
done
something
which
cues
up
another
object's
finalizer
to
be
run.
A
Right
so
now
there's
an
additional
object
that
should
have
a
finalization
run
right.
But
when
you
started
that
so
you
had
this
list,
you
had
this
list
of
things
that
needed
that
had
had
finalizers
and
and
you
needed
to
run
through.
But
when
you
started
going
through
that
list
that
entry
wasn't
in
the
list.
B
To
yeah,
yes,
yes,
okay,
it's
important
to
know
how
it
goes
through
the
list.
Okay,
so
so,
basically
it
goes
through
the
list
by
not
going
through
the
list.
So
we
don't.
We
don't
advance.
We
like
the
list
has
a
head
which
is
fixed
right
and
then
and
then
it
has
list
item
off
of
that
head
right
right.
So
basically,
what
we're
doing
is
we're
we're
always
removing
the
the
the
first
item
after
the
head
right
right.
So
so,
if,
during
that
removal
process
the
the
list
changes,
then
the.
B
B
A
B
You
know
all
references
are
kept
in
the
list,
so
if
you
merely
weaken
a
reference
that
doesn't
change
its
place
in
the
list
right.
C
A
A
B
No
well,
there
are
two.
Actually
there
are
two
lists
because
you
need
to
keep
them
separate.
So
you
there
are.
There
are
lists
of
objects
that
don't
have
user
finalizers,
there's
a
list
of
objects
that
doesn't
have
user
finalizers
and
there's
a
second
list
of
objects.
That
of
of
those
objects
that
do
have
user
finalizers
right.
D
B
Have
to
in
environment
shutdown,
you
have
to
run
the
you
have
to
finalize
those
objects
which
have
user
finalizers
first,
precisely
because
they
can
affect
the
contents
of
the
lists
right
and
because,
because
you
know
that
the
list
of
objects
that
don't
have
user
finalizers
is
safe
because
they
will
never
change
during
shutdown
right
because
they
don't.
B
I
see
what
you
mean
so
so,
okay!
Well,
no!
No,
because
you,
you
cannot
attach
a
finalizer
to
a
reference
after
you've
created
it,
you
have
to
attach
it
during
its
creation,
so
you
can
create
references
with
finalizers.
You
can
create
references
without
finalizers,
but
you
cannot
attach
a
finalizer
after
you've
created
a
reference.
Okay,
nappy,
add
finalizer
creates
a
second
reference
that
has
a
finalizer,
so
so
yeah
nappy,
add
finalizer
does
not
accept
the
reference
as
as
input
it
merely
outputs
the
reference.
So
that's
definitely.
A
B
It
doesn't
well,
okay,
okay,
it
prevented
the
finalizer
from
running
because,
currently
on
main
weakening,
it
will
unlink
it
from
the
list,
because
we
were
thinking
well,
it's
safe
to
unlink
from
the
list,
because
you
know
the
the
gc
is
going
to
run
the
finalizer
and
then
that's
gonna
delete
it.
So
it
doesn't
need
to
be
tracked
anymore
because
it's
gonna
get
deleted.
Okay
from.
B
B
A
A
B
Yeah,
okay,
okay,
yeah,
yeah
yeah.
This
was
another
option
that
I
was
thinking
about
and
yeah.
Okay,
so
all
right!
So
then
so
then
my
workflow
will
be
as
follows.
I
will
create
all
the
tests
to
ensure
that
the
behavior
is
as
expected
and
then
I'm
going
to
check
which
solution
makes
all
those
tests
pass
right.
A
B
A
D
B
B
Yeah
yeah
yeah
yeah,
okay,
okay,
but
yeah.
Okay,
let's
not
worry
about
that
future
scenario,
because
I'm
thinking
one
worry
that
I
have
is
that
is
that
during
finalize
we
run
the
user's
finalizer,
if
there's
a
user
finalizer,
but
we
should.
We
should
also
check
if
it
has
already
run,
because
if
it
has
already
run,
then
we
we
don't
run
it
again,
because
then
you
know
that'll
give
the
user
double
freeze
and
that's
not
good.
B
B
D
B
Well,
well,
let
me
double
check
that
right
now
the
user's
finalizer
has
run,
let's
see
during
finalize.
If
environment
teardown
is
false,
then
we
check
if
there
is
a
finalizer
callback
and
rerun
it
and
then.
A
And
then
I
guess,
but
I
I
think
when
that
finalizer
runs,
we
delete
it
from
the
list
too.
Don't
we.
B
Well,
we
call
delete
for
sure
which
currently
unlinks
and
let's
see
okay,
so
delete.
I
see
so
great,
okay,
okay,
so
it
unlinks,
and
if
it's,
if
it's
strong
or
if
delete
self
is
set
or
if
the
finalize
ran,
then
it
deletes
it.
So,
okay,
so
currently,
if
the
finalizer
runs
it
marks
well.
No,
currently,
if
the
finalizer
runs
and
doesn't
call
nappy
delete
reference,
then
nothing
happens
to
the
reference.
So
all
of
these
will
still
be
false
and
it
will.
It
will
not
delete
the
reference
it
will.
B
B
Yeah
exactly
yeah.
Well
I
mean
everything.
Every
change
that
we
make
right
now
should
be
keyed
on
his
environment
shutdown.
So
it
should
never
behave
differently
unless
it's
environmental
right.
D
B
C
B
B
D
B
The
set
knowing
fully
that
it's
useless,
yep
and
then
yeah
and
then
make
sure
we
get
the
finalized
sequence
right:
okay,
yeah,
okay,.
B
B
B
A
B
All
right
there
has
been
a
10x
release,
so
I
I
haven't
checked
yet,
but
it
this
may
actually
already
be
landed
on
the
10..
So
if
you,
if
you
can
you
go
to
the
to
the
tracking
pr
that
I
made
with
like
the
you
know
that
big
table,
because
then
I
think
there
are
links
there
to
the
p
to
the
pr's
that
that
are
relevant
and
we
can
check
if
they
landed.
B
Yeah
this
one
yeah
okay.
So
let's
go
to
an
api
seven
here
we
go
where
oh
that's
type
tagging.
Where
is
an
api
seven?
Here
we
go
yeah
okay,
so
we
want
to
look.
B
No
yeah
this
one
yeah
yeah,
it
should
be
on
the
10.x
branch
and
if
it's,
if
it's
followed
by
a
commit
that
releases
well,
actually,
why
don't
I
just
okay
yeah!
So,
okay,
let
me
just
let
me
just
pull
from
from
just
pull
the
tags
and
see
see
just
do
a
git
log,
one
line
of
of
what's
in
in
the
latest
10.x.
C
A
E
A
Did
I
just
comment
that
I
was
gonna
close
it
right:
okay,
okay,
so
blog
post.
Unfortunately,
we
ran
out
of
time,
and
now
I
remember
we
were
supposed
to
spend
most
of
this
week's
time
working
on
the
blog
post,
but
that's
a
little
bit
late.
B
A
C
Okay,
because
you
already
delete
okay,
yeah
okay,
so
it
is
at
the
top.
So,
okay,
okay,.
A
A
C
A
E
Yeah
thanks
yeah
me
I
I
passed
the
the
link
of
the
tweet
and
I
tried
to
make
an
image.
A
E
Mongodb
realm
now
has
been
ported
to
an
api,
excellent
yeah,
so
it
was
implemented
with
nan
and
they
with
some
iterations
ported
to
all
the
things
to
an
api
and
yeah.
B
E
E
Yeah
yeah.
In
fact,
we
are
at
2
million
yeah
14.
B
A
E
Yeah,
but
we
can
take
just
before
to
ship
the
article,
so
I
hope
that
the
number
is
to
I
yep.
A
A
A
We'll
take
a
look
next
week,
then
yep
or
or
or
I
think
in
github
as
well,
but
I
guess
the
one
thing
was
the
we
were
going
to
do
a
release
with
the
thread
ex.
I
know
you
were.
B
Yeah,
I
think
yeah.
I
don't
know
if
this
has
a
chance
to
to
to
remove
that
that
that
jib
file,
edit
okay,
because
that
is
no
longer
needed,
so
he
he
needed
to
do
that
and
and
rebase,
and
I'm
not
sure
that
he's
done
it
I
mean
I
can
chair
I've
just
promoted
kevin
because
I
didn't
notice
it
oh
there.
He
is.
D
D
No
worries
worried.
Yes,
I
did
rebase
and
re-pushed
and
on
the
ci
at
least
that's
the
ci
for
the
one
that
we
have
on
the
the
repo.
I
don't
know,
how
do
you
have
to
start
the
one
that
you
see?
Okay,.
B
Yeah
yeah
no
worries
no
worries
I'll
I'll
I'll
I'll,
give
it
I'll
give
it
a
set
of
ci's
and
then
it
they
should
be
green.
Now
there
I
don't
see
any
reason
why
they
shouldn't
be
so
I'll.
Just
I'll
just
do
another
one
of
those
tables
with
the
four
c
irons
and
if
they're
all
green,
then
then
I'll
land.
It.