►
Description
The Ins-and-Outs of Publishing a Module to npm by Steve Kinney
A
Hello,
so
my
name
is
Steve
Kinney
and
I.
Am
the
director
of
the
front-end
engineering
program
at
the
Turing
school
of
software
and
design
out
in
Denver?
Colorado
turn
is
one
of
those
developer
training
programs,
but
a
little
bit
different
cuz,
it's
a
7-month
developer,
training
program
and
a
non-profit
and
we're
always
looking
for
people
who
want
to
be
our
friends
and
hang
out
with
us.
A
Laurie
was
out
visiting
us
last
Friday
and
that
was
super
cool
and
if
anyone
else
wants
to
come
and
talk
to
our
amazing
students
or
work
with
us
for
a
little
bit
or
spend
a
week
with
us,
we
got
a
bunch
of
alumni
in
the
room,
some
other
instructors.
So
please
come
find
any
of
us
and
talk
to
us
because
we
really
like
to
meet
amazing
humans.
I
also
have
stickers.
A
That'll
make
the
whole
like
social
interaction,
less
awkward,
they'll
be
really
great,
I
mean
say:
hey
can
I
have
a
sticker
and
I
will
give
you
a
sticker.
I
actually
also
have
a
few
dinosaur
J's
stickers
because
they
were
in
my
bag.
So
I
can
also
give
you
those
as
well
they're
the
black
ones,
not
the
cool
blue
ones,
but
they're
cool
and
I
can
give
you
those
as
well
I'm.
A
Also
working
a
book
called
electron
in
action
and
I
also
have
like
codes
for
like
for
free
copies
of
that
that
I
scrolled
on
business
cards
that
you
can
get
from
me
later
as
well.
So
there's
a
lot
of
like
topics
of
conversation
before
I,
eventually
convinced
you
to
come
out
to
Denver
and
hang
out
with
us
and
so
turns
important
part
of
this
talk,
one
of
the
things
about
being
a
7
month,
program,
I,
suppose
like
a
12
week
or
whatever
is
towards
months
like
6
and
7.
A
You
have
a
lot
of
like
time
to
get
really
weird
with
things
right
like
you've
made
a
form
and
you
submitted
stuff,
you
made
a
shopping,
cart,
you've
done,
you've
done
the
web
development
thing
right
and
and
what
happens
is
towards
iam.
We
have
to
really
start
like
reaching
to
keep
you
occupied
and
convince
you.
A
This
is
still
a
good
idea,
so
we're
the
project
we
did
in
the
kind
of
the
final
weeks
of
Farion
is
to
have
our
students
build
an
application,
a
build,
an
electron
application
that
used
ember
on
the
front
end
right,
and
this
is
an
example
of
one
of
them.
It's
a
little
notes
application.
You
write
in
some
marked
and
you
get
like
the
pretty
HTML
format.
You
can
just
log
into
github
and
publish
it
to
a
gist.
It
writes
to
the
file
system,
so
it
works
totally
offline.
It's
really
cool.
A
The
problem
is
that
there's
a
few
moving
parts
like
no
generally
likes
callbacks
amber
likes
promises
so
on
and
so
forth.
Right.
A
lot
of
the
kind
of
node
file
system,
API
is,
will
go
ahead
and,
like
you
know,
get
you
the
list
of
all
the
names
of
files,
but
you
also
want
what
the
contents
of
the
files,
so
the
main
learning
goal
here
was
to
gonna,
get
comfortable,
amber
and
get
comfortable
electron,
not
like
also
like
kind
of
deal
with
the
impedance
mismatch
of
like
callback,
driven
like
a
few
guys
vs.
promise
ones.
A
So
the
morning
before,
I
made
a
little
npm
module
that
basically
only
did
part
of
the
job
right
it.
Basically
it
had
a
promise
kind
of
api,
but
it
did
the
callbacks
under
the
hood
and
all
the
did
was
read
files
and
lists
all
the
files
in
a
directory,
and
it
would
filter
out,
like
your
DS
stores,
your
dot,
vin,
undo,
files
and
stuff
like
that.
A
So
you
can
get
a
file
extension
and
just
a
few
things,
but
it
didn't
do
everything
so
part
of
the
project
with
students,
but
also
to
like
implement
all
of
the
other
features
right,
implement
the
ability
to
remove
files
to
update
files.
All
sorts
of
things
like
that
so
I
kind
of
just
did
the
bare
bones
and
handed
it
to
them
and
kind
of
opened
up
a
bunch
of
issues
and
assigned
it,
and
a
really
weird
I
got
a
really
weird
reaction.
A
But
this
totally
caught
me
off
guard
I'm,
like
you,
don't
need
permission
to
publish
one
as
I
started,
to
think
about
it
more
and
more
so
we
kind
of
like
scrapped
the
schedule
for
the
next
day
and
we're
like
all
right,
we're
all
gonna,
publish
a
module
to
NPM
together
and
individually
and
like
this
is
a
thing
that
you
can
do
right,
because
part
of
my
job
is
to
build
people
who
can
I
go
get
jobs
as
developers.
The
other
part
my
job
is
to
build
really
amazing
humans
that
can
be
part
of
the
community.
A
Be
citizens
of
the
open-source
community
be
participants
in
it.
I
started
thinking
about
this
1%
rule
right
and
the
idea
is
that,
like
of
any
giving
online
community,
1%
of
all
people
like
actually
contribute
and
99%
of
people
just
kind
of
like
lurk
right
and
sometimes
there's
like
1%,
contribute
9%,
like
kind
of
a
1%
create
9%
kind
of
like
edit
Wikipedia
articles.
I
think
one
time
there
was
like
they
spelled
York
Street
wrong
in
a
in
a
Wikipedia
article
about
New,
York,
City
and
I
fixed
that
that's
my
contribution
to
Wikipedia.
A
But
generally
speaking,
or
they
called
it,
F
new,
a
I,
don't
remember
because
it's
not
it's
before
first
Avenue,
but
it's
not
Avenue
way
so
with
I
asked
Laurie
for
some
numbers
right
and
what
we
find
out
is
that
NPM
has
about
250
thousand
registered
users
right,
but
you
don't
need
to
be
logged
in
to
NPM
in
order
to
like
download
a
module
right.
So
how
many
people
really
use
it?
A
large
guess
is
about
4.5
million
people
right.
That's
a
lot
of
humans!
A
Oh
that
84,000
actually,
like
you
know
contributing
published
and
modular
registry,
and
that
comes
in
at
you
guessed
it
around
1%.
So
only
1%
of
people
have
actually
published
to
the
registry,
and
my
goal
today
is:
if
you've
never
published
a
module
to
the
NPM
registry
to
show
you,
it
is
totally
a
thing
that
you
can
do
and
totally
I
think
that
you
should
do
and
if
you
have,
if
you're
you
know,
one
of
the
kind
of
stuff
sort
of
people
can
use
an
NPM
before
is
included
in
node.
A
Then,
like,
hopefully,
there's
a
few
tricks
that
you
can
pick
up
to
make
life
easier,
because
one
thing
I
realize
is
that
almost
anything
that
might
cause
you
some
friction
there's
actually
like
some
kind
of
NPM
setting
or
I'm
NPM
command.
That
gets
you
around
it
cool,
so
we're
gonna
make
a
little
module
today
for
working
with
rectangles
right,
because
this
is
this
is
a
talk
about
publishing.
If
you
have
is
not
a
talk
about
watch
me
live
code,
a
module
in
25
minutes
cool.
A
So
we
have
a
few
options
right.
We
have
to
come
up
with
a
new
name
option:
one
is
we
can
have
a
Scopes
module?
I
can
say
that
it's
going
to
be
at
CVS,
slash
rectangle
option
two
is
to
get
a
little
bit
creative,
so
I
went
to
a
anagram
generator,
and
this
is
you
type
in
rectangle.
These
are
all
the
words
that
still
have.
These
are
all
the
other
words
they
have
the
same
suspect
angle.
So
when
we
did
as
a
class,
we
made
nectar
leg,
but
I
couldn't
use
that
cuz.
A
Now
next,
your
leg
is
taken
for
this
talk,
so
we're
gonna
use
trance
leg
instead,
so
we
will
have
to
post
a
readme
and
some
documentation,
because
it
is
not
going
to
be
clear
from
the
name
what
this
module
does,
and
so
how
do
we
get
started
right?
Well,
we
open
up
our
little
command
line
and
we
can
go
ahead
and
just
make
a
new
folder
right,
just
hop
on
in
and
head
in.
There,
alright
and
I
think
that's
nice,
except
before,
like
I'm
p.m.
A
got
a
lot
of
it
start
from
just
having
a
package.json
right,
and
so
what
we
need
to
do
is
create
a
package
of
JSON
except
like
like
I,
can't
remember
the
rules
of
JSON.
It's
like
double
quoted
keys.
You
can't
have
a
trailing
comma.
It's
almost
like
it's
trying
to
hurt
your
feelings.
Sometimes,
luckily
we
don't
really
have
to
deal
with
that
right.
We
have.
A
We
have
tools
that,
like
save
us
from
like
trying
to
figure
out
where
we
messed
up
getting
our
JSON
in
order
right,
so
we
go
ahead
and
hit
NPM
and
knit,
and
this
is
a
little
fun
tool
that
will
kind
of
like
ask
you
a
series
of
questions
like
hoping
you
to
figure
out
like
which
Disney
character
you
are,
but
this
is
for
your
module
so,
and
it
has
a
lot
of
like
sensible
defaults
which
are
really
cool.
It's
like
hey
you're
at
a
folder
called
trance
lag
I'm
like
thank
you
for
noticing.
A
You
probably
want
to
name
this
module.
Trance
lag
I'm
like
you're
right
I.
Do
what
version
would
you
like
it
to
be
right
and
you
it'll
give
you
a
suggestion
of
1.0.0?
You
can
be
a
contrarian
and
do
zero
point,
zero
point,
one
whatever
right
and
then
a
description,
and
so
ours
is
going
to
be
a
very
important
module
for
working
with
rectangles
and
an
entry
point.
This
is
when
somebody
NPM
installs
your
module,
and
they
do
like
requires
trance
leg
like
where
do
we
start
right?
A
What
is
the
entry
file
of
this
cuz
like
I?
Could
have
I
could
break
stuff
out
into
multiple
files,
but
this
is
this
is
where
starts
if
you
have
something,
if
you
already
have
a
file
like
surfer,
Jas
or
like
mayonnaise
NPM
will
be
really
smart.
Try
it's
best
to
figure
out
what
file
it
was,
but
if
this
is
just
an
empty
directory,
so
we're
gonna
get
indexed
a
Jaso.
It
seems
reasonable
to
me
a
test
command.
Alright
and
you
know
I
say
I
want
to
use
mocha
or
make
file
or
whatever
right
anyone.
A
You
want
you
kind
of
like
put
it
in
there.
If
you
don't
put
any
it'll
like
just
echo
and
error
that
you
didn't
write,
tests
and
kind
of,
like
just
shame
you
get
repository,
which
will
kind
of
round
back
to
later
some
keywords
for
finding
it
right
because
again,
I
have
a
terribly
named
module,
so
we
could
say
stuff,
like
rectangle,
quadrilateral
geometry,
just
kind
of
like
search
terms,
all
right
who
the
author
is
right.
That
is
me.
You
should
not
use
this.
You
should
use
your
name.
What
license
you
want
to
do
is
see.
A
Is
the
default
MIT
use
a
mozilla
public
license?
Whatever
one
makes
you
happiest
you
kind
of
put
in
there,
you
should
also
have
a
license
file
in
there
as
well,
and
then
it's
like
hey
this
is
the
package
jason
I'm
gonna
make
for
you.
This
is
cool
and
the
default
answer
is
yes,
and
now
you
have
a
package.json,
your
folder
and
it's
all
perfectly
formatted,
and
you
have
everything
that
you
need
and
you
can
change
this
because
it's
just
a
JSON
file.
A
If
you
like,
I
made
a
boo-boo
just
go
ahead,
you
can
change
it
and
say
the
file
is
totally
fine,
but
at
least
like
the
hard
work
of
like
getting
everything
order,
making
sure
you
have
all
the
right
seals
has
been
done
for
you.
You're,
like
my
name,
doesn't
change
that
often
right
so
it'd
be
cool
if
I
could
just
like
save
that,
so
do
I
have
to
type
it
in
every
time,
and
the
answer
is
no.
You
can
actually
go
ahead
and
set
some
configuration
options.
A
You
can
be
like
hey
when
I'm
doing
opinions
on
it.
My
name
is
Steve
Kenny
or
your
name,
I
mean
if
you
want
to
publish
modules
under
my
name,
if
they're
good,
that's
totally,
okay,
an
email
address
you
can,
you
can
set,
you
know,
set
like
a
website
where
they
can
find
more
about
you
and
now,
if
you
do
NPM
in
it,
it'll
ask
you
a
bunch
of
questions.
It
won't
ask
you,
for
your
name
anymore
and
it'll
actually
fill
it
in
for
you
right.
A
So
now
you
have
this
kind
of
like
setting
done
it
in
place.
The
other
hard
part
is
like
I,
don't
even
like
I,
don't
want
to
type
in
the
whole
get
URL
every
time.
So
the
good
news
is
that
you
don't
necessarily
have
to.
If
you
kind
of
start
the
workflow
a
little
bit
differently
and
you
start
by
creating
a
new
repository
and
setting
it
up
and
then
cloning
it
down,
and
then
you
just
clone
the
you
call
the
repository
it's
like.
A
Instead
of
create
a
folder
you're,
just
gonna
clone
the
repo
down
and
you
can
go
ahead
and
CD
into
it
and
run
yeah
man
it.
It's
actually
gonna
do
a
bunch
of
things.
For
you,
it's
going
to
fill
in
this
repository
automatically.
It's
also
when
your
rectangle
library
becomes
very
popular
people
are
going
to
have.
People
have
requests
on
the
Internet,
people
have
opinions,
I,
don't
know
if
you've
ever
if
you've
ever
noticed
this,
and
so
it's
where
they
can
file
bugs
to
see
the
homepage
becomes.
A
A
No
literally,
you
just
be
like
hey
I'm
here
man,
it
like
it's
cool
I'm,
just
gonna
slam
on
the
Enter
key
and
you
can
like
form
a
working
relationship
where
it's
just
gonna
like
fill
in
the
defaults
for
you
defaults
of
your
name,
defaults
of
the
repo.
If
you
have
all
that
set
up
you
just
NPM,
yes,
yes
or
why
and
you're
good
to
go
alright.
So
now
we
have
to
make.
We've
talked
a
lot
about
like
getting
set
up.
A
I
am
very
bad
at
math,
so
this
is
where
I
start
to
like
hit
the
wall
on
what
I
can
do
with
the
rectangle.
So
we
have
that
and
remember
the
people
are
going
to
use
this
code.
It
can't
be
like
the
yeah
I'm
just
going
to
deploy
it
if
something
breaks,
I'll
fix
it
later.
People
are
going
to
rely
on
this
very
important,
rectangle
module
that
you
made
and
it's
up
to
you
to
make
sure
that
everything
works.
So
we're
gonna
write
some
tests
to
go
along
with
it.
A
We
can
npm,
install
mocha
or
whatever,
like
I,
don't
want
to
I,
don't
had
to
fight
about
this,
and
but
you
can
ever
even
sell
mocha,
but
you
want
to
make
sure
everyone
else
working
on
this
module
also
knows
that
they
need
mocha,
so
you
could
say
save
right
which
would
be
like
when
someone
combs
it
down,
they
should
get
mocha
except
they
don't
they're,
not
gonna
run
the
tests.
Waves
are
just
using
it
right,
so
we
could
say
F
save
dev,
which
is
gonna,
be
like
all
right.
A
If
you're
just
using
this
module,
you
don't
need
the
whole
like
test
runner,
but
if
you're
gonna
be
like
working
on,
if
you
clone
it
down
and
do
npm
install
to
like
work
on
this
very
important
rectangle
module,
then
in
that
case
you
ought
to
have
Mogens
there.
If
you
don't
like
typing
they're
safe,
you
can
just
do
capital
s,
capital
D,
for
safer
saving
as
a
dev
dependency.
A
A
If
you
forget
to
save
stuff,
you
can
always
like
set
it
to
save
something
to
your
package
JSON
right.
If
the
boo-boo
you
can
always
remove
it,
because
it's
a
JSON
file
or
you
could
say
like
hey
and
this
exact
version-
and
these
are
settings
that
now
forever
it
will
automatically
save
it,
and
you
can
move
it
around
and
do
stuff
like
that.
So
here
we
have
some
tests
like
it
should
do
the
thing
that's
important
and
we
can
run
our
tests
and
one
thing
you
might
notice
is
I
didn't
like
globally
install
mocha
right.
A
It's
just
like
a
dependency
of
my
particular
module
and
one
of
the
cool
things
is
in
your
package,
a
JSON.
You
have
this
scripts
like
list
of
like
different
scripts.
You
might
want
to
run
it
what's
cool
about
this.
Is
that
anything
in
here
the
path
of
your
like
binaries
for
your
node
module,
so
you
have
installed
locally
to
that
project
is
added
when
you
run
it.
So,
if
I
ran
mbm
test,
that's
going
to
run
mocha
relative
to
that
project.
The
one
I
have
installed.
A
So
this
means
you
could
have
mocha
installed
at
like
I.
Don't
know
the
mochas
right
now
be
really
honest,
but
you
could
have
like
a
previous
version
so
on
a
different
project.
You
don't
have
to
worry
about
any
of
that
stuff.
If
real,
quick,
we
said
echo
wish
mocha
as
we
run,
it
you'll
see
that
it's
actually
scoped.
That
was
the
wrong
way
to
zoom.
It's
actually
scoped
to
the
project
right.
A
So
like
we
can
have
it
install
for
each
and
every
one
of
them,
but
then
we
can
want
to
get
a
little
fancy
with
our
rectangle
module
right.
It
works
and
that's
not
good
enough
for
us.
We're
gonna,
take
our
fun
little
prototypal
inheritance
thing
and
we're
gonna
use
extras,
favorite
feature
of
es6
classes
and
we're
gonna.
Do
that
and
we're
gonna
change
these
perimeter
area
methods
to
computed
properties,
and
it's
gonna
be
really
great,
wonderful
and
then
that's
cool.
But
your
boss
comes
in
and
says:
hey,
hey,
node,
zero.
A
A
A
So
what
we
can
do
is
we
can
go
ahead
and
like
use,
install
some
tools
right.
We're
gonna
write
in
the
latest
greatest
version,
it's
a
JavaScript,
but
we
want
it
available
for
anyone
who
can
run
like
es5
or
anything
like
that.
So
we'll
go
ahead,
we'll
make
a
little
babel
RC!
That's
fun
cool
and
we
could
do
this
every
time.
We've
made
an
important
change
to
our
module.
A
We
can
be
really
honest
with
ourselves
and
realize
that
we're
never
going
to
remember
to
do
this
right,
we're
going
to
want
to
do
it,
we're
just
never
gonna,
remember
to
do
it.
So
what
we
could
do
is
we
could
add
it
to
our
scripts
in
our
pack
of
such
a
song,
we
say:
NPM
run,
build
and
that'll
be
scoped
to
just
right.
We
don't
have
to
think
about
it
anymore,
and
so
you
can
run
that
it'll
go
ahead
and
build
everything
for
us,
except
we're
probably
going
to
forget
to
do
that
too.
A
Like
we've
made
it
easier,
but
we
haven't
solved
the
core
problem
of
we're,
not
gonna,
remember
to
do
it
unless
you're
better
than
me,
and
then
you
might
so.
We've
got
these
like
these
friendly
and
PM
scripts
that
we
use
all
the
time
publish
test
install
start,
but
they
also
come
like
when
you
run
NPM
start
right.
You
actually
run
NPM
pre-start
NPM
start
NPM,
post
start
right,
and
so
you
can
do
things
beforehand
right.
A
We
can
look
at
NPM
pre
published,
which
means
I'm,
gonna,
publish
this
type
script
or
CoffeeScript
module
I
worked
on
right
before
it
goes
up
to
the
registry.
Let's
go
turn
that
into
like.
You
know
like
universal,
like
JavaScript
right
same
thing,
with
a
pre
installed
post,
install
they're,
different
hooks
that
allow
you
to
hook
into
the
whole
process
and
have
like
custom
functionality,
so
you
can
kind
of
automate
it
and
remove
yourself
from
having
to
remember
to
do
certain
things
cool.
A
So
here
we'll
say,
NPM
pre
publish
is
going
to
run,
npm
run
build
and
we
can
do
other
stuff
in
here.
We
could
like
also
es
lint
and
test,
so
we
make
sure
it's
lint
it
and
tested
viewer.
We
push
it
up.
Whatever
you
want
to
do.
You
can
also
like
npm
run.
Build
is
our
own
like
custom
script,
that
we
made
right,
there's
nothing
special
about
it.
It's
why
we
had
to
use
run
beforehand.
You
could
have
npm
run
sandwich
and
I
don't
it'll
do
something
do
whatever
you
say
it
does.
A
The
thing
is
I
need
to
like
that
fancy
pants
code
that
I
wrote
before
I
do
want
to
commit
that
to
version
control,
because
that's
the
code
I'm
working
on,
but
I,
don't
need
to
ship
that
code
that
they're
not
running
with
them
right
so
I
don't
want
to
ship
all
those
es6
source
files
with
a
coffee,
script
or
typescript,
or
what
have
you
source
files,
but
I
do
want
to
have
them
in
get
so
I
need
like
that
kind
of
plate.
David
I'm,
not
shipping
them,
but
I
do
want
to
have
them
around.
A
Just
like
I
forget
ignore
you
can
actually
have
an
NPM
ignore
right.
These
are
the
false
that
will
not
ship
with
your
project
and
there's
certain
things
kind
of
already
built
in
there
that
won't
ship
with
it
like
log
files
and
stuff,
like
that,
we're
gonna,
say
our
source
file,
which
is
all
that
es6
that
we
wrote
is
in
there
and
that
will
now
not
publish,
but
we
could
also
commit
it
to
get
which
is
kind
of
cool.
A
The
other
cool
fact
is:
if
you
already
have
to
read
me
what
IBM
will
do
was
it'll
look
at
the
first
line
that
doesn't
have
a
pound
sign
in
front
of
it
right.
So
the
first
thing,
that's
not
clear,
like
a
markdown
header,
and
it
will
actually
set
that
as
the
description
of
your
module.
If
you
do
NPM
an
it
and
you
already
have
a
readme,
so
you'll
also
get
that
for
free,
too
cool
if
you've
never
published
something.
That
begin
before.
A
If
you
are
one
of
the
4.5
million
minus
84,000
people,
you
can
go
ahead
and
create
an
account
right
from
the
command
line.
If
you
already
have
an
account
you
can
just
log
in
and
then
you
just.
This
is
how
you
get
the
permission
to
publish
to
NPM.
This
is
the
kind
of
main
part
you
just
type
in
NPM,
publish
and
that's
that
what
your
module
is.
A
Now
again,
people
have
opinion
for
the
feature:
requests
come
in
the
bug,
requests
come
in
and
stuff
along
those
lines
and
let's
say
we
started
at
that:
1.0.0
Isaac's
talking
a
little
bit
about
semantic
versioning
right
and
the
idea
is
if
we
do
a
little
tiny
like
change,
we
fix
like.
Oh,
we
fix
a
bug,
but
it
doesn't
change
the
way
we
work
with
the
module
doesn't
add
any
new
features
right,
we
can
say
NPM
version
patch
and
it
will
bump
us
up
from
1.0
0.0
to
1.0
point
1.
A
Let
them
know
like
this
is
a
big
deal
right
and
then
we
can
do
an
NPM
version,
major-
and
that
seems
neat,
but
we
also
get
some
free
things
with
that
right.
All
it
will
update
our
package
JSON.
It
will
also
make
some
commits
on
our
behalf
right,
which
is
super
cool,
and
it
will
also
you
also
set
like
get
tags
for
each
one
of
those
version
commits
right
all
for
us,
like
we
don't
have
to
really
think
about
it.
A
Once
we
have
that
we
can,
we
can
publish
right
and
congratulations
like
you
did
it
you.
You
now
have
all
the
information
you
need
to
know
about,
to
publish
stuff
onto
NPM
and
like
on
one
hand
like
JavaScript,
is
a
wonderful
languages.
It's
like
fair
share
for
like
rough
edges,
and
the
cool
part
is
that
we
can
then
create
solutions
that
we
can
share
as
a
community,
which
I
think
is
really
important.
A
Even
better
is
that
javascript
is
always
like
finding
its
way
like
to
find
to
do
new
things
right
like
we
can
program
robots
with
it.
We
can
you
know
we
can
do.
We
can
do
it
on
the
server
now.
Did
you
hear
about
that?
We
can
make
desktop
applications
with
JavaScript
right
and,
as
we
keep
like,
pushing
the
language
forward.
There's
like
new
needs
and
new,
like
kind
of
places
where
we
might
need
to
have
shared
solutions.
A
So
once
you
once
you
think
about
yourself
as
somebody
who
can
create
and
contribute
to
the
community
and
you
kind
of
start
getting
in
the
habit
like
we
are
all
better
off
for
it
right
so
like
hopefully,
if
you've,
if
you
felt
like
I
I,
don't
know
how
to
do
this.
I,
don't
like
I,
don't
have
permission
to
do
this.
You
I
have
now,
given
you
permission,
you
have
permission
to
publish
NPM
modules.
Now
it's
like
it's
an
extra
gift.
So
thank
you
so
much.