Node: Up and Running

Index

A note on the digital index

A link in an index entry is displayed as the section title in which that entry appears. Because some sections have multiple index markers, it is not unusual for an entry to have several links to the same section. Clicking on any link will take you directly to the place in the text in which the marker appears.

Symbols

. (period), Node REPL

A

A (address) records, DNS

accept HTTP header, Let’s Build Twitter

add-ons, Add-ons

address (A) records, DNS

advanced message queueing protocol (AMQP), RabbitMQ, Work queues

aes192 algorithm, Encrypting with Cipher

Almaer, Dion, Professionalism in JavaScript

AMQP (advanced message queueing protocol), RabbitMQ, Work queues

APIs, Let’s Build Twitter, Let’s Build Twitter, Core APIs, console.log, Core APIs, Helper APIs, VM

(see also specific APIs)

adding, Let’s Build Twitter

core, Core APIs, console.log

helper, Helper APIs, VM

testing, Let’s Build Twitter

applications, Building a Chat Server (see web applications)

apt command, Installation

ASCII encoding format, A quick primer on binary, Using Buffers

assert module, Let’s Build Twitter, Let’s Build Twitter, Testing Through assert, Testing Through assert, Testing Through assert, Testing Through assert, Testing Through assert, Testing Through assert, Testing Through assert, Testing Through assert, Testing Through assert, Testing Through assert, Testing Through assert, Testing Through assert

about, Let’s Build Twitter, Testing Through assert, Testing Through assert

deepEqual() method, Testing Through assert

doesNotThrow() method, Testing Through assert

equal() method, Testing Through assert, Testing Through assert

notDeepEqual() method, Testing Through assert

notEqual() method, Testing Through assert, Testing Through assert

notStringEqual() method, Testing Through assert

strictEqual() method, Let’s Build Twitter

stringEqual() method, Testing Through assert

throws() method, Testing Through assert

asynchronous communications, The I/O Problem Space, Ordered serial I/O, Error Handling, Filesystem

callbacks and modified objects, Ordered serial I/O

error handling in, Error Handling

fs module and, Filesystem

I/O activities and, The I/O Problem Space

auth command (Redis), Securing Redis

authentication, password (Redis), Securing Redis

B

basicAuth middleware, Middleware

binary data, A quick primer on binary, A quick primer on binary, Binary and strings

about, A quick primer on binary, A quick primer on binary

strings and, Binary and strings

block ciphers, Encrypting with Cipher

blocking operations, Glossary

blowfish algorithm, Encrypting with Cipher

bodyParser middleware, Let’s Build Twitter, Handling Form Data, Middleware

browsers, Browser Wars 2.0 (see web browsers)

BSON object storage, MongoDB

Buffer class, A Very Brief Introduction to Node.js, Building a Chat Server, Building a Chat Server, Making HTTP GET requests, Buffers, Buffers, A quick primer on binary, A quick primer on binary, Binary and strings, Using Buffers, Using Buffers, Using Buffers, Working with strings, Working with strings, Working with strings, Working with strings

about, A Very Brief Introduction to Node.js, Building a Chat Server, Making HTTP GET requests, Buffers

binary data and, A quick primer on binary, A quick primer on binary

binary data and strings, Binary and strings

byteLength() method, Working with strings

size considerations, Buffers, Using Buffers

toString() method, Building a Chat Server

usage considerations, Using Buffers, Using Buffers

working with strings, Working with strings, Working with strings

write() method, Working with strings

C

callbacks, A First Server, The Event Loop, The Event Loop, Unordered parallel I/O, Ordered serial I/O, Ordered serial I/O, Callback Syntax, Callback Syntax, Filesystem, DNS, Glossary

dealing with events, Callback Syntax, Callback Syntax

defined, A First Server, Glossary

DNS module and, DNS

event-driven programming and, The Event Loop, The Event Loop

modified objects and, Ordered serial I/O

nesting, Ordered serial I/O, Filesystem

unordered parallel I/O and, Unordered parallel I/O

canonical name (CNAME) records, DNS

Caswell, Tim, Ordered serial I/O

chat server application, Building a Chat Server, Building a Chat Server, Building a Chat Server, Building a Chat Server, Building a Chat Server, Building a Chat Server, Building a Chat Server, Building a Chat Server, Building a Chat Server, Building a Chat Server, Building a Chat Server, Building a Chat Server, Building a Chat Server, Building a Chat Server

about, Building a Chat Server

causing server failure, Building a Chat Server

checking write status of sockets, Building a Chat Server

communicating between clients, Building a Chat Server

connecting to TCP server, Building a Chat Server

creating TCP server, Building a Chat Server

disconnecting clients, Building a Chat Server

improving chat server, Building a Chat Server

improving message sending, Building a Chat Server

listening to each connection, Building a Chat Server

logging errors, Building a Chat Server

running improved chat server, Building a Chat Server

sending data to servers, Building a Chat Server

sending messages between clients, Building a Chat Server

checkContinue event, HTTP Servers

child processes, Using Multiple Processors, Using Multiple Processors, Child Process, child_process.spawn( )

child_process module, Using Multiple Processors, Child Process, Child Process, Child Process, child_process.exec( ), Child Process, Child Process, Child Process, Child Process, child_process.exec( ), child_process.exec( ), child_process.spawn( ), child_process.spawn( ), child_process.spawn( ), child_process.spawn( ), child_process.spawn( )

about, Using Multiple Processors, Child Process

exec() method, Child Process, child_process.exec( )

pid property, Child Process

spawn() method, Child Process, child_process.spawn( ), child_process.spawn( )

stderr property, Child Process, child_process.spawn( )

stdin property, Child Process, child_process.exec( ), child_process.spawn( )

stdout property, Child Process, child_process.exec( ), child_process.spawn( )

Cipher class, Public Key Cryptography, Encrypting with Cipher, Encrypting with Cipher, Encrypting with Cipher

