Node.js is many things, but mostly it’s a way of running JavaScript outside the web browser. This book will cover why that’s important and the benefits that Node.js provides. This introduction attempts to sum up that explanation in a few paragraphs, rather than a few hundred pages.
Many people use the JavaScript programming language extensively for programming the interfaces of websites. Node.js allows this popular programming language to be applied in many more contexts, in particular on web servers. There are several notable features about Node.js that make it worthy of interest.
Node is a wrapper around the high-performance
V8 JavaScript runtime from the Google Chrome browser. Node
tunes V8 to work better in contexts other than the browser, mostly by
providing additional APIs that are optimized for specific use cases. For
example, in a server context, manipulation of binary data is often
necessary. This is poorly supported by the JavaScript language and, as a
result, V8. Node’s Buffer class
provides easy manipulation of binary data. Thus, Node doesn’t
just provide direct access to the V8 JavaScript runtime. It also makes
JavaScript more useful for the contexts in which people use Node.
V8 itself uses some of the newest techniques in compiler technology. This often allows code written in a high-level language such as JavaScript to perform similarly to code written in a lower-level language, such as C, with a fraction of the development cost. This focus on performance is a key aspect of Node.
JavaScript is an event-driven language, and Node uses this to its advantage to produce highly scalable servers. Using an architecture called an event loop, Node makes programming highly scalable servers both easy and safe. There are various strategies that are used to make servers performant. Node has chosen an architecture that performs very well but also reduces the complexity for the application developer. This is an extremely important feature. Programming concurrency is hard and fraught with danger. Node sidesteps this challenge while still offering impressive performance. As always, any approach still has trade-offs, and these are discussed in detail later in the book.
To support the event-loop approach, Node
supplies a set of “nonblocking” libraries. In essence, these are interfaces
to things such as the filesystem or databases, which operate in an
event-driven way. When you make a request to the filesystem, rather than
requiring Node to wait for the hard drive to spin up and retrieve the file,
the nonblocking interface simply notifies Node when it has access, in the
same way that web browsers notify your code about an onclick event. This
model simplifies access to slow resources in a scalable way that is
intuitive to JavaScript programmers and easy to learn for everyone
else.
Although not unique to Node, supporting JavaScript on the server is also a powerful feature. Whether we like it or not, the browser environment gives us little choice of programming languages. Certainly, JavaScript is the only choice if we would like our code to work in any reasonable percentage of browsers. To achieve any aspirations of sharing code between the server and the browser, we must use JavaScript. Due to the increasing complexity of client applications that we are building in the browser using JavaScript (such as Gmail), the more code we can share between the browser and the server, the more we can reduce the cost of creating rich web applications. Because we must rely on JavaScript in the browser, having a server-side environment that uses JavaScript opens the door to code sharing in a way that is not possible with other server-side languages, such as PHP, Java, Ruby, or Python. Although there are other platforms that support programming web servers with JavaScript, Node is quickly becoming the dominant platform in the space.
Aside from what you can build with Node, one extremely pleasing aspect is how much you can build for Node. Node is extremely extensible, with a large volume of community modules that have been built in the relatively short time since the project’s release. Many of these are drivers to connect with databases or other software, but many are also useful software applications in their own right.
The last reason to celebrate Node, but certainly not the least important, is its community. The Node project is still very young, and yet rarely have we seen such fervor around a project. Both novices and experts have coalesced around the project to use and contribute to Node, making it both a pleasure to explore and a supportive place to share and get advice.
Installing Node.js is extremely simple. Node runs on Windows, Linux, Mac, and other POSIX OSes (such as Solaris and BSD). Node.js is available from two primary locations: the project’s website or the GitHub repository. You’re probably better off with the Node website because it contains the stable releases. The latest cutting-edge features are hosted on GitHub for the core development team and anyone else who wants a copy. Although these features are new and often intriguing, they are also less reliable than those in a stable release.
Let’s get started by installing Node.js. The
first thing to do is download Node.js from the website, so let’s go there
and find the latest release. From the Node home page, find the download
link. The current release at the time of print is 0.6.13, which is a
stable release. The Node website provides installers for Windows and Mac
as well as the stable source code. If you are on Linux, you can either do
a source install or use your usual package manager (apt-get,
yum, etc.).
Note
Node.js version
numbers follow the C convention of
major.minor.patch. Stable versions of Node.js
have an even minor version number, and development versions have an odd
minor version number. It’s unclear when Node will become version 1, but
it’s a fair assumption that it will only be when the Windows and Unix
combined release is considered mature.
If you used an installer, you can skip to
First Steps in Code. Otherwise (i.e., if you are doing a
source install), once you have the code, you’ll need to unpack it. The
tar command does this using the flags xzf. The x
stands for extract (rather than compress), z tells tar to also
decompress using the GZIP algorithm, and f
indicates we are unpacking the filename given as the final argument (see
Example 1-1).
The next step is to configure the code for
your system. Node.js uses the configure/make system for its installation.
The configure script
looks at your system and finds the paths Node needs to use for the
dependencies it needs. Node generally has very few dependencies. The
installer requires Python 2.4 or greater, and if you wish to use TLS or
cryptology (such as SHA1), Node needs the OpenSSL development
libraries. Running configure will let you know
whether any of these dependencies are missing (see Example 1-2).
Example 1-2. Configuring the Node install
enki:node-v0.6.6 $ ./configure
Checking for program g++ or c++ : /usr/bin/g++
Checking for program cpp : /usr/bin/cpp
Checking for program ar : /usr/bin/ar
Checking for program ranlib : /usr/bin/ranlib
Checking for g++ : ok
Checking for program gcc or cc : /usr/bin/gcc
Checking for gcc : ok
Checking for library dl : yes
Checking for openssl : not found
Checking for function SSL_library_init : yes
Checking for header openssl/crypto.h : yes
Checking for library util : yes
Checking for library rt : not found
Checking for fdatasync(2) with c++ : no
'configure' finished successfully (0.991s)
enki:node-v0.6.6 $The next installation step is to make the project (Example 1-3). This compiles Node and builds the binary
version that you will use into a build subdirectory of the source
directory we’ve been using. Node numbers each of the build steps it needs
to complete so you can follow the progress it makes during the
compile.
Example 1-3. Compiling Node with the make command
enki:node-v0.6.6 $ make
Waf: Entering directory `/Users/sh1mmer/Downloads/node-v0.6.6/out'
DEST_OS: darwin
DEST_CPU: x64
Parallel Jobs: 1
Product type: program
[ 1/35] copy: src/node_config.h.in -> out/Release/src/node_config.h
[ 2/35] cc: deps/http_parser/http_parser.c -> out/Release/deps/http_parser/http_parser_3.o
/usr/bin/gcc -rdynamic -pthread -arch x86_64 -g -O3 -DHAVE_OPENSSL=1 -D_LARGEFILE_SOURCE ...
[ 3/35] src/node_natives.h: src/node.js lib/dgram.js lib/console.js lib/buffer.js ...
[ 4/35] uv: deps/uv/include/uv.h -> out/Release/deps/uv/uv.a
...
f: Leaving directory `/Users/sh1mmer/Downloads/node-v0.6.6/out'
'build' finished successfully (2m53.573s)
-rwxr-xr-x 1 sh1mmer staff 6.8M Jan 3 21:56 out/Release/node
enki:node-v0.6.6 $The final step is to use make to install Node. First, Example 1-4 shows how to install Node globally for the
whole system. This requires you to have either access to the root user or sudo privileges that let you act as root.
Example 1-4. Installing Node for the whole system
enki:node-v0.6.6 $ sudo make install
Password:
Waf: Entering directory `/Users/sh1mmer/Downloads/node-v0.6.6/out'
DEST_OS: darwin
DEST_CPU: x64
Parallel Jobs: 1
Product type: program
* installing deps/uv/include/ares.h as /usr/local/include/node/ares.h
* installing deps/uv/include/ares_version.h as /usr/local/include/node/ares_version.h
* installing deps/uv/include/uv.h as /usr/local/include/node/uv.h
...
* installing out/Release/src/node_config.h as /usr/local/include/node/node_config.h
Waf: Leaving directory `/Users/sh1mmer/Downloads/node-v0.6.6/out'
'install' finished successfully (0.915s)
enki:node-v0.6.6 $If you want to install only for the local user
and avoid using the sudo command, you
need to run the configure script with
the --prefix argument to tell Node to
install somewhere other than the default (Example 1-5).
Example 1-5. Installing Node for a local user
enki:node-v0.6.6 $mkdir ~/localenki:node-v0.6.6 $./configure --prefix=~/localChecking for program g++ or c++ : /usr/bin/g++ Checking for program cpp : /usr/bin/cpp ... 'configure' finished successfully (0.501s) enki:node-v0.6.6 $ make && make install Waf: Entering directory `/Users/sh1mmer/Downloads/node-v0.6.6/out' DEST_OS: darwin DEST_CPU: x64 ... * installing out/Release/node as /Users/sh1mmer/local/bin/node * installing out/Release/src/node_config.h as /Users/sh1mmer/local/include/node/... Waf: Leaving directory `/Users/sh1mmer/Downloads/node-v0.6.6/out' 'install' finished successfully (0.747s) enki:node-v0.6.6 $
Get Node: Up and Running now with the O’Reilly learning platform.
O’Reilly members experience books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.
