Index
A
- abstract interface
- about / Exploring streams
- add-ons
- URL, for examples / Links and resources
- Add method / Creating a calculator
- AJAX / The Network
- Apache Bench (ab)
- about / Network latency
- application scaling
- about / When to scale?
- network latency / Network latency
- CPU usage, measuring / Hot CPUs
- socket usage / Socket usage
- file descriptors / Many file descriptors
- data creep / Data creep
- monitoring server tools / Tools for monitoring servers
- ASCII characters
- ASCII codes, converting to / Transforming streams
- ASCII codes
- converting, to ASCII characters / Transforming streams
- assert module
- about / The assert module
- asynchronous context
- about / Errors and exceptions
- AWS
- using, in application / Using Amazon Web Services in your application
- authenticating / Authenticating
- errors / Errors
- S3, using for storing files / Using S3 to store files
- using, with Node server / Using AWS with a Node server
- data, setting with DynamoDB / Getting and setting data with DynamoDB
- e-mail, sending via SES / Sending mail via SES
B
- bind command
- arguments / Using Node's UDP module
- blocking process / Broadcasting events
- bouncy module / Using HTTP Proxy
- browser testing
- performing / Headless web testing
- performing, ZombieJS used / Headless web testing
- buckets
- working with / Working with buckets
- bundledDependencies / Declaring dependencies
- bundling / Achieving a modular architecture
C
- .cc extension / Hello World
- C++
- URL / Links and resources
- C++ add-ons
- Hello World, building / Hello World
- calculator, creating / Creating a calculator
- callbacks, implementing / Implementing callbacks
- C++ modules
- linking, with Node program / Closing thoughts
- caching / Achieving a modular architecture
- calculator
- creating / Creating a calculator
- callbacks
- implementing / Implementing callbacks
- child process communication, event sources
- child processes
- creating / Creating child processes
- spawning / Spawning processes
- forking / Forking processes
- output, buffering / Buffering process output
- communicating with / Communicating with your child
- messages, sending / Sending messages to children
- CLI (Command-Line Interface) / fs.write(fd, buffer, offset, length, position, callback)
- click event / Sending and receiving
- client-server state
- managing / Managing state
- issues / Managing state
- client/server divide
- bridging / Bridging the client/server divide
- cluster module
- used, for parsing file / Using the cluster module
- cluster object
- events / Cluster events
- fork event / Cluster events
- online event / Cluster events
- listening event / Cluster events
- disconnect event / Cluster events
- exit event / Cluster events
- setup event / Cluster events
- communication / Achieving a modular architecture
- concurrency
- connections
- authenticating / Authenticating connections
- basic authentication / Basic authentication
- handshaking / Handshaking
- console.timeEnd method
- about / Writing to the console
- console.time method
- about / Writing to the console
- console output
- about / Writing to the console
- formatting / Formatting console output
- util.format() method / The util.format(format, [arg, arg…]) method
- util.inspect() method / The util.inspect(object, [options]) method
- content types
- about / Understanding content types
- conventions, Node community / Conventions
- convert operation / Creating and streaming images with Node
- cookies
- about / Using cookies
- using / Using cookies
- ctime standard library / Implementing callbacks
- cwd (String) / Spawning processes
- cwd (String) parameter / Forking processes
D
- D3.js library
- data binding / Achieving a modular architecture
- datagrams
- about / Using Node's UDP module
- db.stats() command / Data creep
- deferred event sources
- execution blocks / Four sources of truth
- timers / Four sources of truth
- I/O / Four sources of truth
- deferred execution blocks / Four sources of truth
- deferred execution, event sources
- about / Deferred execution
- process.nextTick / process.nextTick
- dependencies / Declaring dependencies
- detached (Boolean) / Spawning processes
- devDependencies / Declaring dependencies
- digital streams
- about / Exploring streams
- direct exchange
- about / Types of exchanges
- directives
- list / Using scripts
- directories
- about / Moving through directories
- nested directories, moving through / Moving through directories
- DOM (Document Object Model) / Creating and streaming images with Node
- domain.bind method
- about / The domain module
- domain module
- about / The domain module
- duplex streams
- about / Duplex streams
- DynamoDB
- about / Getting and setting data with DynamoDB
- table, creating / Getting and setting data with DynamoDB
- database, searching / Searching the database
E
- encapsulation / Achieving a modular architecture
- encoding (String) parameter / Forking processes
- Encryption and Compression modules
- ZLIB / Loading and using modules
- Crypto / Loading and using modules
- PunyCode / Loading and using modules
- ENOENT (no entity) error / File events
- env (Object) / Spawning processes
- env (Object) parameter / Forking processes
- error handling
- about / Errors and exceptions
- errors
- about / Errors and exceptions
- ES6 (EcmaScript6) / V8
- ES6 Harmony / Harmony
- event API / Events
- event context
- about / Errors and exceptions
- event loop
- about / Understanding the event loop
- events
- about / Events
- event listeners, removing / Events
- listening for / Listening for events
- events, broadcasting
- collaboration / Collaboration
- queueing / Queueing
- event sources
- deferred execution / Listening for events
- signals / Signals
- child process communication / Forks
- filesystem change events / File events
- exception handling
- about / Errors and exceptions
- exceptions
- about / Errors and exceptions
- exchange publisher / Message queues – RabbitMQ
- exchange queue subscriber / Message queues – RabbitMQ
- exchanges, types
- direct exchange / Types of exchanges
- fanout exchange / Types of exchanges
- topic exchange / Types of exchanges
- exec method
- about / Buffering process output
- command argument / Buffering process output
- options argument / Buffering process output
- callback argument / Buffering process output
- execPath (String) parameter / Forking processes
F
- 403* Forbidden errors / Errors
- Facebook Connect
- used, for authenticating / Authenticating with Facebook Connect
- fail_timeout directive / Nginx as a proxy
- fanout exchange
- about / Types of exchanges
- favicon requests
- handling / Handling favicon requests
- file
- reading from / Reading from a file
- byte by byte, reading / Reading byte by byte
- fetching, at once / Fetching an entire file at once
- readable stream, creating / Creating a readable stream
- line by line, reading / Reading a file line by line
- writing to / Writing to a file
- byte by byte, writing / Writing byte by byte
- large chunks of data, writing / Writing large chunks of data
- writable stream, creating / Creating a writable stream
- caveats / Caveats
- parsing, multiple child processes used / Parsing a file using multiple processes
- parsing, cluster module used / Using the cluster module
- file changes
- listening for / Listening for file changes
- file events, event sources
- about / File events
- file paths
- path.normalize / File paths
- path.join / File paths
- path.dirname / File paths
- path.basename / File paths
- path.extname / File paths
- path.relative / File paths
- path.resolve / File paths
- filesystem
- directories / Directories, and iterating over files and folders, Moving through directories
- file types / Types of files
- file paths / File paths
- file attributes / File attributes
- files, opening / Opening and closing files
- files, closing / Opening and closing files
- file operations / File operations
- sSynchronicity / Synchronicity
- file types, filesystem
- ordinary files / Types of files
- directories / Types of files
- sockets / Types of files
- named pipe / Types of files
- device files / Types of files
- links / Types of files
- file uploads
- handling / Handling file uploads
- fork
- about / Forking processes
- parameters / Forking processes
- fork method / Forks
- fork processes / Forks
- forward proxy
- about / Forward and reverse proxies
- fs.appendFile(path, data, [options], callback) method
- fs.chmod(path, mode, callback) method / fs.chmod(path, mode, callback)
- fs.chown(path, uid, gid, callback) method / fs.chown(path, uid, gid, callback)
- fs.close(fd, callback) method / fs.close(fd, callback)
- fs.createReadStream(path, [options]) method / fs.createReadStream(path, [options])
- fs.createWriteStream(path, [options]) method
- fs.exists(path, callback) method / fs.exists(path, callback)
- fs.fchmod(fd, mode, callback) method / fs.fchmod(fd, mode, callback)
- fs.fchown(fd, uid, gid, callback) method / fs.fchown(fd, uid, gid, callback)
- fs.fsync(fd, callback) method / fs.fsync(fd, callback)
- fs.ftruncate(fd, len, callback) method / fs.ftruncate(fd, len, callback)
- fs.futimes() method / File attributes
- fs.lchmod(path, mode, callback) method / fs.lchmod(path, mode, callback)
- fs.lchown(path, uid, gid, callback) method / fs.lchown(path, uid, gid, callback)
- fs.link(srcPath, dstPath, callback) method / fs.link(srcPath, dstPath, callback)
- fs.mkdir(path, [mode], callback) method / fs.mkdir(path, [mode], callback)
- fs.open() method / fs.open(path, flags, [mode], callback)
- fs.open(path, flags, [mode], callback) method / fs.open(path, flags, [mode], callback)
- fs.read(fd, buffer, offset, length, position, callback) method / fs.read(fd, buffer, offset, length, position, callback)
- fs.readFile(path, [options], callback) method / fs.readFile(path, [options], callback)
- fs.readlink(path, callback) method / fs.readlink(path, callback)
- fs.realpath(path, [cache], callback) method / fs.realpath(path, [cache], callback)
- fs.rename(oldName, newName, callback) method / fs.rename(oldName, newName, callback)
- fs.rmdir(path, callback) method / fs.rmdir(path, callback)
- fs.Stats object / File attributes
- fs.symlink(srcPath, dstPath, [type], callback) method / fs.symlink(srcPath, dstPath, [type], callback)
- fs.truncate(path, len, callback) method / fs.truncate(path, len, callback)
- fs.unlink(path, callback) method / fs.unlink(path, callback)
- fs.utimes() method / File attributes
- fs.write(fd, buffer, offset, length, position, callback) method / fs.write(fd, buffer, offset, length, position, callback)
- fs.writeFile(path, data, [options], callback) method
- functional tests
- about / Functional tests
G
- GC (Garbage Collection) / Memory and other limits
- gid (Number) / Spawning processes
- Grunt
H
- Harmony / V8
- harmony
- hashtag #nodejs / Listening for file changes
- headers
- working with / Working with headers
- Hello World
- building / Hello World
- htop
- about / Hot CPUs
- HTTP
- about / Creating an HTTP server
- HTTP proxy
- about / Using HTTP Proxy
- HTTP Proxy
- using / Using HTTP Proxy
- HTTP requests
- making / Making HTTP requests
- HTTPS
- HTTP server
- creating / Creating an HTTP server
I
- I/O bound / Broadcasting events
- I/O events
- about / Broadcasting events
- idle process / Broadcasting events
- ImageMagick / Creating and streaming images with Node
- images
- streaming, with Node / Creating and streaming images with Node
- installation, SSL certificate / Installing a real SSL certificate
- integration tests
- about / Integration tests
- Inter-Process Communication (IPC) / Signals
J
- JavaScript
- extending / Extending JavaScript
- JavaScript event model
- events / Events
- modularity / Modularity
- network / The Network
- jsdom package / Creating and streaming images with Node
K
- KB (Kilobytes) / Memory and other limits
L
- libuv / Multithreading is already native and transparent
- listenng event / UDP multicasting with Node
- logproc folder / Parsing a file using multiple processes
M
- max_fails directive / Nginx as a proxy
- MIME
- about / Understanding content types
- Mocha
- URL / Headless website testing with ZombieJS and Mocha
- about / Mocha
- used, for browser testing / Mocha
- integrating, with ZombieJS / Headless web testing
- modular architecture, Path Framework
- achieving / Achieving a modular architecture
- module
- paths, resolving / Resolving module paths
- module.children property / Understanding the module object
- module.filename property / Understanding the module object
- module.loaded property / Understanding the module object
- module.parent property / Understanding the module object
- module loading system
- key goals / Achieving a modular architecture
- module object
- about / Understanding the module object
- module.filename property / Understanding the module object
- module.filename properties / Understanding the module object
- module.loaded property / Understanding the module object
- module.parentTopicnproperty / Understanding the module object
- module.children property / Understanding the module object
- module paths
- resolving / Resolving module paths
- modules
- about / Loading and using modules
- Network and I/O / Loading and using modules
- Encryption and Compression / Loading and using modules
- Monit
- multicast
- about / Using Node's UDP module
- multiple child processes
- used, for parsing file / Parsing a file using multiple processes
- multiple Node servers
- running / Running multiple Node servers
- forward proxy / Forward and reverse proxies
- reverse proxy / Forward and reverse proxies
- Nginx, as proxy / Nginx as a proxy
- HTTP Proxy, using / Using HTTP Proxy
- multiprocess system
- constructing / Real-time activity updates of multiple worker results
- multithreading
- Munin
N
- Nagios
- network-path reference / The URL module
- Network and I/O modules
- TTY / Loading and using modules
- HTTP / Loading and using modules
- HTTPS / Loading and using modules
- Net / Loading and using modules
- DNS / Loading and using modules
- TLS/SSL / Loading and using modules
- Readline / Loading and using modules
- FileSystem / Loading and using modules
- UDP/Datagram / Loading and using modules
- Network Time Protocol (NTP) / Errors
- Nginx
- about / Nginx as a proxy
- using, as proxy / Nginx as a proxy
- wiki URL / Nginx as a proxy
- connection failures, managing / Nginx as a proxy
- Node
- used, for streaming images / Creating and streaming images with Node
- single-threaded model / Node's single-threaded model
- multithreading / Multithreading is already native and transparent
- URL, for add-ons / Links and resources
- node-amqp module
- about / Types of exchanges
- Node community
- conventions / Conventions
- error handling / Know your errors
- pyramids / Building pyramids
- guidelines / Considerations
- Node debugger
- about / The Node debugger
- NodeJitsu
- about / Using HTTP Proxy
- Node program
- Nodes standard library
- modules / Loading and using modules
- npm / Modularity
- using / Using npm
- package file, initializing / Initializing a package file
- scripts, using / Using scripts
- dependencies, declaring / Declaring dependencies
- packages, publishing / Publishing packages
- packages, installing globally / Globally installing packages and binaries
- repositories, sharing / Sharing repositories
- Number variable / Creating a calculator
O
- objects
- working with / Working with objects
- deleting / Working with objects
- multiple objects, deleting / Working with objects
- optionalDependencies / Declaring dependencies
- OS (Operating System) / Memory and other limits
- output tools
- util.debug(String) / Writing to the console
- util.error(String, [String ]) / Writing to the console
- util.puts(String, [String ]) / Writing to the console
- util.print(String, [String ]) / Writing to the console
- util.log(String) / Writing to the console
P
- package file
- initializing / Initializing a package file
- name / Initializing a package file
- version / Initializing a package file
- description / Initializing a package file
- entry point (main) / Initializing a package file
- keywords / Initializing a package file
- license / Initializing a package file
- parallelism
- about / Concurrency is not parallelism
- PassThrough streams
- using / Using PassThrough streams
- Path Framework
- calls, responding / Sending and receiving
- modular architecture, achieving / Achieving a modular architecture
- persistent (Boolean) / File events
- PhantomJS
- PNG (Portable Network Graphics) / Creating and streaming images with Node
- PNG representation
- Portable Operating System Interface (POSIX) signal / Signals
- POST data
- handling / Handling POST data
- preferGlobal property / Globally installing packages and binaries
- process.nextTick
- about / process.nextTick
- process ID (PID) / Signals
- process object
- about / The process object
- proxy
- about / Forward and reverse proxies
- proxying
- about / Proxying and tunneling
- publish command / Sending and receiving
- push operation
- about / Pushing and pulling
Q
- Querystring module
- about / The Querystring module
- queueing / Queueing
R
- RabbitMQ
- about / Message queues – RabbitMQ
- starting / Message queues – RabbitMQ
- interacting / Message queues – RabbitMQ
- consumer, creating / Message queues – RabbitMQ
- exchange, binding / Message queues – RabbitMQ
- types of exchanges / Types of exchanges
- Readable stream
- implementing / Implementing readable streams
- about / Implementing readable streams
- creating / Implementing readable streams
- push operation / Pushing and pulling
- Readline module
- about / The Readline module
- Redis
- using, for tracking client state / Using Redis for tracking client state
- user data, storing / Storing user data
- ref function / unref and ref
- REPL
- request object
- about / The request object
- URL module / The URL module
- Querystring module / The Querystring module
- requests
- routing / Routing requests
- routing, Express used / Using Express to route requests
- requests redirection, static files
- performing / Redirecting requests
- location / Location
- Content-Location / Content-Location
- resource caching, static files
- implementing / Implementing resource caching
- reverse proxy
- about / Forward and reverse proxies
- routes
- about / Understanding routes
- routing keys / Types of exchanges
- Rule of Separation / Multithreading is already native and transparent
S
- S3
- about / Using S3 to store files
- used, for storing files / Using S3 to store files
- buckets, working with / Working with buckets
- objects, working with / Working with objects
- sandboxing
- about / Sandboxing
- local scope, versus execution context / Distinguishing between local scope and execution context
- compiled contexts, using / Using compiled contexts
- Scout
- scripts
- using / Using scripts
- prepublish, publish, postpublish / Using scripts
- preinstall, install, postinstall / Using scripts
- preuninstall, uninstall, postuninstall / Using scripts
- preupdate, update, postupdate / Using scripts
- pretest, test, posttest / Using scripts
- prestop, stop, poststop / Using scripts
- prestart, start, poststart / Using scripts
- prerestart, restart, postrestart / Using scripts
- self-signed certificate
- creating, for development / Creating a self-signed certificate for development
- send method
- about / Using Node's UDP module
- server
- securing / HTTPS, TLS (SSL), and securing your server
- Server Sent Events (SSE) / Listening for file changes
- sessions handling
- about / Handling sessions
- cookies / Cookies and client state
- client state / Cookies and client state
- polling / A simple poll
- state, centralizing / Centralizing states
- setImmediate method
- about / setImmediate
- setInterval function / setInterval
- setMulticastTTL method / UDP multicasting with Node
- setTimeout function / setTimeout
- setTimeout method
- about / process.nextTick
- signal, event sources
- about / Signals
- Signals Intelligence (SIGINT) signal / Signals
- SIGUSR1 signal / Signals
- silent (Boolean) parameter / Forking processes
- single-threaded model
- about / Node's single-threaded model
- benefits / The benefits of single-threaded programming
- difficulties / The benefits of single-threaded programming
- spawn
- about / Spawning processes
- command argument / Spawning processes
- arguments / Spawning processes
- options / Spawning processes
- SSL/TLS protocol
- SSL certificate
- installing / Installing a real SSL certificate
- static files
- serving / Serving static files
- requests, redirecting / Redirecting requests
- resource caching, implementing / Implementing resource caching
- stdio (String or Array) / Spawning processes
- Stream Editor / Parsing a file using multiple processes
- Stream module
- about / Exploring streams
- Stream object
- about / Creating a readable stream
- streams
- exploring / Exploring streams
- transforming / Transforming streams
- StrongOps
- SVG (Scalable Vector Graphics) / Creating and streaming images with Node
- synchronous code / Synchronicity
- synchronous context
- about / Errors and exceptions
- synchronous operation / Synchronicity
T
- TCP (Transmission Control Protocol) server / The Read-Eval-Print Loop and executing a Node program
- templates / Achieving a modular architecture
- testing
- benefits / Why testing is important
- tests
- unit tests / Unit tests
- functional tests / Functional tests
- integration tests / Integration tests
- timers
- about / Timers
- setTimeout / setTimeout
- setInterval / setInterval
- unref method / unref and ref
- ref method / unref and ref
- TLS/SSL / The Network
- topic exchange
- about / Types of exchanges
- Transform stream
- about / Transforming streams
- TTY (TeleTYpewriter)
- about / The Readline module
- tunneling
- about / Proxying and tunneling
U
- UDP module
- about / Using Node's UDP module
- error event / Using Node's UDP module
- close event / Using Node's UDP module
- multicasting UDP, setting up with Node / UDP multicasting with Node
- UDP server
- creating, with Node / Using Node's UDP module
- uid (Number) / Spawning processes
- uncaughtException handler
- about / Errors and exceptions
- unit tests
- about / Unit tests
- unref function / unref and ref
- URL module
- about / The URL module
- util.format(format, [arg, arg ]) method
- util.format method / Formatting console output
- util.inspect(object, [options]) method
- util.inspect method / Formatting console output
V
- V8 / Hello World
- about / V8
- memory / Memory and other limits
- limits / Memory and other limits
- harmony / Harmony
- process object / The process object
- URL / Hello World
- V8 thread
- about / The process object
- validate_phone_number() method / Unit tests
- VM (Virtual Machine) / V8
W
- watch method / File events
- wc command / Parsing a file using multiple processes
- Worker object
- properties / Worker object properties
- id attribute / Worker object properties
- process attribute / Worker object properties
- suicide attribute / Worker object properties
- send(message, [sendHandle]) method / Worker object properties
- kill([signal]) method / Worker object properties
- disconnect() method / Worker object properties
- events / Worker events
- Writable stream
- about / Writable streams
- creating / Writable streams
- implementing / Writable streams
- Writable streams
- constructors, instantiating / Writable streams
- ws
Z
- ZombieJS
- URL / Headless website testing with ZombieJS and Mocha
- used, for browser testing / Headless web testing