about, Public Key Cryptography, Encrypting with Cipher

final() method, Encrypting with Cipher

update() method, Encrypting with Cipher

.clear meta-command, Node REPL

clientError event, HTTP Servers

ClientRequest class, HTTP Clients, Uploading data for HTTP POST and PUT, HTTP Clients, Uploading data for HTTP POST and PUT, Uploading data for HTTP POST and PUT

about, HTTP Clients, Uploading data for HTTP POST and PUT

end() method, HTTP Clients, Uploading data for HTTP POST and PUT

write() method, Uploading data for HTTP POST and PUT

ClientResponse class, Let’s Build Twitter, Making HTTP GET requests, The ClientResponse object, The ClientResponse object, The ClientResponse object

about, The ClientResponse object

header property, The ClientResponse object

setEncoding() method, Let’s Build Twitter, Making HTTP GET requests

statusCode property, The ClientResponse object

close event, HTTP Servers

cluster module, Using Multiple Processors, Using Multiple Processors, Using Multiple Processors, Using Multiple Processors, Using Multiple Processors

about, Using Multiple Processors, Using Multiple Processors

fork() method, Using Multiple Processors

isMaster property, Using Multiple Processors

isWorker property, Using Multiple Processors

CNAME (canonical name) records, DNS

code, writing, Writing Code for Production (see writing code for production)

CoffeeKup template engine, Template Engines

commonJS module format, A First Server, Modules

compiler middleware, Middleware

CONFIG command, Securing Redis

configure script, Installing Node.js, Installing Node.js

about, Installing Node.js

--prefix argument, Installing Node.js

Connect library, Ordered serial I/O, Middleware, Middleware

connection event, Building a Chat Server, HTTP Servers

connection pooling, Connection Pooling, Connection Pooling

console.log command, A First Server, Building a Chat Server, Using Multiple Processors, A quick primer on binary, console.log

about, console.log

error event and, Building a Chat Server

hex values in, A quick primer on binary

printing information with, A First Server, Using Multiple Processors

.cookieParser middleware, Middleware

CouchDB database, CouchDB, Installation, Installing CouchDB’s Node module, Using CouchDB over HTTP, Using node-couchdb, Using node-couchdb, Deleting documents, Using node-couchdb, Working with databases, Working with databases, Creating documents, Reading documents, Reading documents, Updating documents, Updating documents, Deleting documents, Deleting documents

about, CouchDB

createClient() function, Working with databases

creating documents in, Creating documents

creating tables in, Working with databases

deleting documents from, Deleting documents

getDoc command, Reading documents

installing, Installation

Node module, Installing CouchDB’s Node module, Using node-couchdb

node-couchdb package, Using node-couchdb, Deleting documents

over HTTP, Using CouchDB over HTTP, Using node-couchdb

reading documents, Reading documents

removeDoc command, Deleting documents

saveDoc command, Updating documents

updating records in, Updating documents

createConnection command, Publish and subscribe

Crockford, Douglas, Professionalism in JavaScript, HTTP

cross-site request forgery (CSRF) protection, Middleware

crypto module, Crypto, Hashing, Hashing, Hashing, HMAC, HMAC, HMAC, HMAC, Public Key Cryptography, Public Key Cryptography, Public Key Cryptography, Public Key Cryptography, Encrypting with Cipher, Decrypting with Decipher, Creating signatures using Sign, Creating signatures using Sign, Verifying signatures with Verify

about, Crypto

Cipher class, Public Key Cryptography, Encrypting with Cipher

createHash() method, Hashing

createHmac() method, HMAC

createSign() method, Creating signatures using Sign

Decipher class, Public Key Cryptography, Decrypting with Decipher

Hash class, Hashing, Hashing

Hmac class, HMAC, HMAC, HMAC

Sign class, Public Key Cryptography, Creating signatures using Sign

Verify class, Public Key Cryptography, Verifying signatures with Verify

cryptography, Installing Node.js, Crypto, Crypto, Hashing, Crypto, HMAC, HMAC, HMAC, Public Key Cryptography, Verifying signatures with Verify

hashing and, Crypto, Hashing

HMAC and, Crypto, HMAC, HMAC

OpenSSL and, Installing Node.js, HMAC

public key, Public Key Cryptography, Verifying signatures with Verify

usage considerations, Crypto

CSRF (cross-site request forgery) protection, Middleware

csrf middleware, Middleware

D

Dahl, Ryan, HTTP

data access, Data Access, CouchDB, Deleting documents, Redis, Securing Redis, MongoDB, Performance, MySQL, Sequelize, PostgreSQL, Insertion, updates, and deletion, Connection Pooling, Connection Pooling, MQ Protocols, Work queues

about, Data Access

connection pooling, Connection Pooling, Connection Pooling

CouchDB database, CouchDB, Deleting documents

MongoDB database, MongoDB, Performance

MQ protocols, MQ Protocols, Work queues

MySQL database system, MySQL, Sequelize

PostgreSQL database system, PostgreSQL, Insertion, updates, and deletion

Redis key-value store, Redis, Securing Redis

data event, Readable streams

db-mysql package, Installation

Decipher class, Public Key Cryptography, Decrypting with Decipher, Decrypting with Decipher

about, Public Key Cryptography, Decrypting with Decipher

update() method, Decrypting with Decipher

.delete command (MySQL), Deletion

DELETE verb (HTTP), Using CouchDB over HTTP, Handling Form Data

deleting, Filesystem, Deleting documents, Deletion, Insertion, updates, and deletion

data in MySQL, Deletion

data in PostgreSQL, Insertion, updates, and deletion

documents from CouchDB, Deleting documents

files, Filesystem

denial-of-service (DoS) attack, Handling Form Data

die event, The Event Loop

directory middleware, Middleware

distributing work example, Using Multiple Processors, Using Multiple Processors

