►
From YouTube: Node.js Tooling Group Meeting
Description
A
A
B
A
A
Alright,
so
yes,
I
put
in
for
to
have
a
meeting
there.
So
if
anybody
who
wants
to
show
up
I
think
so
robust
will
be
there,
you
know
when
we
did
last
time.
There
are
actually
a
lot
of
people
that
showed
up
and
I
was
kind
of
like
wow
a
lot
of
people
here.
So
maybe
we
should
kind
of
expect
a
lot
of
people
and
then
you
know
decide
on
that
agenda
closer
to
the
date
of
course,
but
you
know
with
that
in
mind
that
you
know.
A
Maybe
we
can
only
cover
one
or
two
topics,
and
you
know
maybe
we
want
to
get
a
do
something
like
it.
I
get
a
wider
range
of
opinions
on
a
particular
topic
or
you
know
essentially
pull
the
crowd
and
say:
okay,
like
what's
the
thing
that
you
want
to
see
you
that
you
don't
have
do
you
have
any
like
you
know,
burning
needs,
maybe
just
that
sort
of
thing
would
be
a
would
be
a
good
way
to
go.
What
do
you
think,
then?
You
were
there
last
time,
I.
C
A
C
A
A
So
I
want
to
jump
ahead
to
source
maps,
so
it
looked
to
me
like
source
maps,
did
your
PR
get
merged.
C
The
unexcited
PR
got
merged,
which,
which
kind
of
added
the
backends
the
backend
machinery
to
pull
it
off,
but
we're
like
minutes
away
from
landing
the
one
that
actually
adds
source
map
support
to
stack
traces
which
I'm
really
excited.
So
they
realize
there
were
two
different
ones,
one
kind
of
exposed
it
for
test
coverage
and
was
a
way
to
split,
and
it
was
kind
of
a
way
to
just
split
the
work
in
the
two
parts
because
it
was
actually
quite
a
bit
of
work.
C
The
meteor
PR
is
I'm
sharing
it
in
chat
now
yeah,
so
I
have
all
the
approvals.
I
just
need
to
get
tests
passing
and
nodes
testsuite.
It
just
needs
to
be
run
three
or
four
times,
sometimes
because
I
don't
think
I've
broken
anything
in
the
test.
Suite
I
think
it's
just
a
little
flaky
this
morning.
So,
but
what
this
does
this?
To
tell
you
what
it
does?
It
basically
will
listen
for
source
maps
inside
of
code
when
at
the
time
when
a
module
is
loaded
either
ESM
or
commonjs.
C
If
it
sees
the
source
map,
it
places
it
in
a
cache
and
then,
if
a
stack,
if
a
unhandled
exception
occurs
or
if
you
try
to
print
the
stack
trace,
it
walks
over
the
stack
and
looks
for
transpiled
code
and
gives
you
both
the
transpiled
code
and
the
non
transpiled
code
so
that
you
have
the
original
call
site
and
the
transpiled
call
site
in
the
exception
stock
trace.
So
is.
C
Opt
in
so
you'll
go
enable
source,
Maps
and
then
you'll
and
then
you'll
get
stack
traces
that
capture
and
and
provide
a
more
detailed
stack
trace.
If
a
source
map
is
found
for
things
like
mocha
that
already
do
some
of
their
some
source
map
management,
it
might
mean
that
they
want
to
think
about
whether
they
could
leverage
that
or
if
we
could
integrate
more.
You
know
you
know
you
might
not
want
to
run
mocha
with
enable
source
maps
on,
because
I
think
mocha
does
all
its
own
source
map
handling.
It.
A
C
But
it
is
opt-in,
so
someone
would
have
to
some
would
have
to
be
kind
of
bringing
coming
into
it,
and
the
idea
was
that
we
could
expose
an
API
for
it,
so
that,
if
you
do
want
to
monkey
with
the
stack
well,
actually
it
wouldn't
affect
monkeying
of
the
stack
because
I
I,
don't
we
can
just
we
can
talk
about
that.
There's
ways
we
can
make
it
less
less
invasive
or
more
invasive
and
the
approach
we
want
to
take
well.
A
D
A
If
that
sort
of
thing
I
mean
it
would
potentially
affect
I
mean,
so
what
is
what
does
code
look
like
if
you
have
source
map
enable
source
Maps
on,
but
the
code
in
the
stack
is
not
mapped,
it
just
looks
like
a
regular
stack
trace
and,
and
once
you
reach
code,
that
is,
then
you
see
this
extra
info
right.
Yeah.
C
You
see
a
little
bit
of
X,
you
see
both
the
original
cause
call
site
and
the
it
kinda
looks
ugly
in
chat,
but
you
can
kind
of
see
it.
There
cool
the
idea
that
you
don't
necessarily
want
to
see
the
transpiled
exception
to
call
site,
because
maybe
your
transpiler
made
broken
code.
So
it's
kind
of
nice
to
have
the
best
of
both
worlds.
I
think
he
is
what
was
recommended
to
me
by
yang
cooler
to
you
that
that
actually
looks
really
awesome.
Yeah
yeah
I'm
excited
right,
it's
like
simple,
but
it's
powerful
right.
C
E
C
A
Break
people
I,
don't
know,
I
I
feel
like
there
are
tools
or
just
aren't,
aren't
elite
enough
and
they
need
to
be
more
elite
and
I
want
to
do
something
about
that.
But
I
haven't
figured
out
how,
yet
anyway,
that's
a
topic
for
another
time,
so
cool
so
yeah
looks
like
this
is
on
its
way,
and
then
you
know
I,
imagine
it'll,
probably
land
and
one
of
the
next
miners
I'm
gonna
try
to
land
it
today.
C
If
I
can
get
the
test
suite
passing
because
it
has
enough
thumbs,
ups
that
been
reviewed
and
times
and
then
yeah
I
would
love
feedback
from
like
folks
like
well
I
think
fewer
much
people
playing
play
with
it
they'll
actually
have
more
feedback.
So
it's
one
of
those
things
where
we
can
fix
it.
After
the
fact
that's
behind
a
flag,
but
you
know
we
might
want
to
expose
more
hooks
so
that
Moka
could
use
this
to
Matt.
Mauck
luck
with
the
stack
trace
or
how.
C
Not
the
cache
isn't
javascript
land
in
a
in
a
map,
and
I
pull
I
ported
v8
source
map
handler
which
this
one
is
written
in
javascript.
It's
what's
used
when
you
open
inspector
and
look
at
source
maps
and
it's
much
much
smaller
than
the
community
library
and
it's
already
in
the
node
code
base,
because
it's
because
no
uses
v8,
so
it
seemed
like
a
good
choice.
C
So
there's
a
javascript
file
called
source
map,
which
is
the
v8
source
map
handling
which
can
given
the
original
position
can
give
you
the
map
position
and
vice
versa,
there's
a
cache
which
is
in
javascript
and
then
we
override
prepare
stack
trace,
which
is
a
which
gets
called
by
v8
when
the
stack
trace
is
ever
accessed
on
an
air
object.
We
actually
already
overrode
this
in
node.js
for
other
reasons,
because
we
do
some
mucking
around
with
the
stack
trace
already.
C
So
we
were
able
to
just
kind
of
piggyback
off
of
prepare
stack
trace,
which
can
then
iterate
over
each
line
of
the
stack
trace
and
do
something
similar
to
what
mocha
was
doing.
Essentially,
so
you
could
imagine
that
we
get
more
creative
and
find
a
way
to
let
someone
still
hook
in
maybe
yeah
yeah
I,
don't
haven't
thought
of
the
API
completely.
C
A
C
I
think
there's
a
few
cool
things
like
that.
Like
diagnostic
reports,
it's
not
set
up
yet
to
handle.
You
know
how
you
like,
when
you
get
an
exception
and
in
node
it
puts
a
little
ASCII
arrow
below
the
part
of
the
source
code.
That
had
the
exception
call
cite
happen.
You
know
what
I'm
talking
about,
but
like
it,
no
just
kind
of
injects
that
into
the
air
and
that
doesn't
have
source
maps
applied
to
it
right
now,
source
maps
don't
yet
work
with
when
you
have
the
repple
open.
C
If
you
were
to
require
something
with
the
source
map
that
then
through.
That's
a
super,
easy
fix,
I
just
left
it
is
it
to
do
and
like
that
would
be
a
great
thing
for
a
mentee
or
something
something
to
do
like
it's.
It's
really
like
that's
a
few
hundred
lines
of
code
or
actually
a
few
dozen
lines
of
code,
probably
to
make
it
work
for
a
repple.
C
D
C
None
of
the
code
is
that
I,
don't
know.
Yeah
I
wasn't
planning
on
backporting
it
like
I,
think
it's
a
I
think
it's
one
of
those
things
were
plugging
iterate
on
it
for
a
few
months,
so
I
think
we'd
end
up
back
porting
the
initial
work
and
then
be
having
a
back
port
every
iteration,
as
we
figure
out
a
better
API
for
it.
Since
it's
experimental
right.
D
C
E
C
On,
if
we're
already
using
prepare
stack,
trace
and
no
10
and
I
think
we
are
okay,
most
of
most
everything's
done.
There's
this
this
method,
there's
this
hook
that
v8
itself
exposes
for
mocking
off
the
stack
trace
that
node
overrides
and
then
becomes
a
really
good
entry
point
for
fiddling
with
the
stack,
which
I
think
is
what
a
lot
of
user
land
modules
do
as
well,
because
they
can
monkey
patch
it.
C
Assuming
that
the
prepare
stack
traces
intend
which
I
believe
it
is
then
yeah.
It
shouldn't
be
too
hard
to
backboard
this.
So
if
someone
suggested
I
use
private
fields
for
one
of
the
classes
I
made
so
I'd
have
to
change
this
back.
To
not
being
private
fields
did
private
fields,
land
intend
1/5
explaining
the
load
will
be
true.
Yeah
I
know
it's
file
feature.
Ok,
so
you'd
have
to
get
rid
of
the
private
fields.
E
Yeah
I
think
that
it
would
be
nice
to
eventually
be
able
to
run
async
code
in
an
exit
Handler,
but
as
of
now,
I'm,
not
sure
the
best
way
to
accomplish
that.
So
I
think
I
need
to
comment
on
the
issue
again,
but
I
think
that
just
trying
to
have
no
js'
provide
a
standard
way
to
install
an
exit
Handler
that,
as
far
as
the
application
is
concerned,
won't
interfere
with
things
like
the
SIGINT
Handler
and
other
signal
handlers
would
be
really
great.
E
Well,
no,
that
that
was
an
idea
for
how
nodejs
could
theoretically
provide
a
safe
async
functionality
for
the
exit
handlers.
The
problem
is
once
the
exit
handler
starts.
Theoretically,
if
there's
still
stuff
on
the
event
loop,
you
don't
really
want
to
process
that.
But
if
you
start
running
async
code
in
a
new
event
loop,
you
don't
want
that
async
code
to
wait
on
something
that
will
never
resolve
from
when
the
application
was
running.
E
So
that's
where
the
idea
of
the
worker
thread
came
from
is
that
essentially,
a
worker
thread
kind
of
runs
in
in
in
isolation
but,
like
I
said
for
as
far
as
NYC
goes
basically
I
just
found
a
way
for
the
child
processes
to
simply
do
less
work
and.
C
Was
gonna
say
it's
like
I'm,
definitely
more
excited
about
I'm
concerned
with
with
the
complexity
of
an
async
exit
Handler
as
well,
and
I'm
more
excited
personally
about
just
having
a
exit
handler
that
fires
all
courses
where
nodes
about
to
shut
down,
and
it
really
feels
like
I.
Don't
you
know
maybe
the
Devils
in
the
details,
but
it
feels
like
we're
already
pretty
much
there,
because
we
write
like
diagnostic
reports
when
no
just
down
like
process
information,
we
write
source
Maps
when
node
shuts
down
and
we
do
this
in
all
exit
scenarios.
C
So
really
I
think
if
we
just
added
an
additional
javascript
hook
that
can
execute
if
it's,
if
it's
wired
in
and
it
executes
at
that
exact
exact
same
time
when
we'd
be
outputting,
either
coverage
or
other
inspector
information.
As
the
inspector
session
shuts
down,
we
could
just
call
that
hook
pretty
safely
so
and
I
mean
if
it's
opted
into.
C
E
Agreed
and
there's
only
so
much
that
can
be
done
to
prevent
the
exit
handle,
are
from
blocking
exit
and
I
mean,
for
example,
right
now
we
could
use
signal
exit
to
call
a
child
process.
You
know
exact
sync
and
run
a
process
that
never
exits,
so
it's
already
possible
to
block
the
exit
permanently
so
I,
don't
that's
something
that
can
really
be
addressed.
C
My
question
becomes:
should
this
be
the
behavior
of
on
exit
right,
like
maybe
that's,
but
it
feels
a
little
weird
introducing
a
new
method.
That's
like
on
always
exit
or
something
I,
don't
know
what
it
would
be
called,
but
but
it
feels
like
this
is
I
think
as
a
user.
This
would
have
been
my
expectation
of
how
exit
behaves
like
that.
A
fatal
signal
would
cause
me
to
get
that
hook
as
well,
and
I
was
a
little
surprised
that
we
needed
to
build
that
signal.
C
Exit
library
which
I
built
actually
and
I
did
not
know
a
thing
about
signals
and
was
just
trying
to
solve
a
problem.
So
I'd
like
then
had
to
learn
about
signals
and
was
surprised
that
there
wasn't
already
a
signal
handling
library.
That
already
did
this,
and
you
know
it
was
not
that
I
knew
much
about
unix
and
wanted
to
build
this
thing.
B
B
Arrghh,
right
and
I
think
it
does
move
the
conversation
forward,
but
it's
not
necessarily
the
full
argument
person
that
we
want
I
wanted
to
do
that.
I
wanted
to
hear
the
sentiment
from
the
group
on
that
idea
of
just
like
having
something
better
than
the
narvaez
lies,
but
it's
not
necessarily
an
argument
person
liar
yet.
A
B
A
C
Even
go
a
step
further
and
I
mean
you
already
have
frontways
that
process
dot
exactly
already
know
the
bin
that
was
actually
used
to
run
whatever
code.
You
were
running
that
like
could
we
split
out
the
the
actual
been
running,
the
thing
it
ran
and
then
all
the
arguments
passed
to
it,
you
know
like
how
they
just
look
just
split:
remove
all
need
for
slicing,
essentially
I,
think
yeah.
B
A
Mean
I'd,
certainly
back
it
I
mean
you
know
anything
that
moves
the
needle
is
seems-seems
good,
good
good
to
me,
and
you
know,
if
you're
looking
to
get
more
code-
and
you
note
I,
think
it's.
You
know
probably
something
very
straight
forward,
and
you
know
that
you
could
that
you
could
send
over
some
thing.
C
To
do
it
as
have
it
return,
an
object
that
has
the
you
know
like
the
main
args
which
are
in
an
array
and
then
the
bin
that
was
that
was
the
original
exact
bin
and
maybe
like.
If
there
was
I,
would
maybe
you
could
even
split
it
up
one
step
further
and
have
the
targ's
the
non
togs
and
then
the
bin?
Maybe
that's
getting
too
complicated.
Now
I've
read
enough.
B
C
Wouldn't
go
for
the
minimal
thing
I
was
gonna,
say
is,
if
you
made
in
an
object,
though,
then
you
could
imagine
expand
seating,
that
into
a
natural
parser
that
works
more
like
minimis,
but
you've
got
like
the
baby
step.
That's
not
a
parser
like
minimus,
but
the
return
type
wouldn't
have
to
change
significantly.
So
that's
just
my
thinking
and
we
don't
start
dumping
a
ton
of
things
on
to
process.
I
guess
one
of
my
concerns,
like
maybe
do
it
as
an
API.
Instead
of
as
something
on
process
like
I've,
been
the
extended
into
an
argument.
A
E
A
C
A
E
That
was
actually
somewhat
of
my
suggestion
for
the
glob
path.
Matching
was
that
essentially
start
from
building
out
a
spec,
and
you
know
building
out
like
tests
to
prove
a
spec
and
identifying
the
edge
cases
where
the
current
user
land
modules
don't
match
up
and
seeing
if
we
can
nudge
them
closer
anyways.
C
Just
wanted
to
mention
that
I
think
it's
gonna
be
a
good
strategy,
because,
because
what
I've
definitely
seen
is
when
there
is
some
contention
and
what's
popular
like
like
there's,
there's
a
bunch
of
argument,
parsers,
probably
five,
really
popular
ones
and
there's
you
know
two
or
three
globbing
libraries
folks
will
say
well,
there's
you
know
we
haven't
actually
agreed,
there's
some
significant
differences,
but
the
differences
are
usually
less
significant
than
you
think.
I
believe,
like
I,
think
like
minima
stand,
yards
are
the
exact
same
parser
and
I.
C
A
Has
there
been
like
a
precedents
for
this
sort
of
strategy,
because
my
worry
is
just
like
it?
That's
the
it's
a
long
game
right,
it's
a
lot
of
work
and
there's
absolutely.
You
know,
of
course,
there's
no
guarantee
that'll
it
pay
off
and
I
mean.
If
there's
a
precedent.
I
would
definitely
feel
better
about.
C
C
Right
conventional
commits,
which
I
wrote
up
the
specification
for
is
definitely
I,
think
having
the
specification
has
helped
increase
the
popularity
of
that
methodology
because,
because
I
like
started
by
writing
a
spec
for
it,
so
I
thought
and
what's
the
other
example
I
mean
it
definitely
helped
getting
coverage
in
denote,
Jess
that
in
v8
supported
it,
because
you
can
point
to
v8
and
say:
look
the
eights
standardize.
This
they've
made
it
part
of
their
platform.
C
C
It's
an
interesting
challenge
for
this
particular
thing
too,
because
essentially,
the
the
test
suite
program
for
each
library
is
entirely
separate
because
they
have
very
different
api's.
So
it
becomes
like
a
my
aware
of
what
features
it
has
as
much
as
anything,
but
they,
you
know
that
gives
you
an
opportunity
to
invite
the
authors
to
join
the
test,
suite
I
suppose,
but
like
I'm,
not
sure
how
different
that
is
from
just
going.
C
C
C
And
it's
that
Oh
in
his
his
long
list
of
things
that
you
need
to
define,
he
basically
made
a
list
of
like
here's.
All
the
weird
features
that
argument
parsing
has
and
one
of
them
was
okay.
Would
you
do
if
you
only
get
a
single
in
front
of
a
long
argument?
What,
if
you
get
three
dashes
in
front
of
a
long
argument,
most
of
the
node
parsers
treat
all
of
those
as
just
a
single.
You
know
the
same.
Those
are
treated
the
same.
It
just
goes
yeah
strip.
A
C
I
mean
he
was
just
saying
like
that,
that's
a
question
that
any
parser
has
to
like
answer
right.
You
have
to
choose
one
of
those.
You
have
to
choose
something
to
do
with
that.
Now.
The
idea
of
like
I
think
it.
You
know
this.
This
is
but
this
is
where,
like
I'm,
not
sure
that
having
a
a
test
suite
helps
but
I
think
having
a
document.
We
can
point
to.
That's,
like
you
know:
here's
99%
of
the
parser
downloads.
C
E
E
C
To
work
they're
like
oh
and
if
it
doesn't
they're,
also
okay
with
that
yeah
and
there's
a
few
cases
like
like
people,
rarely
do
like
the
single
and
then
ten
sick,
you've
all
in
the
node
community
people
rarely
do
that
I.
Think
that's
more
common
in
some
UNIX,
tooling,
yeah,
BSD,
tooling,
is
very
fond
of
that.
I
think
because
we
standardized
around
things
like
minima,
stand,
commander,
etc
and
nodes
we've
kind
of
driven
behavior
too,
because
all
the
command
lines
work.
Similarly,
I.
E
E
E
C
C
E
C
C
Well,
I,
like
the
idea
of
just
building
on
what
you
know:
I,
don't
I
like
the
idea
of
the
super
minimal
thing,
especially
if
it
was
something
we
kids
extend
on
I
like
the
idea
of
too
maybe
taking
what
Chris
did
and
turning
it
into
a
rubric.
Maybe
because
people
like
rubrics
and
then
you
can
just
like
browser
compatibility,
C
or
command
line
compatibility
and
make
an
argument
for
some
set
of
features.
I
think
that
could
be
compelling
I.
A
C
Don't
know
if
they
see
I
presented,
you
idea
tc39
this
week
and
we
got
the
stage
one.
So
it's
we're
officially
actually
thinking
about
it,
which
is
stage.
One
basically
means
we're
we're
you
know
we're
just
starting
to
flesh
out
the
API
surface,
a
little
bit
more
and
but
people
were
quite
excited
about
it.
C
One
company
was
talking
about
the
fact
that
you
know
they
use
it
for
tons
of
their
infrastructure
and
it
would
be
really
useful
for
them
to
have
it
available.
Another
company
was
saying
that
I,
don't
know
there
was
way
more
more
consensus
than
I
would
have
thought
that
it
would
be
that
it's
a
pretty
good
idea.
C
Maybe
the
most
interesting
thing
to
come
out
of
it
was
I'm.
Gonna
now
be
updating.
The
proposal
to
I'm
gonna
be
updating
the
proposal
to
actually
talk
about
standardizing,
randomness
and
JavaScript,
so
we
don't
actually
have
a
secure
random
source.
In
the
JavaScript
platform
we
have
like
secure
Crandon
bytes
in
the
Bret,
some
of
the
browsers.
We
have
secure
random
bytes
in
nodejs,
but
we
don't
have
been
officially
standardized
randoms
random
way
to
create
a
natural
random
number.
C
That's
cryptographically
secure,
which
means
that
actually
it's
hard
to
make
a
UID
at
the
language
level
consistently,
because
you
guy
DS,
rely
on
randomness.
So
it
brings
up
an
interesting
problem
that
it
would
be
really
nice
for
the
language
and,
for
you
know
all
too
willing
to
have
a
standard
way.
You
get
randomness
and
then
you
can
build
a
lot
of
things
on
top
of
that
randomness.
So
I
thought
that
was
an
interesting
thing
that
came
out
of
the
conversation.
A
What
I
understand
and
I
know
next
to
nothing
about
cryptography,
but
randomness
is
very
difficult
to
pull
off,
especially
when
you're
working
with
things
like
containers
and
virtual
machines,
and
so
I,
don't
know
whatever
comes
out
of
here.
I
think
there's
probably
wants
to
be
some
sort
of
limit
on.
C
Interesting
conversation
like
I'm,
basically
gonna,
have
to
find
someone
smarter
than
me
and
in
cryptography
to
start
talking
to
you
about
it.
So
it's
gonna
be
a
big
project.
You
would
be
amazing,
like
chrome,
does
have
a
node
has
a
cryptographic.
Api
people
rely
on,
Chrome
has
chrome
as
a
cryptographic.
Api
people
rely
on
people
are
running
node
in
containers
and
using
that
code
to
graph
the
API.
So
it's
it's
a
good.
It's
a
you
know
it's
a
good
thing
to
think
about
and
like
if
we
did
standardize
it.
C
A
C
Ritt
one
really
super
fascinating
thing,
too,
is
that
if
you
use
math
dot
random,
which
is
kind
of
the
naive
implementation,
and
then
you
try
to
make
a
UID
out
of
it,
you'll
actually
get
collisions
every
I,
think
64
thousand
items
or
something
like
you,
math,
not
random,
is
not
at
all
random.
It's
very,
not
random.
So.
E
C
With
the
system
you're
not
able
to
what
you're,
not
you
know,
Spector
is
always
concerned
in
any
of
the
eight
new
API
is
they
get
created?
So
it's
always
like.
Can
we
do
this
without
providing
a
place
where
you
can
observe
system
State
in
such
a
way
that
it's
actually
creating
ran
resume
the
answers?
It's
impossible,
No.
E
C
A
B
C
A
C
Yeah
I'm,
assuming
there's,
got
me
super
curious
about
how
Chrome's
doing
it
today
because
they
do
have
the
random
bytes
implementation
in
Chrome,
then
wonder
what
Jackets
getting
behind-the-scenes
sounds
kind
of
like
grain,
entrapment
I
mean
it's
probably
doing
what
open
SSL
does,
which
is
what
I
described
at
to
the
best
of
my
knowledge.
Well,
the
last
time
I
looked
into
it.
That
was
how
it
worked.
Of
course,
there
are
all
of
those
open,
SSL
fixes
where
math
dot
random
really
went
wrong.
Is
it's
only
a
52
bit
value?
E
A
E
C
A
E
D
A
C
C
A
Of
modules,
I
think
an
API
and
yeah
yeah
C++,
so
yeah,
okay,
yeah
cool
anything
else.
Thanks
for
running
the
meeting,
yeah
such
as
it
is,
okay
thanks,
everyone
all
right!
Thank
you.
Oh
one,
more
thing:
Ben!
Please
bug
this
somebody.
If,
if
you
need
any
more
information
about
who
you
should
bug
to
get
access
to
run
this
meeting,
if
I
can't
be
here,
okay,
yeah,
yeah,.
C
C
Take
care,
Roy,
feel
free
to
loot
me
and
on
the
command
line
stuff
too,
like
no
spare
time
but
I
think
it's
a
good
idea,
so
sure
yeah,
oh
definitely
what
long
as
you're
doing
all
the
work.
All
this
chime
in
with
no
context
I
know
it's
very
useful.