►
Description
Join us for Kubernetes Forums Seoul, Sydney, Bengaluru and Delhi - learn more at kubecon.io
Don't miss KubeCon + CloudNativeCon 2020 events in Amsterdam March 30 - April 2, Shanghai July 28-30 and Boston November 17-20! Learn more at kubecon.io. The conference features presentations from developers and end users of Kubernetes, Prometheus, Envoy, and all of the other CNCF-hosted projects
Getting Started with Node.js - Justin Reock, Rogue Wave Software
Learn to leverage the power of server-side Javascript with this Node.js introductory tutorial. We’ll dive into Node’s architecture and understand the build and dependency management systems involved. Several modules for Node will be demoed, and we’ll learn how to debug Node applications within an IDE. You’ll come away with an understanding of what sets Node apart from traditional Javascript, it’s inherently asynchronous and event-driven architecture, and take a look at some real world applications built on Node.
https://sched.co/Nrs9
A
Right
I've
got
220,
let's
go
ahead
and
get
started
thanks.
Everybody
for
showing
up,
I,
hope,
you're
enjoying
the
conference
so
far,
I
hope
you're,
not
as
jet-lagged
as
I.
Am
it's
it's
a
bit
of
a
journey
from
from
the
US.
So
this
is
getting
started
with
with
nodejs,
and
this
really
is
a
beginner
introduction
doesn't
really
assume
that
you
have
any
existing
knowledge
of
nodejs.
A
Maybe
a
little
bit
of
JavaScript
would
be
helpful,
but
we're
not
gonna
get
into
too
much
complex
code,
we're
mostly
going
to
kind
of
focus
on
the
architecture
and
show
sort
of
what
it
takes
to
get
started
right
now
using
nodejs.
So
who
is
this?
Nerd
I'm
Justin
react
I'm,
the
chief
architect
at
rogue
wave
software
I
focused
mostly
on
our
emerging
open
source
technologies
that
we
like
to
focus
on
as
a
company.
We
provide
services
and
support
for
community
editions
of
open
source
packages,
so
we
do
not
branch,
we
do
not
proprietor
eyes.
A
We
allow
you
to
get
the
software
from
the
community
and
we
can
provide
you
with
support.
In
fact,
this
presentation
comes
out
of
a
three
day,
comprehensive
training
that
we
do
on
nodejs,
so
please
feel
free
to
get
in
touch
with
me
if
you're
at
all
interested
in
anything
like
that
and
I
promise.
That
is
the
last
sales
pitch
you
will
hear
from
me.
So
what
are
we
gonna
solve
today?.
A
Hold
on
no
just
kidding,
nobody
likes
the
spinning
wheel
of
doom
or
the
spinning
wheel
of
hope,
so
we're
gonna
talk
about
how
we
can
use
asynchronous
processing
to
be
able
to
return
requests
back
to
our
users.
Faster
anode
is
inherently
asynchronous,
and
for
anybody
who
hasn't
worked
in
a
language
that
is
inherently
asynchronous,
it's
it's
difficult.
It's
gonna
be
a
bit
of
a
shift
in
the
way
that
you
think
about
the
way
that
you're
writing
your
code.
A
Some
of
those
fundamentals.
Note
is
actually
an
ideal
language
for
doing
something
like
this,
because
it
is
inherently
asynchronous
and
it's
very
small
and
very
lightweight
all
right.
It
is
built
on
the
industry
standards
and
it's
been
vetted
against
thousands
of
production
systems.
It
is
an
extremely
popular
language
right
now,
so
what
else
are
we
going
to
solve?
This
is
probably
the
more
valuable
part
of
working
with
nodejs.
So
in
the
past,
this
is
what
a
development
processor
team
would
look
like
right.
A
We'll
have
back-end
servers,
these
are
exposing
data
or
services
to
front-end
applications
or
front
end
servers
right,
and
maybe
we're
writing
these
front-end
apps
in
HTML
and
JavaScript
and
CSS,
and
so
we
have
our
UI
developers
who
are
familiar
with
JavaScript.
Who
are
writing
this
part
of
the
code?
Meanwhile,
we
have
another
silo
right,
our
back-end
servers.
These
are
our
back-end
api's
and
back-end
systems,
and
maybe
these
are
getting
coded
in
PHP
or
Perl
or
Java
right.
So
this
should
look
pretty
familiar
for
anybody.
A
Who's
done
any
type
of
development
over
the
last
say,
15
years,
but
now
we
can
do
this
now
we
can
have
a
DevOps
team,
only
code
in
nodejs
we
have
an
app
farm
and
our
app
is
served
up,
but
from
both
the
back
end
and
the
front
end
using
JavaScript
using
nodejs.
Okay,
that's
an
important
concept
here
right,
so
people
who
have
been
good
at
doing
JavaScript
development
for
a
while
can
now
be
more
useful
at
doing
back-end
development.
A
So
this
allows
us
to
code
our
front
end
and
our
back
end
using
a
single
language,
okay,
which,
if
you
think
about
this
in
terms
of
agile
methodologies
and
scrum,
it's
a
lot
better
when
we're
having
a
scrum
meeting
or
something
like
that,
and
the
technical
folks
in
that
meeting
are
all
capable
of
understanding
and
speaking
the
same
language,
so
a
little
bit
of
an
overview
of
the
language
by
the
way.
Stop
me
at
any
point.
If
you
have
a
question
I'll
do
my
best.
A
It
was
created
by
a
guy
named
Ryan
Dahle
in
2009
and
really
was
just
created
mostly
to
deal
with
these
concurrency
issues
that
we
were
talking
about
before
right.
So
when
we
start
thinking
about
distributed
compute
and
parallel
compute,
we
have
to
start
rethinking
the
way
that
we
write
code.
We
need
that
code
to
be
useful
when
it's
concurrent
write,
a
single
JavaScript
process
is
single
threaded
by
default
right.
We
we
have
one
engine
in
this
case
the
v8
chrome
engine,
which
is
our
JavaScript
interpreter,
and
that
is
a
single
threaded
process.
A
But
as
we'll
see
in
a
moment,
Ryan
Dahl
sort
of
famously
over
the
weekend
built
a
layer
between
the
v8
engine
and
the
JavaScript
interpreter
and
we'll
we'll
see
a
picture
of
that
in
a
minute,
but
it's
built
on
Chrome's
v8
JavaScript
engine.
So
again,
this
is
important
when
nodejs
does
not
use
its
own
JavaScript
engine
right.
A
It
uses
an
industry
standard
engine,
but
what
it
really
does
is
layer,
some
tools
in
front
of
that
engine
that
allow
us
to
do
concurrent
coding
and
if
that
doesn't
make
sense
right
now,
don't
worry
it
will
in
a
minute
we'll
see
a
picture
all
right.
A
single
threaded
asynchronous
have
been
driven.
We
can
achieve
vertical
scale
by
adding
additional
CPU
cores
and
there
are
actually
conventions
within
the
language
we're
in
just
a
couple
of
lines
of
code.
A
There's
a
list
of
register
subscribers,
which
are
basically
just
node
processes
and
they
are
notified
when
their
state
changes.
Ok,
so
you
have
a
pub
sub
or
a
topic
like
pattern
happening
between
worker
nodes
and
a
master
node,
and
that
master
node
is
able
to
communicate
down
to
the
worker
nodes
and
the
worker
nodes
can
communicate
back
up
to
the
master
using
a
topic
kind
of
pub/sub
methodology.
A
We
also
have
NPM
this
used
to
be
called
a
node
package
manager
now
you're
just
supposed
to
pretend
that
the
node
doesn't
stand
for
node
anymore,
because
this
has
become
a
general
sort
of
JavaScript
module
repository.
But
the
vast
majority
of
these
modules
are
for
node,
so
anybody
who's
familiar
with
you
know
maybe
pip
in
Python
or
Sipan
in
perl
or
new,
get
in
dotnet.
You
already
know
what
NPM
is
it's
just
a
package
manager
for
installing
dependencies
for
your
node
applications
as
a
20-7.
A
So
any
Java
developers
like
myself,
who
are
using
maven
you're
like
wow,
there's
a
lot
of
modules
in
there
yeah
well
NPM
has
you
know
almost
four
times
as
many
at
this
point
and
continuing
to
grow
very
quickly,
so
just
sort
of
a
general
overview
here,
sort
of
pros
and
cons
of
using
node
on
the
good
side
of
things.
It
is
very
lightweight
with
an
extremely
low
memory
footprint.
A
A
It
is
very
popular
gaining
lots
of
popularity
right
now,
I
think
I
think
it
has
sort
of
the
same
appeal
that
a
language
like
Perl
had
in
the
late
90s
right
this
this
the
shared
repository
of
well
written
dependencies,
but
it's
just
a
little
bit
more
advanced
of
a
language
right
now,
but
I
think
that's
why
it's
catching
fire
the
way
it
is
there's
already
a
lot
of
people
who
understand
JavaScript
and
so
to
make
the
transition
to
node.
It's
just
not
that
difficult.
A
You
need
to
learn
a
little
bit
more
about
the
additional
modules
that
you
can
use
a
node
and
learn
a
little
bit
about
NPM
get
familiar
with
some
subjects
like
semantic
versioning
and
things
like
that.
But,
overall,
if
you've
done
JavaScript
development,
it's
pretty
easy
to
make
this
transition.
It
is
full
stack
web
development
and
it's
highly
extensible.
Now
on
the
bad
side
of
things,
the
v8
engine
does
have
a
1.7
memory,
gigabyte
memory
limit.
Okay.
A
That
means
that
we
have
to
have
multiple
v8
engines
processing
in
parallel.
If
we
want
to
be
able
to
use
more
than
1.7
gigs
of
memory
within
our
application
and
again
we
can
do
that
by
taking
advantage
of
nodes
clustering
functionality.
So
this
makes
a
vertical
scaling
challenge,
but
workarounds
do
exist.
Module
versions
can
get
a
little
bit
confusing.
For
the
most
part,
people
are
conforming
to
semantic
versioning,
which
does
make
your
life
easier,
but
not
necessarily
over.
Open-Source
governance
is
not
flawless
if
anybody's
familiar
with
the
Left
pad
debacle
from
a
few
years
ago.
A
This
was
a
really
big
deal.
There
was
a
module
and
note
it
was
like
18
lines
of
code.
It
was
a
very
small
module
and
the
purpose
of
that
module
was
to
install
to
insert
spaces
left
tab
spaces
so
that
you
could
align
text.
This
thing
was
used
all
over
the
place.
All
right,
tons
and
tons
of
apps
were
using
this.
The
maintainer
got
angry
and
pulled
the
module
off
of
NPM
literally
breaking
the
internet.
A
It's
a
very
interesting
story
to
read,
but
a
good
reminder
for
everybody
that
you
have
to
be
careful
about
your
use
of
open
source.
You
have
open
source
is
the
best
thing
in
the
world,
but
you
have
to
govern
it.
You
have
to
manage
it.
You
can't
just
go
wild
with
it
and
definitely
a
learning
curve
for
developers
who
maybe
aren't
used
to
dealing
with
a
language
that
is
inherently
asynchronous
again.
It's
it's
it's
a
different
paradigm.
It
really
feels
different
when
you're
coding,
you
know
you
expect
your
code
to
just
execute
one
line.
A
One
line,
one
line,
one
line
like
you
used
to
with
it
with
a
synchronous
language,
but
in
this
case
that's
not
happening
at
all.
No
tis,
absolutely
gonna
skip
ahead
in
your
code
and
execute
things
further
down,
even
if
it
hasn't
finished
the
asynchronous
action
that
it
had
before
we
do
have
ways
to
make
this
a
little
bit
easier.
We
have
like
promises
and
closures
and
things
like
those
patterns.
If
you're
used
to
that,
we
now
have
a
relatively
new
functionality
that
was
introduced
in
economics.
A
Fear
of
2016
I
think
called
async/await,
which
allows
us
to
pretend
that
our
code
is
a
little
bit
more
iterative.
But
but
just
again,
you
know
be
aware:
that's
probably
the
biggest
challenge
for
people
who
are
just
coming
in
to
JavaScript
is
in
no
js'
is
wrapping
their
heads
around
this.
This
sort
of
inherent
asynchronous
nature.
A
So
again,
this
is
a.
This
is
a
web-enabled
one,
we're
actually
creating
a
back-end
web
server
here.
Okay,
so
as
opposed
to
just
you
know,
printing
something
out
to
the
command
line
or
whatnot
we're
actually
spinning
up
a
lightweight
web
server.
That's
called
just
basically
the
HTTP
module
that
that
ships
with
node
and
that
HTTP
module
allows
us
to
create
a
small
HTTP
server,
respond
to
certain
requests,
and
then
you
know
push
what
we
want
and,
of
course
we
tell
it
to
listen
on
a
particular
point:
our
port
okay.
So
this
is
interesting
right.
A
This
is
JavaScript
creating
a
back-end
web
server
that
can
service
requests
all
right.
That's
that's
different!
Java
scripts
usually
served
up
by
a
back-end
server-
it's
not
usually
the
backend
server,
but
again
that
that's
fundamentally,
what's
different
about
this
very
high
level.
Look
at
the
architecture
and
what
kind
of
makes
this
different,
and
so
I
said
before
that
that
the
creator
of
nodejs
Ryan
Dahl
built
this
thing
over
the
weekend.
Well,
if
you
look
at
the
architecture
here,
you
can
kind
of
see
how
that's
possible
right
down
here.
This
is
the
v8
chrome
engine.
A
This
is
the
actual
JavaScript
interpreter.
This
is
not
written
by
or
maintained
by
the
node.js
community.
This
is
the
industry
standard,
JavaScript
interpreter.
But
what
have
we
done
here?
We
have
had
our.
We
were
asking
our
app
to
pass
commands
through
the
node
engine.
This
is
proprietary
to
no
js'.
We
have
some
miscellaneous
libraries
that
we
might
hit
to
access
the
operating
system.
Okay,
we've
just
fundamentally
shifted
here
from
what
we're
used
to
with
JavaScript
Java
scripts,
not
supposed
to
be
able
to
know
anything
about.
A
What's
going
on
at
the
operating
system
level,
it's
sandbox
to
the
browser
for
security
purposes
right,
you
wouldn't
want
somebody
able
to
just
access,
or
just
just
run
some
arbitrary
JavaScript
code
on
your
laptop
and
give
them
access
to
your
operating
system.
But
node,
of
course,
has
to
do
that
because
it's
running
on
the
back
end,
so
it
has
some
special
libraries
specifically
for
accessing
things
about
the
operating
system
level.
Then
we
have
this
interesting
thing
here.
Called
live.
A
Uv
live
UV
is
a
very
fast
event
loop,
it's
an
event
loop
that
was
created
in
C++,
specifically
for
nodejs.
Now
it
has
found
some
use
in
some
other
applications
as
well.
It's
completely
open-source,
but
this
is
the
magic.
This
is
what
makes
no
js'
so
different.
I'm
passing
commands
asynchronously
down
into
an
event
loop
that
event
loop
is
asynchronously,
taking
actions
against
the
engine
or
against
the
operating
system
and
returning
things
back
to
the
application.
A
This
is
how
I'm
capable
of
having
a
distributed
application
that
could
actually
spawn
multiple
instances
of
the
v8
engine
to
allow
this
to
to
allow
the
code
to
execute
in
parallel
all
right.
So
it
is
literally
spawning
off
multiple
Java
side,
note
v8
processes
on
the
server
to
go
and
service
a
single
JavaScript
action,
okay,
so
you're
writing
code
and
when
it
executes
that
action
actually
goes
into
its
own,
isolated
v8
engine
instance
and
executes.
So
then
return
something.
So
this
does
a
couple
of
things
for
us
right.
A
So,
first
of
all,
it
makes
it
very
easy
for
us
to
be
concurrent
in
general.
As
long
as
you
can
wrap
your
head
around
the
asynchronous
semantics
of
the
language,
you
shouldn't
even
really
have
to
think
about
this.
It
just
kind
of
works
that
way.
It
also
makes
it
inherently
thread
safe,
okay,
because
v8
itself
is
single
threaded
and
because
we're
running
these
multiple
JavaScript
actions
inside
of
isolated,
separate
v8
instances
they
are
running
in
there
own
thread,
their
thread
safe,
inherently
another
way
of
looking
at
the
same
architecture.
A
Here's
our
app
passing
commands
into
v8,
here's,
the
special
nodejs
bindings
and
here's
this
event
queue,
and
it
really
just
is
a
queue
right.
It's
a
loop
events
come
into
the
queue,
the
read
off
the
queue
and
a
loop.
If
we
have
a
blocking
operation
like
a
database,
read
or
a
filesystem
read,
then
then
this
will
block,
but
that's
okay,
because
the
next
event
queue
can
be
sent
out
into
another
instance
of
v8
and
execute
in
parallel.
Okay.
So
so
this
is
where
the
magic
happens.
A
But
if
you
look
at
this
and
this
these
two
pieces
here
we're
just
kind
of
we're
just
kind
of
stapled
on
to
JavaScript
and
that's
how
Ryan
Dahl
was
able
to
create
nodejs
in
a
weekend
right.
He
didn't
really
write
that
much
code.
He
just
kind
of
put
together
some
some
libraries
that
made
sense
to
work
together.
A
So
you
know
for
the
most
popular
programming
language
out
there
with
the
biggest
number
of
dependencies
and
modules
out
of
any
other
language.
It's
pretty
impressive
that
he
really,
you
know
just
kind
of
cranky
thing
out
over
a
weekend.
It's
a
very
smart
guy.
If
you
ever
get
a
chance
to
meet
him
or
talk
with
him,
he
doesn't
like
conferences
and
he's
not
a
big
public
speaker,
but
he
does
attend
some
of
them.
If
you
get
a
chance
to
hear
him
or
speak
with
him,
I
I
highly
recommend
it
he's
a
very
smart
guy.
Okay.
A
So
how
do
we
actually
get
node
going
on
your
system?
Well
kind
of
depends
on
your
operating
system
for
you
dealing
with
Linux
if
we're
using
Linux,
which
you
know
you
probably
should
be
most
of
these
open
source
technologies
were
built
with
Linux
in
mind
and
then
maybe
back
ported
to
like
a
like,
like
a
Windows
environment,
Mac
is
kind
of
the
exception
right,
we're
running
BSD,
so
it's
its
UNIX
e-enough.
A
A
Once
it's
been
installed,
we
want
to
make
sure
that
our
package
manager
package
manager
has
been
installed
as
well
and
we
can
validate
that
just
by
checking
the
version
of
each
binary
from
the
command
line.
So
here
we
are
just
saying:
no
version
rank
now
the
old
version
and
upgraded
on
my
Mac
and
then
I
were
seeing
that
NPM
is
installed
as
well,
and
if
that
runs
your
codes,
gonna
run
because
these
tools
are
written
in
node.js
alright.
A
A
A
A
This
shirt
says
open-source
and
it's
a
Microsoft,
the
world's
changing
a
little
bit
and
and
BS
code.
Is
it
great
it's
a
great
little
IDE,
totally
free
and
open
source
and
the
preview
edition
cooler
new
functionality?
So
you
can
do
things
like
remotely
develop
the
SSH
on
a
remote
server
and
stuff,
like
that,
it's
pretty
great
terminal
integration
is
essential
when
you're
building
your
node
apps.
In
fact,
youth
on
that
demo,
I
didn't
even
open
an
IDE
right,
I
just
went
right
into
VI
and
just
just
threw
something
out
there.
A
The
built-in
debugger
works
flawlessly
with
nodejs.
So
it's
really
a
nice
experience
it
just
it
just
works,
and
you
do
have
other
options,
though,
go
with
what's
familiar
and
go
with
what's
available
and
is
not
notepad.
That's
critical,
so
we've
all
got
our
preferences
when
it
comes
to
IDs
or
maybe
you're
already
familiar
with
something
like
eclipse.
That's
fine,
there's,
there's
no
js'
tooling
for
eclipse.
Maybe
you
prefer
an
online
IDE,
something
that's
integrated
already
with
docker
and
maybe
gives
you
a
container
environment.
A
Well,
you
have
that
too,
just
want
to
make
sure
that
you've
met
these
basic
criteria
when
you're
picking
this
ID
I.
Do
you
really
want
the
debugger?
Obviously
you
want
syntax
highlighting
you
want
it
to
support.
What's
called
es
lint
for
those
that
don't
know,
javascript
is
not
really
JavaScript.
It's.
The
special
vacation
is
actually
called
ECMAScript
or
Xmas
script,
and
that's
what
that
es
comes
from.
Do
you
want
es
lint
and
if
ever
use
lint
before
to
clean
up
your
code
or
to
check
your
code
for
syntax?
It's
basically
what
it's
doing.
A
We
want
terminal
integration.
We
want
NPM
integration.
We
want
code
completion
with
intellisense,
we
want
to
beautifier.
We
do
want
docker
integration
these
days.
You
know
it's
just
a
lot
easier
to
get
started
with
with
docker.
We
want
node
modules,
integration
which
we'll
look
at
in
a
minute
and
we
want
our
source
control
integration,
hopefully
we're
using
git
or
something
like
that
and
we're
not
just
you
know,
saving
our
our
program
in
a
zip
or
something.
But
you
do
have
some
other
options.
A
When
you
want
to
look
at
an
IDE,
this
one
is
actually
pretty
cool,
I
have
to
say
this
cloud9
IDE,
it's
completely
online,
and
so
it's
kind
of
like
kind
of
cloudy.
Basically,
all
your
codes
gonna
get
stored
up
in
the
cloud,
but
it
does
have
to
get
integrations
and
all
that
kind
of
stuff.
You
can
push
all
your
code
out
to
your
github
live
preview.
A
Jetbrains.
If
you
like
the
IntelliJ
experience,
if
you're
a
Java
developer,
JetBrains
does
produce
one,
that's
similar
called
webstorm
for
nodejs,
komodo
and
then
node
clips.
If
you
like
eclipse,
then
you
can
just
get
the
node.js
plugins
for
Eclipse,
so
plenty
of
options
here,
I,
just
really
like
vs
code,
so
we're
gonna
focus
on
that.
A
We
have
a
bunch
of
BS
code,
extensions
for
no
GS
when
we
search
for
it
up
here,
so
you've
got
our
debug
and
really
just
adjust
up
just
a
bunch
of
stuff
and
there's
a
whole
lot
of
plugins
for
the
various
frameworks
and
dependency
libraries
that
we
can
use
with
notes.
So
things
like
view,
J
s
or
angularjs
or
react,
there's
a
lot
of
tooling
that's
built
in
for
that
as
well.
A
I
have
another
talk
on
react
which,
unfortunately
didn't
get
accepted
at
this
one,
but
I
will
be
giving
that
talk
at
the
OSS
summit
in
San
Diego
in
August
start
with
at
least
no
debug
in
the
node.js
extension
gone
I
take
time
to
explore.
What's
out
there,
though,
in
vs
code,
we
have
a
launch
file,
that's
specific,
to
vs
code.
Alright,
this
has
nothing
to
do
with
know
J,
as
this
is
telling
vs
code
how
to
launch
our
app.
But
this
is
essential
if
we
want
to
be
able
to
debug
our
app
okay.
A
The
launch
configuration
is
controlled
through
a
JSON
file
called
launch
JSON,
so
it
launches-
and
it
basically
just
describes
the
environment
bootstrap
information
for
the
app
if
I
want
to
set
some
environment
variables.
Maybe
this
is
where
I
would
do
that,
but
it
is
essential
for
debugging,
because
your
app
is
gonna
get
more
complex.
A
You're
gonna
need
some
stuff
set
up
in
your
environment
before
you
can
run
your
app
like
an
environment
variable
or
whatnot,
maybe
you're
using
OAuth,
and
you
need
a
client
key
I,
don't
know
you're
gonna
be
storing
stuff
in
an
environment
variable
and
it
won't
launch
properly
without
that
environment
variable
being
set.
So
you
need
to
tell
vs
code
what
the
environment
should
look
like,
and
you
do
that
and
this
launch
data
a
JSON
file.
So
let's
take
a
quick
look
at
the
debugger.
A
Okay,
when
you
get
started
with
node,
you're
gonna
spend
a
lot
of
time
in
here
all
right
and
in
this
debugger,
because
it's
very
easy
to
look
at
the
way
that
the
node
JS
object,
notation
works
and
it's
very
easy
to
kind
of
see
how
functions
like
every
object
is
actually
treated
like
a
function.
Functions
are
first
class
citizens
in
nodejs,
so
I
can
pass
them
and
I
can
set
them
and
and
all
that
get
more
into
that.
I
have
a
advanced
talk
on
this.
So
let's
just
run
this.
Let's
look
at
our
launch
configuration.
A
A
So
I'm
not
gonna,
go
into
the
contents
of
all
of
this
right
now,
but
I
do
kind
of
recommend
you
poke
around
in
here,
because
you're
gonna
get
to
learn
a
lot
about
what
nodes
actually
doing
in
the
background
for
you,
but
we
can
see
that
we
have
to
find
our
constant
it
just
hasn't
been
set
yet
currently
undefined.
So,
let's
move
to
our
next
breakpoint
and
great,
we
can
see
that
our
variable
has
actually
been
populated.
At
this
point
we
could
introspect
it.
A
A
All
right
so
we've
seen
just
a
quick
hello
world
that
you
can
get
started
with
very
easily
and
now
you've
had
a
little
preview
of
what
we
can
do
in
terms
of
our
developer,
our
debugger
in
our
IDE.
So
this
is
the
basic
life
cycle
of
an
ode,
app
we're
gonna,
create
and
clone
an
SCM
repo,
hopefully
again,
hopefully
we're
using
source
control
like
good
people
right.
But
if
not,
you
can
just
create
a
folder
if
you're
gonna
use
get,
you
know,
set
up
your
ignore
files
and
what
not
you
want
to
initialize
the
project.
A
This
is
the
best
practice.
I
haven't
done
that
yet
the
very
last
demo
shows
that
but
NPM
an
it
will
set
up
you
a
file
called
package
JSON
that
we're
about
to
see
and
that's
like
your
build
file.
That's
where
all
your
dependency
information
is
housed,
as
well
as
some
meta
information
about
the
app
itself
NPM,
and
it
will
set
that
up
for
you
automatically
and
a
lot
of
IDE.
Plugins
and
extensions
will
do
that
too.
Then
you
just
get
to
it
start
coding,
commit
as
normal
and
then
build
so
in
our
target
production
environment.
A
We're
gonna
run
this
NPM
install,
that's
gonna,
download
and
all
of
our
necessary
dependencies.
When
we
see
our
package
JSON
file
in
a
minute,
this
npm
install
will
actually
go
out
to
the
npm
repository,
pull
all
the
modules
down,
which
is
effectively
the
build
process
for
note,
because
again,
we're
not
compiled
in
anything.
A
A
A
A
A
Then
this
is
what
we
have
now
I
in
just
a
minute:
I'm
gonna
kind
of
rush
through
a
little
bit
cuz
I,
want
to
see
I
want
to
show
you
the
very
last
part
which
is
working
with
external
modules
in
NPM,
but
all
of
that
dependency
data
is
held
in
that
package.
Json
file,
which
again
looks
like
this,
so
our
our
apps
can
use
dependencies
or
modules.
Remember
everything
in
nodejs
is
a
module
technically
most
open
source
languages.
A
These
days
are
going
to
have
a
set
of
modules
that
can
be
added
to
a
project
notice,
no
different.
You
can
also
create
your
own
modules,
whether
privately
or
freely
available,
and
the
mbm
repositories
would
actually
provides
these
and
it
could
be
used
to
add
dependencies
to
a
project
by
again
using
this
npm
install
command.
But
it's
not
npm
installed.
Blank
like
doing
the
whole
build
like
we
saw
a
second
ago.
This
is
actually
installing
a
particular
module.
A
A
Notice
all
the
pretty
colors
okay.
Now,
what
did
that?
Do?
We've
got
our
package
JSON
file,
and
now
we
have
this
new
folder
called
node
modules
as
well,
and
this
is
unsurprisingly,
where
our
modules
just
downloaded
to
so.
If
we
do
a
quick
LS
in
here,
we
can
see
that
the
colors
module
downloaded
and
if
we
pick
this
up,
it's
just
another
nodejs
module.
Just
written
a
note.
A
A
A
We
learned
that
you
should
carry
your
clicker
with
you
and
you
leave
podium.
No
js'
is
a
language
that
focuses
on
concurrency
and
unified
development.
Under
a
single
language,
dependencies
are
assisted
through
the
node
package
manager,
which
is
no
longer
called
the
node
package
manager.
It
is
asynchronous
by
default.
A
lot
of
ideas
exist.
A
You
should
initialize
your
projects
using
NPM
in
it.
You
can
install
modules
with
NPM
install
they're
built
from
package.json
when
we
install
in
a
production,
environment
and
they're
included
in
variables
using
the
require
command,
but
there's
still
a
lot
to
learn
so
go
learn
about
understanding,
asynchronous
coding.
It
just
takes
practice,
get
to
know
the
events
and
streams
inside
of
node
learn
about
functional
programming.
This
is
very
much
functional
programming,
mastery,
IDs,
debugger
and
start
exploring
other
modules
and
finally
feel
free
to
reach
out
to
me.