dns module, DNS, DNS, DNS, DNS, DNS, DNS, DNS, DNS

about, DNS

lookup() method, DNS

resolve() method, DNS, DNS

resolve4() method, DNS

resolve6() method, DNS

resolveMX() method, DNS

reverse() method, DNS

DNS requests, A quick primer on binary

document stores, Using CouchDB over HTTP, Using node-couchdb, Reading documents, Redis, Securing Redis

CouchDB over HTTP, Using CouchDB over HTTP, Using node-couchdb

reading documents, Reading documents

Redis key-value store, Redis, Securing Redis

DOS (denial-of-service) attack, Handling Form Data

E

EADDRINUSE exception, Using Multiple Processors

Eich, Brendan, Professionalism in JavaScript

EJ (Embedded JavaScript) template engine, Template Engines

EJS layout file, Let’s Build Twitter

emailchanged event, Using Socket.IO with Express

emailupdate event, Using Socket.IO with Express

Embedded JavaScript (EJ) template engine, Template Engines

encoding formats, A quick primer on binary, Using Buffers

end event, process.stdin

error event, Building a Chat Server, Error Handling

error handling, Error Handling

errorHandler middleware, Middleware

eval() method call, VM

event listeners, EventEmitter, EventEmitter, Callback Syntax, process events

about, process events

calling, Callback Syntax

creating for events, EventEmitter

firing, EventEmitter

event loop, The Event Loop, The Event Loop, The Event Loop, The Event Loop, The Event Loop, The Event Loop, Event loop and tickers, Event loop and tickers

about, The Event Loop, The Event Loop

callbacks and, The Event Loop, The Event Loop

patterns and, The Event Loop

process module and, Event loop and tickers, Event loop and tickers

single-threaded concept, The Event Loop

event-driven programming, The Event Loop, The Event Loop, The Event Loop, The Event Loop, The Event Loop, Patterns, Ordered serial I/O

about, The Event Loop

callbacks and, The Event Loop, The Event Loop

nonblocking operations and, The Event Loop

patterns and, Patterns, Ordered serial I/O

single-threaded concept, The Event Loop

EventEmitter class, EventEmitter, EventEmitter, EventEmitter, Callback Syntax, Streams, process events

about, EventEmitter

emit() method, EventEmitter, Callback Syntax

on() method, EventEmitter

process module and, process events

stream support, Streams

events, EventEmitter, EventEmitter, EventEmitter, EventEmitter, Callback Syntax, Callback Syntax, Callback Syntax

(see also specific events)

callback syntax, Callback Syntax, Callback Syntax

creating event listeners for, EventEmitter

emitting, EventEmitter

listening for, EventEmitter

passing parameters when emitting, Callback Syntax

Events API, Events, EventEmitter, Callback Syntax, Callback Syntax, Callback Syntax, Streams, process events

about, Events

callback syntax, Callback Syntax, Callback Syntax

EventEmitter class, EventEmitter, Callback Syntax, Streams, process events

exit event, process events

.exit meta-command, Node REPL

Express module, Let’s Build Twitter, Let’s Build Twitter, Let’s Build Twitter, Let’s Build Twitter, Let’s Build Twitter, Let’s Build Twitter, Let’s Build Twitter, Let’s Build Twitter, Let’s Build Twitter, Express, A Basic Express App, A Basic Express App, A Basic Express App, A Basic Express App, Setting Up Routes in Express, Setting Up Routes in Express, Handling Form Data, Handling Form Data, Handling Form Data, Handling Form Data, Template Engines, Layouts and partial views, Middleware, Middleware factories, Middleware factories, Using Socket.IO with Express, Using Socket.IO with Express

about, Let’s Build Twitter, Express, A Basic Express App

app folder structure, Let’s Build Twitter

bodyDecoder() method, Let’s Build Twitter

bodyParser() function, Let’s Build Twitter, Handling Form Data

createServer() method, Let’s Build Twitter

handling form data, Handling Form Data

http module and, A Basic Express App

installing, Let’s Build Twitter, Let’s Build Twitter, A Basic Express App

layout file in, Let’s Build Twitter

limit() method, Handling Form Data

listen() method, Let’s Build Twitter

methodOverride() function, Handling Form Data

middleware and, Middleware, Middleware factories

send() method, A Basic Express App

setting up routing in, Setting Up Routes in Express, Setting Up Routes in Express, Middleware factories

Socket.IO library and, Using Socket.IO with Express, Using Socket.IO with Express

template engines, Template Engines, Layouts and partial views

F

factory pattern, Middleware factories, Middleware factories

favicon middleware, Middleware

FIFO (first-in-first-out) queue, Lists

file descriptors, child_process.spawn( )

files, Filesystem, Filesystem

deleting, Filesystem

reading, Filesystem

filesystem module, Filesystem (see fs module)

first-in-first-out (FIFO) queue, Lists

fs module, Filesystem, Filesystem, Filesystem, HMAC, Socket.IO

about, Filesystem

readFile() method, Filesystem

readFileSync() method, HMAC, Socket.IO

unlink() method, Filesystem

Fuchs, Thomas, Professionalism in JavaScript

functional scope in JavaScript, Ordered serial I/O

functions, Node REPL, Ordered serial I/O, Ordered serial I/O, Hashing, Glossary

defined, Glossary

functional scope and, Ordered serial I/O

hashing and, Hashing

Node REPL and, Node REPL

passing changes between, Ordered serial I/O

G

generic-pool module, Connection Pooling

get command (Redis), Basic usage

GET verb (HTTP), Making HTTP GET requests, Making HTTP GET requests, A Basic Express App, Handling Form Data

getDoc command, Reading documents

GZIP algorithm, Installing Node.js

H

Haml template engine, Template Engines

Hash class, Hashing, Hashing, Hashing, Hashing

