Index

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, Core APIs
(see also specific APIs)
adding, Let’s Build Twitter
core, Core APIs, console.log
helper, Helper APIs, VM
testing, Let’s Build Twitter
applications (see web applications)
apt command, Installation
ASCII encoding format, A quick primer on binary, Using Buffers
assert module
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
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
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 (see web browsers)
BSON object storage, MongoDB
Buffer class
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
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
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
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
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
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
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
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 (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
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
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
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
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
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
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
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
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
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
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
about, process events
calling, Callback Syntax
creating for events, EventEmitter
firing, EventEmitter
event loop
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
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
about, EventEmitter
emit() method, EventEmitter, Callback Syntax
on() method, EventEmitter
process module and, process events
stream support, Streams
events, EventEmitter
(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
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
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
deleting, Filesystem
reading, Filesystem
filesystem module (see fs module)
first-in-first-out (FIFO) queue, Lists
fs module
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
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
digest() method, Hashing, Hashing
update() method, Hashing, Hashing
Hash-based Message Authentication Code (HMAC), Crypto, HMAC, HMAC
hashes and hashing algorithms
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
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
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
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 I/O Problem Space
(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
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
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

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
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
about, MongoDB
defining schemas, Defining schemas, Defining schemas
Mongoose library, Mongoose, Performance
native MongoDB driver, MongoDB native driver
writing records, Writing records
Mongoose library
about, Mongoose
defining schemas, Defining schemas, Defining schemas
installing, Installation
manipulating collections, Manipulating collections
performance considerations, Performance
MQ protocols
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
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
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
CouchDB database, Installing CouchDB’s Node module, Using node-couchdb
Redis key-value store, Installing Redis’s Node module
Node Package Manager (see npm)
Node REPL, Node REPL, Node REPL
node-couchdb package
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
about, Using NodeDB
connection pooling and, Connection Pooling
deleting data, Deletion
inserting data, Insertion
installing, Installation
selecting data, Selection
updating data, Updating
Node.js
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
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 database, CouchDB, Deleting documents
MongoDB database, MongoDB, Performance
Redis key-value store, Redis, Securing Redis
npm (Node Package Manager)
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
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
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
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
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
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
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
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
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
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
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
about, Readable streams
pipe() method, process.stdin
Redis key-value store
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
match() method, Setting Up Routes in Express
test() method, Testing Through assert
regular expressions
defining routes, Setting Up Routes in Express
testing through assert, Testing Through assert
relational databases
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
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
MongoDB and, Defining schemas, Defining schemas
Sequelize and, Sequelize
Script class
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
combining work groups, The I/O Problem Space
ordered, Ordered serial I/O, Ordered serial I/O
Server class (http module)
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)
connection event, Building a Chat Server
listen() method, Building a Chat Server
ServerResponse class
end() method, A First Server
writeHead() method, A First Server
service (SRV) records, DNS
session middleware
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
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
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
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
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
child_process module and, Child Process, child_process.spawn( )
process module and, Operating system input/output, process.stderr
STDIN input stream
child_process module and, Child Process, child_process.exec( ), child_process.spawn( )
process module and, Operating system input/output, process.stdin
STDOUT output stream
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
about, Streams
ReadableStream class, Readable streams, process.stdin
WritableStream class, process.stderr
strings
binary data and, Binary and strings
working with, Working with strings, Working with strings
subscribe command
RabbitMQ message broker, Publish and subscribe
Redis key-value store, Subscriptions
subscribing
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
f flag, Installing Node.js
x flag, Installing Node.js
z flag, Installing Node.js
TCP servers
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
connecting TCP servers with, Building a Chat Server
sending data to servers, Building a Chat Server
template engines
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
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
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
about, EventEmitter
inherits() method, EventEmitter

V

V8 JavaScript runtime
about, A Very Brief Introduction to Node.js, A First Server
Node REPL and, Node REPL
Verify class
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
mixing and matching, Template Engines
turning into real websites, Layouts and partial views
vm module
about, VM, VM
runInNewContext() method, VM, VM
runInThisContext() method, VM
Script class, VM, VM

W

web applications
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
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
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
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