►
From YouTube: Node.js Tooling Group Meeting
Description
A
For
like
a
quick,
like
recap
of,
what's
going
on
there,
I
thought
it
might
be
a
great
idea
for
core
to
have
glob
support
and
the
reason
being
is
that
a
it's
essentially
one
of
those
I
mean
it's.
It's
I
argue
it's
an
essential
building
block
of
of
a
lot
of
to
long.
If
you're
operating
on
files
chances
are,
you
are
going
to
want
to
operate
on
many
files,
and
if
you
want
to
operate
on
many
files,
then
you're
probably
gonna
want
to
support
globs
and
if
you
want
your
tool
to
work
and
be
portable.
A
A
A
Essentially,
it
would
be
a
function
or
something
a
function
right
and
you
would
give
that
function.
I
I,
don't
know
a
file
path
or
a
file
name,
and
you
would
also
give
that
function
a
glob
and
it
would
tell
you:
does
this
file
name
match
the
glob?
That's
that's
kind
of
in
a
nutshell.
What
what
a
matress
going
to
do
and
using
that
match
or
you
can
build
out
a
glob
glob
support,
and
so
you
can.
A
A
Sorry
Ben
is
tweeting
at
me,
wins
wins
the
meeting
guys
you
know
so
anyway,
so
we
wanted
to
look
around
the
for
what
what,
if
what
a
stuff
do.
So
what
does
bash
do?
So?
What
does
you
know
the
two
most
popular
node
implementations,
the
that's
gonna,
be
many
match
and
micro
match.
What
do
those
do?
How
does
get
ignore
hand
all
this
stuff
and
so
I
spent
some
time
and
I
went
and
I
did
a
comparison
across
knees
and
kind
of
I
picked?
A
A
Have
they
accept
many
options
which
do
various
things
and
and
turn
off
certain
parts
of
the
of
the
matching,
and
so
I
noted
those,
and
so
what
I
came
up
with
was
well
there's
a
lot
of
stuff
going
on
here,
and
we
know
that
you
know
it
seems
from
from
what
I
can
tell
the
mini
match
and
micro
match
are
actually
much
more
advanced
than
bash
and
bash
is
much
more
advanced
than
gets
implementation
and
gets
it
gets
implementation.
Is
it's
gets
implementation?
A
A
Don't
think
that's
going
to
be
I,
don't
think
that's
going
to
be
easy
to
determine,
and
furthermore
it's
certainly
not
going
to
be
that
easy
to
implement
I,
don't
think
John
Slinker,
who
is
there
anybody
waiting
in
the
queue
here
hold
on?
Let
me
make
sure:
no
okay,
so
John
Schilling,
Curt,
author
of
many
modules
and
one
of
them
being
micro
match.
He
was
mentioning
that
you
know
there's
a
lot
of
edge
cases
and
weirdness
around
this
as
you
would
expect,
and
so
it's
it's
not
it's
not
trivial.
A
To
do
this
sort
of
thing,
and
especially
with
the
amount
I
mean
if
you've
looked
at
micro
matches,
documentation,
there's
a
lot
of
options,
a
lot
a
lot
and
so
well,
we
kind
of
have
to
offer
them,
because
if
we
don't
and
we're
gonna
we're
gonna
miss
files,
like
you
know,
if
you
have
this,
this
weird
file
name-
and
it
happens
to
have
a
a
token
in
it-
that
your
glob
would
normally
look
at
like
I,
don't
know
an
asterisks
if
you're
filing
as
an
Asterix
in
it.
What
do
you
do,
then?
A
You
know,
and
how
do
you
write
that
glob
and
how
do
you
get
the
matcher
to
work?
Well,
the
answer
is
well,
you
got
a
you,
get
flips
me
switches
and
that's
how
you
make
the
match
or
work,
and
so
any
implementation,
that's
going
to
be
useful
I
think
is,
is
going
to
be
one
that's
going
to
have
to
offer
some
level
of
granular
control
or
I
think
it
really
is
going
to
fall
into
this
realm
of
yeah.
It
offers
some
stuff,
but
it
doesn't
match
my
file,
so
I
can't
use
it.
A
You
know
and
I
think
that
probably
happens
more
than
you'd
think
so.
That's
kind
of
where
we're
at
and
I
would
love
to
hear
your
thoughts.
You
know
that's
just
kind
of
what
I
took
from
it
is
that
this
is
kind
of
a
this
is
this
is
a
bit
of
a
can
of
worms.
You
know
just
coming
together
as
one
mind
on
this
is
going
to
be
difficult,
and
you
know,
assuming
that
happens,
the
implementation
is
not
going
to
be
easy
either.
What
do
you
think.
B
I
mean
I,
think
I
expressed
last
time,
like
I.
Think
is
a
great
idea.
It'd
be
super
useful
to
have
this
in
node,
but
I
do
agree
with
you
that,
like
there's
a
it's
after
looking
into
it
a
little
bit,
especially
it's
surprisingly
complicated,
there's
tons
of
edge
cases
and
different
use
cases,
so
I
mean
I,
yeah,
I
think
it'd
be
great
to
do
it,
but
it's
yeah.
It's
not
gonna,
be
easy.
A
Cross-Platform
support
out
of
the
box,
essentially
it
enables
tooling,
to
you
know,
work
using
nodes
facilities
on
Windows.
Just
like
it
would
you
know
Linux
machine
or
what
have
you
if
you're
using
gloves,
but
yeah
I
mean
it
might
be
after
after
looking
at
this
thing,
it
may
be
that
we
decide
that
it's
it's
just
it's
it's
too
too
much,
and
you
know
if
we
thought
rim
raff
was
was
complex.
I
feel
like
this
is
even
even
further
down
that
path.
So
yeah.
B
A
I
mean
it
would
be
valuable,
I
mean
I'm,
just
not
sure.
If
it
is
going
to
be
worth
it
actually,
I
mean
it's,
there
is
value
there
sure,
but
getting
there,
and
maybe
our
time
is,
is
better
spent
on
something
else
and
that's
not
to
discourage
somebody
who
wants
to
like
take
it
and
run
with
it
and
just
like,
send
the
PR
and
see
what
happens,
but
you
know
it
seems
it
seems
like
biting
off
quite
a
bit.
A
A
What
the
minimum
amount
of
stuff
is
that
we
need
to
implement
and
we
have
to
agree
on
it
and
ultimately,
everybody
has
to
agree
on
it
at
least
on
the
TSC
so
yeah
I.
Could
things
could
come
to
a
vote
of
course,
but
yeah
it's
I,
don't
know.
Maybe
maybe
our
time
is
better
spent
on
on
other
things
after
after
looking
at
this,
this
comparison,
what
other
people
think.
C
How
do
you
extend
that
if
it's
necessary
and
I
guess
this
kind
of
is
somewhat
of
the
same
thing
with
the
args
parsing,
if
it
doesn't
work
exactly
the
way
that
it
that
an
application
needs?
That
means
they
just
can't
use
it,
which
you
know
would
be
unfortunate,
because
that
means
that
the
nodejs
core
is
larger
and
has
a
feature
that
people
can't
necessarily
use.
C
One
thought
that
I
was
having
the
other
day.
I
was
wondering
if
it
would
be
useful
to
have
kind
of
a
more
data-driven
testing
or
that
could
be
shared
among
the
implementations
of
glob
matching.
So,
for
example,
we
have
a
list
of
glob
strings
and
you
know
basically
a
list
of
files
that
should
and
shouldn't
match
that
way
there.
We
can
kind
of
start
comparing
the
different
glob
implementations
with
hard
data
and
maybe
even
encourage
them
to
become
more
similar
if
possible.
C
That's
kind
of
I
guess
like
a
spec
test,
basically
that
you
know
we
could
have
mini
match
and
micro
match
both
load.
That
data
and
you
know,
do
the
necessary
conversions
to
make
sure
that
the
basically
to
run
the
the
functions
in
the
way
that
many
match
or
micro
match
expected
to
be
and
essentially
verify.
Yes,
we're
compliant
with
you
know
the
target
spec
or
we're
not
compliant
in
this
list
of
ways
right.
A
D
A
It's
kind
of
like
drive
from
that
forward.
I
mean
I'm,
happy
to
use
glob,
you
know
I,
guess
I'm,
not
I'm,
not
not
personally
anyway,
I'm
not
as
interested
in
in
defining
how
god
should
should
work.
You
know
my
thinking
when,
when
I,
when
I
created
the
issue
was
more
like
okay.
Well,
let's
just
take
something
that
somebody
else
has
done,
and
you
know,
let's
just
basically
try
to
find
something
reasonable
and
just
go
with
that
and
I
guess.
I
didn't
I
didn't
really
want
to
to
go
down
that
path
of
well.
A
B
I
think
didn't
we
realize
I
think
we
looked
at
this
like
last
meeting.
It
was
micro
match
and
mini
match
have
like
nearly
identical
download
numbers.
So
there's
definitely
like
a
pretty
it's,
not
there's
no
clear
favorite
there.
You
know
it's
a
pretty
like
right
down
the
middle
split
which
people
prefer,
which
I
think
is
another
challenge
right.
A
Certainly
micro
matches
has
more
features.
Micro
matches,
probably
has
you
know,
I,
don't
think
mini
match
has
been
released
in
a
couple
years,
so
it's
it's
obviously
has
more
attention
paid
to
it
recently,
but
yeah
so
I
don't
know
anyway,
I
mean
unless
somebody
feels
really
strongly
that
they
that
they
want
to
keep.
A
E
A
Yeah,
okay,
so
the
next
thing,
then,
let's
see
just
reading
CLI
tools
and
self-contained
binaries,
you
know
I
didn't
maybe
probably
just
wasn't
paying
attention,
but
I
don't
see
anything
new
here.
Do
you
know
I,
don't
know
why
this
is
on
the
thing.
A
A
Argument
parsing
as
well
is
this
one
of
those
things
that
we
talked
about,
which
was
yeah
I
mean
I
personally
am
really
interested
in
this
it
we
we
are
gonna,
run
into
some
of
the
same
difficulties
that
we
have
with
globs,
but
you
know
I
would
be
willing
to
champion
this.
So
it's
something
that
I'm
more
I
guess
passionate
about
I
know
some.
Some
others
like
Ben
are
really
interested
in
this
sort
of
thing.
You
know,
and
others
have
you
know,
sent
pr's
and
have
documentation
and
would
like
to
go
over
it.
A
E
A
C
Well,
right
now,
we're
in
NYC
we're
using
I
think
it's
a
signal
exit
which
really
anytime
a
module
directly
says
this
module
does
evil
stuff
get
over.
It
doesn't
really
make
me
feel
great
and
I'd,
rather
that
no
js'
itself
have
the
evil
so
that
you
know
it
can
kind
of
be
in
control
of
you
know
start
to
finish.
I
worry
about
you
know
if
a
module
is
doing
stuff,
that's
kind
of
outside
the
norm
like
that,
then
I
worry
about
what
it
means
in
future
versions
of
nodejs.
C
C
A
So
I,
don't
think
I
mean
I
fully
understand
what
the
issue
it
looks
like
without
having
digging
into
these
issues
that
been
posted,
it
looks
like
you
can
so
I
know
that
there
are
events
that
process
fires
when
things
are
about
to
shut
down,
but
there
are
several
different
ones,
and
so
you're
saying
there
is
not
a
just
a
single
one
that
you
can
listen
to.
Is
that
right?
Did
you
just
drop?
C
A
F
It's
I
think
like
signal
exit
was
definitely
a
quiet
Tritton,
mostly
by
Isaac,
because
you
end
up
having
like
you
need
to
set
up
a
ton
of
different
signal
listeners
to
actually
detect
all
the
conceivable
ways
an
application
might
exit.
Then
you
run
into
issues
like
if
someone
has
a
like
a
little
is
a
listener
on
control,
see
you
can
actually
stop
prevent
the
application
from
exiting
so
I
end
up
in
these
edge
cases
where
you're
like
it
might
exit
it
might
not
exit.
F
A
A
F
And
I
think
that
a
person
to
talk
to
about
it
would
be
Joey
because
we
actually
note
itself
is
a
bunch
of
stuff,
always
when
it's
exiting
like
that's
how
the
coverage
work
works
and
it's
because
we're
able
to
actually
look
at
a
lower
level
and
say:
oh,
we
actually
are
exiting
now.
Let's
do
some
cleanup
stuff
and
by
the
time
we
see
that
in
like
C++
land
or
you
know
late
in
the
late
in
the
processes
life.
We
actually
know
whether
it's
really
good
accident.
B
This
is
something
I'm.
Definitely
a
hundred
percent
in
favor
of
this
I
think
it's
a
great
example
of
something
that
does
belong
in
node
core
again.
There's
these
third-party
libraries
that
are
Dec
sort
of
doing
weird
things
to
make
this
happen.
I
know
we're
using
async
exit
hook
currently,
but
that
also
it
has
some
issues
and
doesn't
always
work
perfectly
so
yeah
I
definitely
think
this
is
something
that
belongs
like
node
should
do
this
itself.
B
F
B
B
C
Agreed
and
as
far
as
bringing
it
into
the
core,
my
understanding
is
to
reliably
have
asynchronous
exit
handlers.
That's
something
that
would
need
to
happen
in
the
core,
because
essentially
you'd
need
to
from
what
I
can
tell
anyways.
You
would
need
to
do
some
C++
side,
manipulation
of
the
default
event
loop.
So
obviously,
that's
not
possible
from
a
JavaScript
module.
A
It
looks
like
robert's
jump.
I
think
that
Samer
over
its
jumped
in
and
you
can-
he
asked
for
a
bit
more
like
a
more
specific
info
about
what
his
wanted
would
be
helpful.
So
I
I
think
he's
another
one
that
if
we're
looking
for
for
guidance
on
on
implementation,
you'd
be
may
be
able
to
help
inhibition
enjoy
because
I
know
he.
He
knows
that
stuff
pretty
well.
So
there.
B
A
So
when
you
are
running
a
new
process-
and
you
send
this
again
so
essentially
so
your
ctrl
C
or
something
right
like
Python
when
you
do
that,
it'll
dump
a
stack
trace
now
personally,
like
whenever
Python
does
that
I'm
like
this
is
completely
useless
and
I
want
to
see
it
and
I
know
I
just
know
that
I'm
gonna
start
getting
bug
reports
when,
if
that
starts
to
happen
in
in
in
my
stuff,
from
people,
because
they're
gonna
see
that
and
be
like.
Oh
there's
gotta
be
something
wrong.
A
Why
am
I
getting
this
stack
trace
when
I
bored
of
the
process?
Okay,
so
I
know
that's
gonna
happen,
so
I
think
it's
useful,
especially
if,
like
your
program
stuck
or
something-
and
you
want
to
control
see,
why
is
it
stuck
get
a
start
race
super,
but
I
think
it
should
be
opt-in,
I,
think
that
should
be
behind
a
flag
and
other
people
do
too
and
so
I
don't
think
the
TSC
necessarily
thought
so.
F
A
B
F
The
argument
that
a
lot
of
the
time
this
tax
rates
will
actually
be
in
like
Libya
v
land
and
meaningless.
A
lot
of
weight
to
like
I
mean
I'd,
be
maybe
more
in
support,
if
hasn't
even
get
a
lovely
stack
trace
of
JavaScript
frequently,
but
most
of
the
most
of
the
sleep
time
is
gonna,
be
like
waiting
on
IO
or
something
right.
It's
a
not
least,
a
portion
of
the
time.
A
A
B
A
B
I
think
I
mean
we
were
maybe
just
addressing
whether
we
support
the
idea
of
doing
that
or
we've
got
something
we
want
to
take
on
I
think
so
I.
Certainly
it's
something
I
would
certainly
be
interested
in
having
in
node
and
I
would
maybe
be
willing
to
do
some
work
on
that.
Like
I
said
it's
a
it's
definitely
an
issue
for
some
of
the
projects
I'm
working
on
now.
A
B
C
So
one
question
that
I'd
like
to
ask
to
the
room:
what
do
we
think
should
be
the
behavior
for
essentially,
if
somebody
runs
processed
exit
and
we
want
to
use
an
async
handler
what
should
happen
to
events
that
may
have
been
left
over
from
before
of
the
process
exit?
If
we
have
an
asynchronous
handle,
or
should
those
just
be
thrown
away
and
forgotten,
or
should
they
continue
to
be
processed?
Is
that
I
think
was
one
of
Sam's
questions
on
github,
I
kind
of
personally
lean
towards?
C
If
an
application
does
process
not
exit,
then
I
would
lean
towards
saying
we
want
to
throw
out
any
events
that
were
left
over,
because
the
application
consciously
chose
that
those
are
no
longer
relevant
and
probably
shouldn't
be
processed,
but
not
being
able
to
do.
Async
means
that
there's
a
whole
chain
of
things
in
NYC,
for
example,
that
have
to
be
synchronous,
otherwise,
we'd
have
to
write
two
copies
of
all
the
code.
C
A
C
A
A
What
types
of
applications
would
want
this
behavior
I
mean
if
we're
talking
about
CLI
apps
and
you
may
have
a
different
opinion,
but
it
it.
It
seems
to
me
that
we
can
more
safely
get
away
with
writing
synchronous
code,
but
I
guess
I'm
trying
to
understand
okay,
so
we
have
to
write
synchronous
code
in
NYC's
exit
handler
okay.
So
we
that's
what
we
have
to
do
right
now,
but
why
do
we
need
to
write
asynchronous
code?
Is
it
just
because
well.
C
A
A
F
Right,
I
guess
my
only
question
is:
could
we
move
the
like
kind
of
split
apart
the
machinery
bits
and
the
reporting
bit
so
that
the
reporting
season
isn't
happens
externally
and
then
the
like
rating
to
disk
is
all
super
nice
I,
like
I,
think
there
are
workarounds
where
we
could
potentially
really
isolate
the
bits
that
are
synchronous,
I
think
we
could
probably
move
source
maps
into
a
different
layer,
but
it
does
create.
You
know:
Chris
I
need
to
refactor
the
whole
code
base.
F
A
C
C
C
Essentially
is
like
exiting
the
process,
but
you
can
actually
have
a
non
closed
handler
that
essentially
opens
a
new
hidden
window
and
pulse
the
application
open
until
you're
done
doing
what
you
need
to
do
at
the
end.
I
know
for
CLI
apps.
One
of
the
things
that
was
mentioned
was
resetting.
The
terminal
I
know
that
doesn't
require
async
I
think
the
async
functionality
would
be
more
useful
for
testing
type
of
stuff.
C
A
A
C
And
another
thing:
as
far
as
this
option
goes,
I
mean
I
can't
speak
for
other
systems,
which
you
know
would
use
the
exit
Handler,
but
for
like
fren
YC,
for
example,
I.
Don't
think
it
would
be
an
issue
if
the
async
functionality
were
essentially
like
behind
a
flag.
You
know,
because
essentially
we
could
inject
a
you
know
enable
async
exit
which
I
can
see
I'm,
not
really
sure
I
can
think
of
a
real
use
case
for
production
applications
to
need
async
exit,
but
I
can
definitely
see
it
being
useful
for
testing.
So
I'm
not
sure.
A
A
A
E
A
So
a
working
group
has
a
charter
and
I'm
not
sure
exactly
what
that
means,
but
instead
of
like
what
we
are,
is
we've
we're
kind
of
established
as
a
an
advisory
type
of
group.
A
working
group
would
have
like
more
clearly
defined
boundaries
and
have
like
more
decision-making
responsibilities
as
far
as
I
understand,
assuming
that's
in
the
Charter
I
mean
doesn't
have
to
be.
That
way,
but,
like
the
security
working
group,
for
example,
can
make
security
related
decisions
and
the
TSC
to
first
their
judgment
on
these
on
those
things
generally.
A
So
because
our
our
scope
is
rather
broad
and
like
what
what
is
to
Lee
entail.
Or
you
know
what
subsystems
do
we
care
about
it's
you
know,
there's
lots
of
different
things
that
can
touch
tooling
I.
Don't
think
that
sort
of
Charter
would
make
a
whole
lot
of
sense
for
us,
because
you
know
like
where
doors
responsibilities
end.
But
yes,
so
it's
not
like
an
official
working
group.
I,
don't
know
if
it
needs
to
be
I,
don't
know
if
that
would
offer
really
any
advantage,
if
there's
something
that.
D
A
As
it
stands,
you
know
they
already.
You
know
the
collaborators
already
CC,
you
know
no
just
tooling
and
say
well,
you
know
this
particular
thing
is
going
to
impact
tooling.
So
maybe
we
should
ask
them,
and
so
we
do
get
CC
and
we
do
get
asked
and-
and
our
opinion
seems
to
matter-
and
so
that's
fine
so
I
mean.
Does
anybody
else?
Have
a
different
interpretation,
yeah.