digest() method, Hashing, Hashing

update() method, Hashing, Hashing

Hash-based Message Authentication Code (HMAC), Crypto, HMAC, HMAC

hashes and hashing algorithms, Crypto, Hashing, Crypto, HMAC, HMAC, Hashes, Hashes, Data types

about, Crypto, Hashing

HMAC and, Crypto, HMAC, HMAC

native MongoDB driver support, Data types

Redis key-value store and, Hashes, Hashes

“Hello World” example, A First Server

.help meta-command, Node REPL

hexadecimal notation, A quick primer on binary

HMAC (Hash-based Message Authentication Code), Crypto, HMAC, HMAC

Hmac class, HMAC, HMAC, HMAC

creating object, HMAC

digest() method, HMAC

update() method, HMAC

hmset command (Redis), Hashes

hset command (Redis), Basic usage, Hashes

HTML5 WebSockets standard, Socket.IO

HTTP clients, Let’s Build Twitter, HTTP Clients, The ClientResponse object

http module, A First Server, A First Server, A First Server, A First Server, Let’s Build Twitter, Let’s Build Twitter, Let’s Build Twitter, Let’s Build Twitter, The Event Loop, The Event Loop, Error Handling, Using Multiple Processors, HTTP, HTTP, HTTP Servers, HTTP Servers, HTTP Servers, HTTP Servers, HTTP Servers, HTTP Clients, The ClientResponse object, HTTP Clients, Uploading data for HTTP POST and PUT, HTTP Clients, Making HTTP GET requests, Making HTTP GET requests, Making HTTP GET requests, The ClientResponse object, Using CouchDB over HTTP, A Basic Express App, Middleware, Socket.IO

about, Let’s Build Twitter, HTTP

ClientRequest class, HTTP Clients, Uploading data for HTTP POST and PUT

ClientResponse class, Let’s Build Twitter, Making HTTP GET requests, The ClientResponse object

Connect library and, Middleware

createServer() method, A First Server, The Event Loop, HTTP, HTTP Servers, Using CouchDB over HTTP

Express module and, A Basic Express App

get() method, Error Handling, Making HTTP GET requests, Making HTTP GET requests

HTTP clients, Let’s Build Twitter, HTTP Clients, The ClientResponse object

HTTP servers, The Event Loop, HTTP Servers, HTTP Servers, Socket.IO

including in code, A First Server

request() method, A First Server, Let’s Build Twitter, HTTP Clients

Server class, HTTP Servers, HTTP Servers

ServerResponse class, A First Server

work distribution example, Using Multiple Processors

HTTP servers, The Event Loop, HTTP Servers, HTTP Servers, Socket.IO

about, HTTP Servers, HTTP Servers

creating, The Event Loop

Socket.IO library and, Socket.IO

HTTP, CouchDB over, Using CouchDB over HTTP, Using node-couchdb

I

I/O activities, The Event Loop, The I/O Problem Space, The I/O Problem Space, The I/O Problem Space, Unordered parallel I/O, Ordered serial I/O, Ordered serial I/O, Error Handling, I/O, console.log

(see also nonblocking operations)

API support, I/O, console.log

Node approach, The Event Loop, The I/O Problem Space

ordered serial I/O, Ordered serial I/O, Ordered serial I/O

splitting out, Error Handling

unbounded latency, The I/O Problem Space

unordered parallel I/O, Unordered parallel I/O

Ingres database system, PostgreSQL, PostgreSQL

(see also PostgreSQL database system)

.insert command (MySQL), Insertion

installing, Installing Node.js, Installing Node.js, Let’s Build Twitter, Let’s Build Twitter, Installation, Installing CouchDB’s Node module, Installation, Installing Redis’s Node module, Installation, Installation, Installation, Installation, Installation, Installing RabbitMQ, A Basic Express App

CouchDB database, Installation

CouchDB Node module, Installing CouchDB’s Node module

db-mysql package, Installation

Express module, Let’s Build Twitter, Let’s Build Twitter, A Basic Express App

Mongoose library, Installation

native MongoDB driver, Installation

node-db module, Installation

Node.js, Installing Node.js, Installing Node.js

PostgreSQL database system, Installation

RabbitMQ message broker, Installing RabbitMQ

Redis key-value store, Installation

Redis Node module, Installing Redis’s Node module

IPv4 address records, DNS

IPv6 address records, DNS

J

Jade template engine, Template Engines, Template Engines

JavaScript, A Very Brief Introduction to Node.js, A Very Brief Introduction to Node.js, Node REPL, Professionalism in JavaScript, Professionalism in JavaScript, Ordered serial I/O, Writing Code for Production, Error Handling, A quick primer on binary

about, A Very Brief Introduction to Node.js, A Very Brief Introduction to Node.js, Professionalism in JavaScript

browser support, Professionalism in JavaScript

functional scope, Ordered serial I/O

hexadecimal notation and, A quick primer on binary

maximum heap size, Writing Code for Production

trycatch functionality, Error Handling

weird and amusing things about, Node REPL

jQuery template engine, Template Engines

K

keys, HMAC, Public Key Cryptography, Verifying signatures with Verify, Public Key Cryptography, Public Key Cryptography, Hashes

PEM-encoded, HMAC, Public Key Cryptography

private, Public Key Cryptography

public, Public Key Cryptography, Verifying signatures with Verify

setting, Hashes

kill command, child_process.exec( )

Koch, Peter Paul, Professionalism in JavaScript

Kvaleim, Christian, MongoDB native driver

L

layouts and partial views, Layouts and partial views, Layouts and partial views

.less files, Middleware

libpq-dev package, Installation

limit middleware, Middleware

list commands in Redis, Lists

Listener class, Socket.IO

logger middleware, Middleware

lpush command (Redis), Lists

M

mail exchanger (MX) records, DNS

make command, Installing Node.js

master processes, Using Multiple Processors, Using Multiple Processors

MD5 hashing algorithm, Crypto, Hashing

methodOverride middleware, Handling Form Data, Middleware

methods (term), Glossary

middleware, Let’s Build Twitter, Ordered serial I/O, Setting Up Routes in Express, Middleware, Middleware, Middleware, Middleware factories, Middleware factories

about, Let’s Build Twitter, Middleware, Middleware

Connect library and, Ordered serial I/O, Middleware

factory pattern, Middleware factories, Middleware factories

route, Setting Up Routes in Express

MongoDB database, MongoDB, MongoDB native driver, Writing records, Mongoose, Performance, Defining schemas, Defining schemas

about, MongoDB

defining schemas, Defining schemas, Defining schemas

Mongoose library, Mongoose, Performance

native MongoDB driver, MongoDB native driver

writing records, Writing records

Mongoose library, Mongoose, Installation, Defining schemas, Defining schemas, Manipulating collections, Performance

about, Mongoose

defining schemas, Defining schemas, Defining schemas

installing, Installation

manipulating collections, Manipulating collections

performance considerations, Performance

MQ protocols, MQ Protocols, RabbitMQ, Work queues

about, MQ Protocols

RabbitMQ, RabbitMQ, Work queues

multicore processors, Using Multiple Processors, Using Multiple Processors

MVCC (multi-version concurrency control), CouchDB

MX (mail exchanger) records, DNS

MySQL database system, MySQL, Using NodeDB, Deletion, Sequelize, PostgreSQL

about, MySQL

node-db module, Using NodeDB, Deletion

Sequelize ORM, Sequelize, PostgreSQL

N

namespaces, Socket.IO library, Namespaces, Namespaces

nesting callbacks, Ordered serial I/O, Filesystem

net module, Building a Chat Server, Building a Chat Server, Building a Chat Server, Building a Chat Server, Building a Chat Server, Building a Chat Server

about, Building a Chat Server

createServer() method, Building a Chat Server

Server class, Building a Chat Server

Socket class, Building a Chat Server, Building a Chat Server, Building a Chat Server

new keyword, EventEmitter

Node module, Installing CouchDB’s Node module, Using node-couchdb, Installing Redis’s Node module

CouchDB database, Installing CouchDB’s Node module, Using node-couchdb

Redis key-value store, Installing Redis’s Node module

Node Package Manager, Let’s Build Twitter (see npm)

Node REPL, Node REPL, Node REPL

node-couchdb package, Using node-couchdb, Working with databases, Creating documents, Reading documents, Updating documents, Deleting documents

about, Using node-couchdb

creating documents, Creating documents

deleting documents, Deleting documents

reading documents, Reading documents

updating documents, Updating documents

working with databases, Working with databases

node-db module, Using NodeDB, Installation, Selection, Insertion, Updating, Deletion, Connection Pooling

about, Using NodeDB

connection pooling and, Connection Pooling

deleting data, Deletion

inserting data, Insertion

installing, Installation

selecting data, Selection

updating data, Updating

Node.js, A Very Brief Introduction to Node.js, A Very Brief Introduction to Node.js, Installing Node.js, Installing Node.js, Installing Node.js, Node REPL, Node REPL, A First Server, A First Server, Why Node?, Browser Wars 2.0, High-Performance Web Servers, Building a Chat Server, Building a Chat Server, Let’s Build Twitter, Let’s Build Twitter, Building Robust Node Applications, Using Multiple Processors, Core APIs, console.log, Modules, Add-ons

about, A Very Brief Introduction to Node.js, A Very Brief Introduction to Node.js

building chat server, Building a Chat Server, Building a Chat Server

building robust applications, Building Robust Node Applications, Using Multiple Processors

building Twitter-like application, Let’s Build Twitter, Let’s Build Twitter

core APIs, Core APIs, console.log

extending, Modules, Add-ons

installing, Installing Node.js, Installing Node.js

as runtime environment, Node REPL, Node REPL

strengths of, Why Node?, Browser Wars 2.0

version numbers, Installing Node.js

as web servers, A First Server, A First Server, High-Performance Web Servers

nonblocking operations, The Event Loop, The Event Loop, Error Handling, I/O, console.log, Glossary

API support, I/O, console.log

defined, Glossary

error handling and, Error Handling

event-driven programming and, The Event Loop

Node approach, The Event Loop

NoSQL systems, CouchDB, Deleting documents, Redis, Securing Redis, MongoDB, Performance

CouchDB database, CouchDB, Deleting documents

MongoDB database, MongoDB, Performance

Redis key-value store, Redis, Securing Redis

npm (Node Package Manager), Let’s Build Twitter, Installation, Installation, Package Manager, Searching Packages, Searching Packages, Creating Packages, Creating Packages, Creating Packages, Publishing Packages, Publishing Packages, Publishing Packages, Publishing Packages, Linking, Linking

about, Package Manager

adduser command, Publishing Packages

creating packages, Creating Packages

init command, Creating Packages

install command, Creating Packages

installing db-mysql package, Installation

installing Express module, Let’s Build Twitter

installing Mongoose library, Installation

link command, Linking

linking dependencies, Linking

publish command, Publishing Packages

publishing packages, Publishing Packages

search command, Searching Packages

searching packages, Searching Packages

unpublish command, Publishing Packages

O

object relational mapper (ORM), Sequelize, PostgreSQL

objects, Node REPL, Ordered serial I/O, Hashes

passing by reference, Ordered serial I/O

setting and enumerating, Node REPL

setting multiple hash values, Hashes

onclick event, A Very Brief Introduction to Node.js

OpenSSL, Installing Node.js, Crypto, HMAC, Public Key Cryptography

cryptography and, Installing Node.js, Crypto

PEM-encoded keys, HMAC, Public Key Cryptography

ordered serial I/O, Ordered serial I/O, Ordered serial I/O

ORM (object relational mapper), Sequelize, PostgreSQL

os module, Using Multiple Processors

P

parallel I/O, The I/O Problem Space, Unordered parallel I/O

combining work groups, The I/O Problem Space

unordered, Unordered parallel I/O

passing objects by reference, Ordered serial I/O

password authentication (Redis), Securing Redis

patterns, The Event Loop, The I/O Problem Space, Ordered serial I/O, Readable streams, Filesystem, Middleware factories, Middleware factories

about, Filesystem

event loop and, The Event Loop

I/O considerations, The I/O Problem Space, Ordered serial I/O

middleware factories, Middleware factories, Middleware factories

spooling, Readable streams

PEM-encoded keys, HMAC, Public Key Cryptography

period (.), Node REPL

pg_config utility, Installation

POST verb (HTTP), Uploading data for HTTP POST and PUT, querystring, Handling Form Data

PostgreSQL database system, PostgreSQL, Installation, Selection, Insertion, updates, and deletion, Insertion, updates, and deletion, Insertion, updates, and deletion

about, PostgreSQL

deleting data, Insertion, updates, and deletion

inserting data, Insertion, updates, and deletion

installing, Installation

selecting data, Selection

updating data, Insertion, updates, and deletion

private keys, Public Key Cryptography

process module, HMAC, process Module, process events, process events, process events, Interacting with the current Node process, Interacting with the current Node process, Interacting with the current Node process, Interacting with the current Node process, Interacting with the current Node process, Interacting with the current Node process, Interacting with the current Node process, Interacting with the current Node process, Interacting with the current Node process, Interacting with the current Node process, Interacting with the current Node process, Interacting with the current Node process, Interacting with the current Node process, Interacting with the current Node process, Operating system input/output, Operating system input/output, Operating system input/output, process.stdin, process.stdin, process.stderr, process.stderr, Event loop and tickers, Event loop and tickers, Event loop and tickers, Event loop and tickers, Event loop and tickers, child_process.exec( ), child_process.spawn( )

about, process Module

argv property, process.stderr, child_process.spawn( )

chdir() method, Interacting with the current Node process

cwd() method, Interacting with the current Node process, child_process.exec( )

event loop and tickers, Event loop and tickers, Event loop and tickers

execPath property, Interacting with the current Node process

exit event, process events

getgid() method, Interacting with the current Node process

installPrefix property, Interacting with the current Node process

memoryUsage() method, Interacting with the current Node process

nextTick() method, Event loop and tickers, Event loop and tickers

PEM-encoded keys and, HMAC

pid property, Interacting with the current Node process

platform property, Interacting with the current Node process

setgid() method, Interacting with the current Node process, Interacting with the current Node process

setuid() method, Interacting with the current Node process

stderr property, Operating system input/output, process.stderr

stdin property, Operating system input/output, process.stdin

stdout property, Operating system input/output, process.stdin

title property, Interacting with the current Node process

uncaughtException event, process events, process events, Event loop and tickers

uptime() method, Interacting with the current Node process

version property, Interacting with the current Node process

profiler middleware, Middleware

ps command, Interacting with the current Node process

pseudoclasses (term), HTTP, Glossary

public key cryptography, Public Key Cryptography, Encrypting with Cipher, Decrypting with Decipher, Creating signatures using Sign, Verifying signatures with Verify

about, Public Key Cryptography

creating signatures using Sign class, Creating signatures using Sign

decrypting with Decipher class, Decrypting with Decipher

encrypting with Cipher class, Encrypting with Cipher

verifying signatures with Verify class, Verifying signatures with Verify

publishing, Subscriptions, Publish and subscribe, Publish and subscribe, Publishing Packages

packages, Publishing Packages

RabbitMQ message broker, Publish and subscribe, Publish and subscribe

Redis key-value store and, Subscriptions

PUT verb (HTTP), Uploading data for HTTP POST and PUT, Using CouchDB over HTTP, Handling Form Data

pyramid code, Ordered serial I/O

Q

q.shift() command, Work queues

query middleware, Middleware

querystring module, querystring, querystring, querystring, querystring, querystring, querystring, querystring, querystring, querystring, querystring, querystring

about, querystring, querystring

decode() method, querystring

encode() method, querystring, querystring

escape() method, querystring

parse() method, querystring, querystring

stringify() method, querystring

unescape() method, querystring

unescapeBuffer() method, querystring

queues, RabbitMQ message broker and, Work queues, Work queues

R

RabbitMQ message broker, RabbitMQ, Installing RabbitMQ, Publish and subscribe, Publish and subscribe, Publish and subscribe, Publish and subscribe, Work queues, Work queues

about, RabbitMQ

createConnection command, Publish and subscribe

installing, Installing RabbitMQ

publishing and subscribing, Publish and subscribe, Publish and subscribe

subscribe command, Publish and subscribe

work queues, Work queues, Work queues

Read-Evaluate-Print-Loop (REPL), Node REPL, Node REPL

ReadableStream class, Readable streams, process.stdin

about, Readable streams

pipe() method, process.stdin

Redis key-value store, Redis, Installation, Basic usage, Basic usage, Basic usage, Basic usage, Hashes, Hashes, Hashes, Hashes, Lists, Lists, Lists, Sets, Sets, Sorted sets, Sorted sets, Sorted sets, Subscriptions, Securing Redis, Securing Redis

about, Redis

auth command, Securing Redis

basic usage, Basic usage

get command, Basic usage

hashes and, Hashes, Hashes

hmset command, Hashes

hset command, Basic usage, Hashes

installing, Installation

list commands, Lists

lpush command, Lists

password authentication, Securing Redis

rpop command, Lists

sadd command, Sets

set command, Basic usage

smembers command, Sets

subscribe command, Subscriptions

zadd command, Sorted sets

zcard command, Sorted sets

zrange command, Sorted sets

reference, passing by, Ordered serial I/O

RegExp class, Testing Through assert, Setting Up Routes in Express

match() method, Setting Up Routes in Express

test() method, Testing Through assert

regular expressions, Testing Through assert, Setting Up Routes in Express

defining routes, Setting Up Routes in Express

testing through assert, Testing Through assert

relational databases, MySQL, Sequelize, PostgreSQL, Insertion, updates, and deletion

MySQL, MySQL, Sequelize

PostgreSQL, PostgreSQL, Insertion, updates, and deletion

removeDoc command, Deleting documents

REPL (Read-Evaluate-Print-Loop), Node REPL, Node REPL

request event, The Event Loop, Callback Syntax, Callback Syntax

require() function, A First Server, HTTP Servers

Resig, John, Professionalism in JavaScript

response event, The Event Loop, HTTP Clients

responseTime middleware, Middleware

RIPEMD160 hashing algorithm, Hashing

root user, Installing Node.js

router middleware, Middleware

routes, Setting Up Routes in Express, Setting Up Routes in Express, Setting Up Routes in Express, Setting Up Routes in Express, Middleware factories

Express module and, Setting Up Routes in Express, Setting Up Routes in Express, Middleware factories

passing control to, Setting Up Routes in Express

wildcards in, Setting Up Routes in Express

rpop command (Redis), Lists

runtime environment, Node REPL, Node REPL

Russell, Alex, Professionalism in JavaScript

S

sadd command (Redis), Sets

.sass files, Middleware

saveDoc command, Updating documents

schemas, Defining schemas, Defining schemas, Sequelize

MongoDB and, Defining schemas, Defining schemas

Sequelize and, Sequelize

Script class, VM, VM, VM

about, VM, VM

runInNewContext() method, VM

Separation of Concerns (SoC) paradigm, Using Socket.IO with Express

Sequelize object relational mapper, Sequelize, PostgreSQL

serial I/O, The I/O Problem Space, Ordered serial I/O, Ordered serial I/O

combining work groups, The I/O Problem Space

ordered, Ordered serial I/O, Ordered serial I/O

Server class (http module), HTTP Servers, HTTP Servers, HTTP Servers, HTTP Servers, HTTP Servers, HTTP Servers, HTTP Servers

about, HTTP Servers

checkContinue event, HTTP Servers

clientError event, HTTP Servers

close event, HTTP Servers

connection event, HTTP Servers

listen() method, HTTP Servers

upgrade event, HTTP Servers

Server class (net module), Building a Chat Server, Building a Chat Server

connection event, Building a Chat Server

listen() method, Building a Chat Server

ServerResponse class, A First Server, A First Server

end() method, A First Server

writeHead() method, A First Server

service (SRV) records, DNS

session middleware, Middleware, Using Socket.IO with Express, Using Socket.IO with Express

about, Middleware, Using Socket.IO with Express

save() method, Using Socket.IO with Express

.set command (MySQL), Updating

set command (Redis), Basic usage

SHA1 hashing algorithm, Crypto, Hashing

SHA256 hashing algorithm, Hashing

SHA512 hashing algorithm, Hashing

SIGINT interrupt signal, process events

SIGKILL interrupt signal, child_process.exec( )

Sign class, Public Key Cryptography, Creating signatures using Sign, Creating signatures using Sign, Creating signatures using Sign

about, Public Key Cryptography, Creating signatures using Sign

sign() method, Creating signatures using Sign

update() method, Creating signatures using Sign

SIGTERM interrupt signal, child_process.exec( )

single-threaded concept, The Event Loop, Writing Code for Production, Using Multiple Processors, Using Multiple Processors

about, The Event Loop

multiple processor usage and, Using Multiple Processors, Using Multiple Processors

writing code for production, Writing Code for Production

smembers command (Redis), Sets

SoC (Separation of Concerns) paradigm, Using Socket.IO with Express

Socket class, Building a Chat Server, Building a Chat Server, Building a Chat Server, Building a Chat Server, Building a Chat Server, Socket.IO, Socket.IO, Using Socket.IO with Express, Using Socket.IO with Express

accept() method, Using Socket.IO with Express

connect() method, Socket.IO

destroy() method, Building a Chat Server

end() method, Building a Chat Server

handshake property, Using Socket.IO with Express

listen() method, Socket.IO

remoteAddress property, Building a Chat Server

remotePort property, Building a Chat Server

write() method, Building a Chat Server

Socket.IO library, Socket.IO, Socket.IO, Namespaces, Namespaces, Using Socket.IO with Express, Using Socket.IO with Express

about, Socket.IO, Socket.IO

Express module and, Using Socket.IO with Express, Using Socket.IO with Express

namespaces and, Namespaces, Namespaces

sorted sets, Sorted sets

spooling pattern, Readable streams

SRV (service) records, DNS

static middleware, Middleware

staticCache middleware, Middleware

STDERR error stream, Operating system input/output, process.stderr, Child Process, child_process.spawn( )

child_process module and, Child Process, child_process.spawn( )

process module and, Operating system input/output, process.stderr

STDIN input stream, Operating system input/output, process.stdin, Child Process, child_process.exec( ), child_process.spawn( )

child_process module and, Child Process, child_process.exec( ), child_process.spawn( )

process module and, Operating system input/output, process.stdin

STDOUT output stream, Operating system input/output, process.stdin, Child Process, child_process.exec( ), child_process.spawn( )

child_process module and, Child Process, child_process.exec( ), child_process.spawn( )

process module and, Operating system input/output, process.stdin

Stonebraker, Michael, PostgreSQL

stream API, Streams, Readable streams, process.stdin, process.stderr

about, Streams

ReadableStream class, Readable streams, process.stdin

WritableStream class, process.stderr

strings, Binary and strings, Working with strings, Working with strings

binary data and, Binary and strings

working with, Working with strings, Working with strings

subscribe command, Subscriptions, Publish and subscribe

RabbitMQ message broker, Publish and subscribe

Redis key-value store, Subscriptions

subscribing, Subscriptions, Publish and subscribe, Publish and subscribe

RabbitMQ message broker, Publish and subscribe, Publish and subscribe

Redis key-value store, Subscriptions

sudo command, Installing Node.js

T

tables, creating in CouchDB, Working with databases

tar command, Installing Node.js, Installing Node.js, Installing Node.js

f flag, Installing Node.js

x flag, Installing Node.js

z flag, Installing Node.js

TCP servers, Building a Chat Server, Building a Chat Server, Building a Chat Server, Building a Chat Server, Building a Chat Server, Building a Chat Server, Building a Chat Server, Building a Chat Server, Building a Chat Server, Building a Chat Server, Building a Chat Server, Building a Chat Server

causing failure by disconnecting clients, Building a Chat Server

checking writing status of sockets, Building a Chat Server

communicating between clients, Building a Chat Server

connecting to, Building a Chat Server

creating, Building a Chat Server

improving message sending, Building a Chat Server

listening to connections, Building a Chat Server

logging errors, Building a Chat Server

making more robust, Building a Chat Server

running improved, Building a Chat Server

sending data from Telnet, Building a Chat Server

sending messages between clients, Building a Chat Server

Telnet, Building a Chat Server, Building a Chat Server

connecting TCP servers with, Building a Chat Server

sending data to servers, Building a Chat Server

template engines, Template Engines, Template Engines, Layouts and partial views, Layouts and partial views

about, Template Engines, Template Engines

layouts and partial views, Layouts and partial views, Layouts and partial views

testing APIs, Let’s Build Twitter

text (TXT) records, DNS

try/catch block, Error Handling

Twitter-like application, Let’s Build Twitter, Let’s Build Twitter, Let’s Build Twitter, Let’s Build Twitter, Let’s Build Twitter, Let’s Build Twitter, Let’s Build Twitter, Let’s Build Twitter, Let’s Build Twitter, Let’s Build Twitter, Let’s Build Twitter, Let’s Build Twitter, Let’s Build Twitter

about, Let’s Build Twitter

adding basic API, Let’s Build Twitter

basic web server in, Let’s Build Twitter

checking accept header, Let’s Build Twitter

EJS layout file, Let’s Build Twitter

folder structure, Let’s Build Twitter

installing Express module, Let’s Build Twitter

redirecting browsers, Let’s Build Twitter

rendering chirps, Let’s Build Twitter

rendering index template, Let’s Build Twitter

rendering stylesheets, Let’s Build Twitter

showing tweets, Let’s Build Twitter

testing APIs, Let’s Build Twitter

TXT (text) records, DNS

U

uncaughtException event, process events, process events, Event loop and tickers

unordered parallel I/O, Unordered parallel I/O

.update command (MySQL), Updating, Deletion

upgrade event, HTTP Servers

URL module, URL, URL, URL, URL, URL, querystring

about, URL

format() method, URL

parse() method, URL, URL

querystring module and, querystring

resolve() method, URL

UTF-8 encoding format, A quick primer on binary, Using Buffers

util module, EventEmitter, EventEmitter

about, EventEmitter

inherits() method, EventEmitter

V

V8 JavaScript runtime, A Very Brief Introduction to Node.js, Node REPL, A First Server

about, A Very Brief Introduction to Node.js, A First Server

Node REPL and, Node REPL

Verify class, Public Key Cryptography, Verifying signatures with Verify, Verifying signatures with Verify, Verifying signatures with Verify

about, Public Key Cryptography, Verifying signatures with Verify

update() method, Verifying signatures with Verify

verify() method, Verifying signatures with Verify

version numbers (Node.js), Installing Node.js

vhost middleware, Middleware

view engines, Template Engines, Layouts and partial views

mixing and matching, Template Engines

turning into real websites, Layouts and partial views

vm module, VM, VM, VM, VM, VM, VM, VM

about, VM, VM

runInNewContext() method, VM, VM

runInThisContext() method, VM

Script class, VM, VM

W

web applications, Building a Chat Server, Building a Chat Server, Let’s Build Twitter, Let’s Build Twitter, The Event Loop, The Event Loop, Patterns, Ordered serial I/O, Writing Code for Production, Using Multiple Processors

building chat server, Building a Chat Server, Building a Chat Server

building Twitter-like app, Let’s Build Twitter, Let’s Build Twitter

event loop, The Event Loop, The Event Loop

patterns, Patterns, Ordered serial I/O

writing code for production, Writing Code for Production, Using Multiple Processors

web browsers, Professionalism in JavaScript, Browser Wars 2.0, Let’s Build Twitter, Socket.IO

browser wars, Browser Wars 2.0

HTML5 WebSockets standard, Socket.IO

JavaScript support, Professionalism in JavaScript

redirecting from endpoint, Let’s Build Twitter

web servers, A First Server, A First Server, High-Performance Web Servers, Let’s Build Twitter, HTTP

about, A First Server, A First Server, HTTP

Express module support, Let’s Build Twitter

high-performance, High-Performance Web Servers

.where command (MySQL), Updating

wildcard in routes, Setting Up Routes in Express

work distribution example, Using Multiple Processors, Using Multiple Processors

work queues, RabbitMQ, Work queues, Work queues

WritableStream.write() method, process.stderr

writing code for production, Writing Code for Production, Error Handling, Using Multiple Processors, Using Multiple Processors

about, Writing Code for Production

error handling, Error Handling

multiple processor usage, Using Multiple Processors, Using Multiple Processors

X

X-Response-Time header, Middleware

Z

zadd command (Redis), Sorted sets

zcard command (Redis), Sorted sets

zombie workers, killing, Using Multiple Processors

zrange command (Redis), Sorted sets