Index

A

• Adaptee / Adapter
• Adapter pattern
  • about / Adapter
  • LevelUP, using through filesystem API / Using LevelUP through the filesystem API
  • examples / In the wild
• add() function
  • about / Synchronous continuation-passing style
• Advanced Message Queuing Protocol (AMQP)
  • about / Peer-to-peer or broker-based messaging
  • URL / Peer-to-peer or broker-based messaging
• advised method / Proxy in the ecosystem – function hooks and AOP
• aggressive caching pattern / Asynchronous request caching
• AMQP
  • about / Introducing AMQP
  • queue / Introducing AMQP
  • exchange / Introducing AMQP
  • binding / Introducing AMQP
  • using / Durable subscribers with AMQP and RabbitMQ
  • real-time chat application, integrating / Integrating the chat application with AMQP
• amqplib package
  • URL / Designing a history service for the chat application
• AngularJS
  • URL / Declaring a set of dependencies to a DI container
• Apache ab
  • URL / Building a simple HTTP server
• API orchestration
  • about / API orchestration
  • data aggregation / API orchestration
• API Orchestrator / API orchestration
• API proxy / The API proxy
• APIs, ES6 promises
  • constructor / Promises/A+ implementations
  • static methods, of Promise object / Promises/A+ implementations
  • methods, of Promise instance / Promises/A+ implementations
• Application-controlled extension
  • versus Plugin-controlled / Plugin-controlled vs Application-controlled extension
• app module
  • about / The app module
• args-list module
  • URL / Refactoring the authentication server to use a DI container
• arguments, constructor
  • resolve(obj) / Promises/A+ implementations
  • reject(err) / Promises/A+ implementations
• Aspect Oriented Programming (AOP) / Proxy in the ecosystem – function hooks and AOP
• async.queue() function
  • about / Limited parallel execution
• asynchronous batching
  • about / Asynchronous batching and caching
• asynchronous caching
  • about / Asynchronous batching and caching
• asynchronous callback pattern
  • about / Synchronous or asynchronous?
  • unpredictable function / An unpredictable function
  • Zalgo, unleashing / Unleashing Zalgo
  • unpredictable function, using / Unleashing Zalgo
  • synchronous APIs, using / Using synchronous APIs
  • execution, deferring / Deferred execution
• asynchronous control flow, streams
  • about / Asynchronous control flow with streams
  • sequential execution / Sequential execution
  • unordered parallel execution / Unordered parallel execution
  • unordered limited parallel execution / Unordered limited parallel execution
• asynchronous control flow, with generators
  • about / Asynchronous control flow with generators
  • generator-based control flow, using co / Generator-based control flow using co
• asynchronous function
  • about / Asynchronous continuation-passing style
• asynchronously initialized modules
  • requiring / Requiring asynchronously initialized modules
  • canonical solutions / Canonical solutions
  • preinitialization queues / Preinitialization queues
  • implementing / Implementing a module that initializes asynchronously
• asynchronous messaging
  • about / Asynchronous messaging and queues
• Asynchronous Module Definition (AMD) / Universal Module Definition
• asynchronous programming
  • challenges / The difficulties of asynchronous programming
• asynchronous request batching
  • about / Asynchronous request batching
  • batching requests, in total sales web server / Batching requests in the total sales web server
• asynchronous request caching
  • about / Asynchronous request caching
  • caching requests, in total sales web server / Caching requests in the total sales web server
• async library
  • about / The async library
  • reference link / The async library
  • sequential execution / Sequential execution
  • parallel execution / Parallel execution
  • limited parallel execution / Limited parallel execution
  • pros / Comparison
  • cons / Comparison
• authController module
  • about / The authController module, Refactoring the authentication server to use dependency injection
• authentication server
  • building, hardcoded dependencies used / Building an authentication server using hardcoded dependencies
  • about / Building an authentication server using hardcoded dependencies
  • running / Running the authentication server
  • refactoring, for dependency injection usage / Refactoring the authentication server to use dependency injection
  • refactoring, for service locator usage / Refactoring the authentication server to use a service locator
  • refactoring, for DI container usage / Refactoring the authentication server to use a DI container
• authService module
  • about / The authService module, Refactoring the authentication server to use a service locator
• availability, cluster module / Resiliency and availability with the cluster module

B

• back-pressure
  • about / Back-pressure
• back-pressure, writable streams / Back-pressure
• Backbone Models
  • used, for sharing business logic / Sharing business logic and data validation using Backbone Models
  • used, for sharing data validation / Sharing business logic and data validation using Backbone Models
  • shared models, implementing / Implementing the shared models
  • platform-specific code, implementing / Implementing the platform-specific code
  • isomorphic models, using / Using the isomorphic models
  • application, running / Running the application
• Backbone Views
  • URL / Sharing business logic and data validation using Backbone Models
• basic concepts, generators
  • about / The basics
  • simple example / A simple example
  • generators, as iterators / Generators as iterators
  • values, returning to generator / Passing values back to a generator
• batching
  • about / Asynchronous request batching
• batching, with Promises / Batching and caching with Promises
• batch operations
  • URL / Implementing a LevelUP plugin
• binding, AMQP
  • about / Introducing AMQP
• Bluebird
  • URL / Promises/A+ implementations
• Bower
  • URL / The advantages of using Browserify
• brew
  • URL / Load balancing with Nginx
• browser
  • code, sharing with / Sharing code with the browser
• Browserify
  • about / Considerations on the UMD pattern, Introducing Browserify
  • URL / Introducing Browserify, The advantages of using Browserify
  • demonstrating / Exploring the magic of Browserify
  • advantages / The advantages of using Browserify
• Browserify, invoking from Grunt
  • URL / The advantages of using Browserify
• Browserify, invoking from Gulp
  • URL / The advantages of using Browserify
• buffering
  • versus streaming / Buffering vs Streaming
• bundle
  • about / Introducing Browserify
• bunyan
  • URL / In the wild
• business logic
  • sharing, Backbone Models used / Sharing business logic and data validation using Backbone Models
• busy-waiting
  • about / Non-blocking I/O

C

• caching
  • about / Asynchronous batching and caching
• caching, with Promises / Batching and caching with Promises
• caching mechanisms
  • implementing / Notes about implementing caching mechanisms
• callback function
  • about / The reactor pattern
• callback hell
  • about / The callback hell
• callback pattern
  • about / The callback pattern
  • continuation-passing style / The continuation-passing style
  • asynchronous / Synchronous or asynchronous?
  • synchronous / Synchronous or asynchronous?
  • Node.js callback conventions / Node.js callback conventions
• canonical solutions
  • about / Canonical solutions
• central registry
  • about / Service locator
• Chain of Responsibility pattern / Middleware as a pattern
• challenges, asynchronous programming
  • simple web spider, creating / Creating a simple web spider
  • callback hell / The callback hell
• chance module
  • URL / Implementing Readable streams
• channels
  • about / Multiplexing and demultiplexing, Using Redis as a message broker, Introducing AMQP
• Checkout service / Integration with a message broker
• child process
  • URL / Communicating with a child process
• child processes
  • about / Using multiple processes
• child_process.fork()
  • URL / Running the mux/demux application
• child_process API
  • URL / Communicating with the parent process
• cloning / Cloning and load balancing
• closures
  • about / The callback pattern
  • reference link / The callback pattern
• Cloud-based proxies / Scaling with a reverse proxy
• cluster module
  • about / The cluster module
  • behavior / Notes on the behavior of the cluster module
  • URL / Notes on the behavior of the cluster module
  • simple HTTP server, building / Building a simple HTTP server
  • simple HTTP server, profiling / Building a simple HTTP server
  • scaling / Scaling with the cluster module
  • resiliency / Resiliency and availability with the cluster module
  • availability / Resiliency and availability with the cluster module
  • zero-downtime restart / Zero-downtime restart
• co
  • reference link / Generator-based control flow using co
  • about / Generator-based control flow using co
  • yieldables / Generator-based control flow using co
• co-limiter
  • reference link / Limited parallel execution
• code
  • sharing, with browser / Sharing code with the browser
• code profiler, Factory pattern
  • about / Building a simple code profiler
• cohesion
  • about / Cohesion and Coupling
• combine-stream package
  • URL / Combining streams
• combined stream
  • advantages / Combining streams
  • implementing / Implementing a combined stream
• Command-line Interface (CLI) / Gzipping using a buffered API
• Command Message
  • about / Message types
• Command pattern
  • about / Command
  • advantages / Command
  • flexible pattern / A flexible pattern
• CommonJS modules
  • about / Node.js modules explained
• CommonJS module system
  • about / Modules and dependencies
• competing consumers
  • about / Point-to-point communications and competing consumers
• competing consumers pattern
  • about / Point-to-point communications and competing consumers
• competing consumers pattern
  • about / Pipelines and task distribution patterns
• competitive race
  • about / The pattern
• complex applications
  • decomposing / Decomposing complex applications
  • monolithic architecture / Monolithic architecture
  • microservice architecture / The Microservice architecture
  • microservice architecture, integration patterns / Integration patterns in a Microservice architecture
• Component
  • URL / The advantages of using Browserify
• composability approach, streams
  • about / Gzipping using streams
  / Composability
• configuration manager template / A configuration manager template
• consistentReadSync() function
  • about / Using synchronous APIs
• constructor
  • about / Promises/A+ implementations
  • arguments / Promises/A+ implementations
• constructor injection
  • about / The different types of dependency injection
• continuation-passing style
  • about / The continuation-passing style
  • synchronous continuation-passing style / Synchronous continuation-passing style
  • asynchronous continuation-passing style / Asynchronous continuation-passing style
  • non continuation-passing style callbacks / Non continuation-passing style callbacks
• continuous delivery process / Zero-downtime restart
• correlation identifier
  • about / Correlation identifier
  • used, for implementing request/reply abstraction / Implementing a request/reply abstraction using correlation identifiers
• CouchDB
  • URL / Sharing the state across multiple instances
• CouchUP
  • URL / Introducing LevelUP and LevelDB
• coupling
  • about / Modules and dependencies, Cohesion and Coupling
  • tightly coupled / Cohesion and Coupling
  • loosely coupled / Cohesion and Coupling
• CPU-bound
  • about / Running CPU-bound tasks
  • interleaving pattern, with setImmediate / Interleaving with setImmediate
  • multiple processes, using / Using multiple processes
• CPU-bound tasks
  • running / Running CPU-bound tasks
  • subset sum problem, solving / Solving the subset sum problem
• Cross-origin resource sharing (CORS) / Building an authentication server using hardcoded dependencies
• cross-platform code / Sharing code with the browser
• cross-platform development
  • fundamentals / Fundamentals of cross-platform development
  • design patterns / Design patterns for cross-platform development

D

• data ownership / An example of the Microservice architecture
• data validation
  • sharing, Backbone Models used / Sharing business logic and data validation using Backbone Models
• db module
  • about / The db module, Refactoring the authentication server to use a service locator, Canonical solutions
• Decorator pattern
  • about / Decorator
  • implementing, techniques / Techniques for implementing decorators
• deferreds
  • about / Promises/A+ implementations
• demultiplexer (demux) / Multiplexing and demultiplexing
• demultiplexing
  • about / Multiplexing and demultiplexing
  • server side application, creating / Server side – demultiplexing
• Denial of Service (DoS) / Limited parallel execution
• Denial of Service (DoS) attacks
  • about / Delegating the subset sum task to other processes
• dependencies
  • about / Modules and dependencies
• dependency
  • about / The most common dependency in Node.js
  • between modules / The most common dependency in Node.js
• dependency graph
  • about / Modules and dependencies
• dependency hell problem / Small modules
• dependency injection (DI)
  • about / Dependency injection
  • pros / Pros and cons of dependency injection
  • cons / Pros and cons of dependency injection
  • used, for exposing services / Exposing services using dependency injection
• dependency injection (DI), types
  • constructor injection / The different types of dependency injection
  • property injection / The different types of dependency injection
• dependency Injection containers
  • URL / Pros and cons of a Dependency Injection container
• dependency injection containers
  • about / Dependency injection, Pros and cons of dependency injection, Dependency injection container
  • pros / Pros and cons of a Dependency Injection container
  • cons / Pros and cons of a Dependency Injection container
  • used, for exposing services / Exposing services using a dependency injection container
• Derby
  • URL / Running the application
• design pattern
  • Factory / Factory
  • Proxy / Proxy
  • Decorator / Decorator
  • Adapter / Adapter
  • Strategy / Strategy
  • State / State
  • Template / Template
  • Middleware / Middleware
  • Command / Command
• design patterns, cross-platform development
  • about / Design patterns for cross-platform development
  • Strategy / Design patterns for cross-platform development
  • Template / Design patterns for cross-platform development
  • Adapter / Design patterns for cross-platform development
  • Proxy / Design patterns for cross-platform development
  • Observer / Design patterns for cross-platform development
  • Dependency Injection / Design patterns for cross-platform development
  • Service locator / Design patterns for cross-platform development
• DI container
  • set of dependencies, declaring to / Declaring a set of dependencies to a DI container
• dimensions, scalability
  • X Axis / The three dimensions of scalability
  • Y Axis / The three dimensions of scalability
  • Z Axis / The three dimensions of scalability
• direct style
  • about / Synchronous continuation-passing style
• distributed hashsum cracker, with ØMQ
  • building / Building a distributed hashsum cracker with ØMQ
  • ventilator, implementing / Implementing the ventilator
  • worker, implementing / Implementing the worker
  • sink, implementing / Implementing the sink
  • executing / Running the application
• Dnode
  • URL / In the wild
• docpad
  • URL / Plugins as packages
• Document Message
  • about / Message types
• Don't Repeat Yourself (DRY) principle
  • about / Small modules
• duck typing
  • URL / Building a simple code profiler
• duplexer2 module
  • URL / Combining streams
• Duplex stream
  • about / Duplex streams
  • creating / Duplex streams
• durable subscribers
  • about / Durable subscribers
  • AMQP / Introducing AMQP
  • with AMQP / Durable subscribers with AMQP and RabbitMQ
  • with RabbitMQ / Durable subscribers with AMQP and RabbitMQ
  • real-time chat application / Designing a history service for the chat application
• dynamic load balancer
  • implementing, with http-proxy / Implementing a dynamic load balancer with http-proxy and seaport
  • implementing, with seaport / Implementing a dynamic load balancer with http-proxy and seaport
• dynamic scaling / Using a Service Registry

E

• ecstatic middleware
  • URL / Implementing the server side
  • about / Implementing the server side
• elasticsearch
  • URL / Reusability across platforms and languages
• embarrassingly parallel workload
  • about / Building a distributed hashsum cracker with ØMQ
  • reference link / Building a distributed hashsum cracker with ØMQ
• encapsulation mechanism / A mechanism to enforce encapsulation
• envelope
  • about / Abstracting the request
• ES6
  • about / Promises
• ES6 promises
  • about / Promises/A+ implementations
  • APIs / Promises/A+ implementations
• ES6 WeakMaps
  • URL / A mechanism to enforce encapsulation
• EventEmitter function
  • about / The EventEmitter
  • on(event, listener) method / The EventEmitter
  • once(event, listener) method / The EventEmitter
  • emit(event, [arg1], […]) method / The EventEmitter
  • removeListener(event, listener) method / The EventEmitter
  • using / Create and use an EventEmitter
  • creating / Create and use an EventEmitter
  • fileread event / Create and use an EventEmitter
  • found event / Create and use an EventEmitter
  • error event / Create and use an EventEmitter
• EventEmitters
  • about / Extension points
• event loop
  • about / Event demultiplexing
• Event Message
  • about / Message types
• event notification interface
  • about / Event demultiplexing
• exchange, AMQP
  • about / Introducing AMQP
  • direct exchange / Introducing AMQP
  • topic exchange / Introducing AMQP
  • fanout exchange / Introducing AMQP
• Express
  • URL / Middleware in Express
  • Middleware / Middleware in Express
• express
  • URL / Building an authentication server using hardcoded dependencies, Plugins as packages
• express middleware
  • about / Middleware in Express
  • tasks / Middleware in Express
• extension points
  • about / Extension points
• Ezel
  • URL / Running the application

F

• factory injection / The different types of dependency injection
• Factory pattern
  • about / Factory
  • generic interface, for creating objects / A generic interface for creating objects
  • encapsulation mechanism / A mechanism to enforce encapsulation
  • simple code profiler, building / Building a simple code profiler
  • Dnode / In the wild
  • Restify / In the wild
• fail-safe socket
  • implementing / Implementing a basic fail-safe socket
• fair queuing system
  • about / PUSH/PULL sockets
• fan-out distribution
  • about / Pipelines and task distribution patterns
• Fibers
  • reference link / Comparison
• flexible pattern
  • task pattern / The task pattern
  • complex command / A more complex command
• flowing mode, readable streams / The flowing mode
• forever
  • URL / Load balancing with Nginx
• forward proxy
  • URL / Scaling with a reverse proxy
• framework / Plugin-controlled vs Application-controlled extension
• from2 package
  • URL / through and from
• from package / through and from
  • URL / through and from
• fs module
  • createReadStream() method / Getting started with streams
  • createWriteStream() method / Getting started with streams
• fstream package
  • URL / Creating a tarball from multiple directories
• function hooking / Proxy in the ecosystem – function hooks and AOP
• fundamentals, cross-platform development
  • about / Fundamentals of cross-platform development
  • runtime code branching / Runtime code branching
  • build-time code branching / Build-time code branching

G

• gateway
  • about / Scaling with a reverse proxy
• generators
  • about / Generators
  • basics / The basics
  • asynchronous control flow, with generators / Asynchronous control flow with generators
  • sequential execution / Sequential execution
  • parallel execution / Parallel execution
  • limited parallel execution / Limited parallel execution
  • pros / Comparison
  • cons / Comparison
• God Object / Integration with a message broker
• Grunt
  • URL / Exposing services using dependency injection
  • about / Exposing services using dependency injection
• gulp
  • URL / Plugins as packages

H

• handler
  • about / The reactor pattern
• HAProxy
  • URL / Scaling with a reverse proxy
• hardcoded dependencies
  • used, for building authentication server / Building an authentication server using hardcoded dependencies
  • pros / Pros and cons of hardcoded dependencies
  • cons / Pros and cons of hardcoded dependencies
  • using / Using hardcoded dependencies
• hardcoded dependency
  • about / Hardcoded dependency
• Harmony
  • about / Promises
• hashsum cracker, with AMQP
  • implementing / Implementing the hashsum cracker using AMQP
  • producer, implementing / Implementing the producer
  • worker, implementing / Implementing the worker
  • result collector, implementing / Implementing the result collector
  • executing / Running the application
• Hollywood principle
  • about / Plugin-controlled vs Application-controlled extension
• hooks
  • URL / Proxy in the ecosystem – function hooks and AOP
  • about / Extension points
• horizontal partitioning / The three dimensions of scalability
• horizontal scaling / Cloning and load balancing
• http-proxy
  • URL / In the wild, Implementing a dynamic load balancer with http-proxy and seaport
• HTTP server
  • building / Building a simple HTTP server
  • profiling / Building a simple HTTP server

I

• I/O Completion Port API (IOCP) / The non-blocking I/O engine of Node.js – libuv
• implementation / Stateful modules
• implementation techniques, Decorator pattern
  • composing, using / Composition
  • object augmentation / Object augmentation
  • LevelUP database, decorating / Decorating a LevelUP database
• implementation techniques, Proxy pattern
  • object composition / Object composition
  • object augmentation (monkey patching) / Object augmentation
• inconsistentRead() function
  • about / Unleashing Zalgo
• IndexedDB / Introducing LevelUP and LevelDB
• information hiding / The most common dependency in Node.js
• injected service locator
  • about / Service locator
• integration patterns, microservice architecture
  • about / Integration patterns in a Microservice architecture
  • API proxy / The API proxy
  • API orchestration / API orchestration
  • message broker / Integration with a message broker
• Intercepting Filter pattern
  • about / Middleware as a pattern
  • URL / Middleware as a pattern
• interface / Stateful modules
• interleaving pattern
  • considerations / Considerations on the interleaving pattern
• interleaving pattern, with setImmediate
  • about / Interleaving with setImmediate
  • steps of subset sum algorithm, interleaving / Interleaving the steps of the subset sum algorithm
• Inversion of Control (IoC)
  • about / Plugin-controlled vs Application-controlled extension
  • URL / Plugin-controlled vs Application-controlled extension
• isomorphic
  • about / Using the isomorphic models

J

• json-over-tcp library
  • URL / Implementing a basic fail-safe socket
• JSON messages
  • supporting, with middleware / A middleware to support JSON messages
• JSON Web Token (JWT)
  • about / Building an authentication server using hardcoded dependencies
  • URL / Building an authentication server using hardcoded dependencies
• jugglingdb
  • URL / In the wild

K

• Keep It Simple, Stupid (KISS) principle / Simplicity and pragmatism
• kernel panic / Monolithic architecture
• KISS principle / The difficulties of asynchronous programming
• koa
  • reference link / Generator-based control flow using co

L

• Least Recently Used (LRU) algorithm / Notes about implementing caching mechanisms
• level-filesystem
  • URL / In the wild
• level-inverted-index
  • URL / In the wild
• level-plus
  • URL / In the wild
• level.js
  • URL / Using LevelUP through the filesystem API
• LevelDB
  • about / Introducing LevelUP and LevelDB
• levelgraph
  • URL / Introducing LevelUP and LevelDB
• level of indirection
  • about / Modules and dependencies
• level package
  • URL / Implementing a LevelUP plugin
• levelup
  • URL / Building an authentication server using hardcoded dependencies
• LevelUP database
  • decorating / Decorating a LevelUP database
  • URL / Introducing LevelUP and LevelDB
  • about / Introducing LevelUP and LevelDB
• LevelUP ecosystem
  • URL / Introducing LevelUP and LevelDB
• LevelUP plugin
  • implementing / Implementing a LevelUP plugin
• libuv
  • about / The non-blocking I/O engine of Node.js – libuv
  • reference link / The non-blocking I/O engine of Node.js – libuv
• limited parallel execution, async library
  • about / Limited parallel execution
• limited parallel execution, generators
  • about / Limited parallel execution
  • options / Limited parallel execution
  • producer-consumer pattern / Producer-consumer pattern
  • download tasks concurrency, limiting / Limiting the download tasks concurrency
• limited parallel execution, plain JavaScript
  • about / Limited parallel execution
  • concurrency, limiting / Limiting the concurrency
  • concurrency, limiting globally / Globally limiting the concurrency
  • queues / Queues to the rescue
  • web spider version 4 / Web spider version 4
• limited parallel execution, promise
  • about / Limited parallel execution
• load balancer / Scaling with a reverse proxy
• load balancing / Cloning and load balancing, Notes on the behavior of the cluster module
• load distribution / The three dimensions of scalability
• logging Writable stream
  • creating / Creating a logging Writable stream
• logout plugin
  • implementing / Implementing a logout plugin
• lookup / The three dimensions of scalability

M

• Main function
  • about / Parallel execution
• makeGenerator() function / The basics
• master process / The cluster module
• meld
  • URL / Proxy in the ecosystem – function hooks and AOP
• Memcached
  • URL / Notes about implementing caching mechanisms, Sharing the state across multiple instances
• memoization
  • about / Caching requests in the total sales web server
• memoizee package
  • URL / Caching requests in the total sales web server
• merge-stream module
  • URL / Creating a tarball from multiple directories
• message broker
  • integration / Integration with a message broker
  • about / Integration with a message broker
• Message Broker
  • about / Peer-to-peer or broker-based messaging
• message queue
  • about / Asynchronous messaging and queues
• message queue (MQ)
  • about / Durable subscribers
• Message Queue Telemetry Transport (MQTT)
  • about / Peer-to-peer or broker-based messaging
  • URL / Peer-to-peer or broker-based messaging
• messages
  • about / Message types
• messages, types
  • Command Message / Message types
  • Event Message / Message types
  • Document Message / Message types
• messaging system
  • fundamentals / Fundamentals of a messaging system
  • one-way pattern / One-way and request/reply patterns
  • request/reply pattern / One-way and request/reply patterns
  • asynchronous messaging / Asynchronous messaging and queues
  • queues / Asynchronous messaging and queues
  • peer-to-peer messaging / Peer-to-peer or broker-based messaging
• Meteor
  • URL / Running the application
• methods, Promise instance
  • promise.then(onFulfilled, onRejected) / Promises/A+ implementations
  • promise.catch(onRejected) method / Promises/A+ implementations
• microservice architecture
  • about / The Microservice architecture
  • loose coupling / The Microservice architecture
  • high cohesion / The Microservice architecture
  • integration complexity / The Microservice architecture
  • example / An example of the Microservice architecture
  • data ownership / An example of the Microservice architecture
  • integration patterns / Integration patterns in a Microservice architecture
• microservices
  • about / The three dimensions of scalability
  • pros / Pros and cons of microservices, Reusability across platforms and languages
  • cons / Pros and cons of microservices, A way to scale the application
  • URL / Pros and cons of microservices
  • expendable service / Every service is expendable
  • platform reusability / Reusability across platforms and languages
  • application, scaling / A way to scale the application
  • challenges / The challenges of microservices
• Middleware
  • about / Middleware
  • in Express / Middleware in Express
  • as pattern / Middleware as a pattern
  • using, as pattern / Middleware as a pattern
  • middleware framework, for ØMQ / Creating a middleware framework for ØMQ
• middleware
  • about / Proxy in the ecosystem – function hooks and AOP, Asynchronous messaging and queues
• Middleware, using as pattern
  • about / Middleware as a pattern
  • steps / Middleware as a pattern
• middleware framework
  • creating, for ØMQ / Creating a middleware framework for ØMQ
  • Middleware Manager / The Middleware Manager
• middleware framework, creating for ØMQ
  • Middleware Manager / The Middleware Manager
  • json middleware / A middleware to support JSON messages
  • ØMQ middleware framework, using / Using the ØMQ middleware framework
• Middleware Manager
  • about / Middleware as a pattern
• minification / Declaring a set of dependencies to a DI container
• minificators / Declaring a set of dependencies to a DI container
• minimist package
  • URL / Using the ØMQ PUB/SUB sockets
• Mkdirp dependency
  • about / Creating a simple web spider
• models
  • about / Sharing business logic and data validation using Backbone Models
• module
  • about / Small modules
  • wrapping, with preinitialization queues / Wrapping the module with preinitialization queues
• module definition patterns
  • about / Module definition patterns
  • named exports / Named exports
  • function, exporting / Exporting a function
  • constructor, exporting / Exporting a constructor
  • instance, exporting / Exporting an instance
  • modules, modifying on global scope / Modifying other modules or the global scope
• module impersonation pattern / Using hardcoded dependencies
• modules
  • about / Modules and dependencies
  • properties / The most common dependency in Node.js
  • sharing / Sharing modules
• module system
  • about / The module system and its patterns
  • patterns / The module system and its patterns
  • revealing module pattern / The revealing module pattern
• module wiring patterns
  • about / Patterns for wiring modules
  • hardcoded dependency / Hardcoded dependency
  • dependency injection (DI) / Dependency injection
  • service locator / Service locator
  • dependency injection container / Dependency injection container
• MongoDB
  • URL / Sharing the state across multiple instances
• Mongoose
  • about / In the wild
  • URL / In the wild
  • references / In the wild
• Monit
  • URL / Load balancing with Nginx
• monkey patching
  • about / Modifying other modules or the global scope
• monkey patching (Object augmentation) / Object augmentation
• monolithic applications
  • about / The three dimensions of scalability
• monolithic architecture
  • about / Monolithic architecture
• monolithic kernels / Monolithic architecture
• monotonic timestamp
  • using / Implementing a reliable history service using AMQP
  • URL / Implementing a reliable history service using AMQP
• multipipe package
  • URL / Combining streams
• multiple directories
  • tarball, creating from / Creating a tarball from multiple directories
• multiplexer (mux) / Multiplexing and demultiplexing
• multiplexing
  • about / Multiplexing and demultiplexing
  • client side application, creating / Client side – Multiplexing
• multiprocess pattern
  • considerations / Considerations on the multiprocess pattern
• multistream-merge module
  • URL / Creating a tarball from multiple directories
• multistream package
  • URL / Creating a tarball from multiple directories
• Mustache
  • URL / Creating an UMD module
  • about / Creating an UMD module
• mux/demux application
  • running / Running the mux/demux application
• ØMQ
  • middleware framework, creating for / Creating a middleware framework for ØMQ
  • URL / Using the ØMQ middleware framework, Peer-to-peer load balancing, Peer-to-peer or broker-based messaging, Introducing ØMQ
  • about / Introducing ØMQ
  • URL, for installation / Designing a peer-to-peer architecture for the chat server
• ØMQ fan-out/fan-in pattern
  • about / The ØMQ fan-out/fan-in pattern
  • PUSH/PULL sockets / PUSH/PULL sockets
  • distributed hashsum cracker, building / Building a distributed hashsum cracker with ØMQ
• ØMQ middleware framework
  • using / Using the ØMQ middleware framework
  • server / The server
  • client / The client
• ØMQ PUB/SUB sockets
  • using / Using the ØMQ PUB/SUB sockets

N

• named exports
  • about / Named exports
• name mangling / Declaring a set of dependencies to a DI container
• Nginx
  • URL / Scaling with a reverse proxy, Load balancing with Nginx
  • installing, URL / Load balancing with Nginx
  • load balancing / Load balancing with Nginx
• node-core
  • about / The recipe for Node.js
• node-glob module
  • reference link / Combine callbacks and EventEmitter
• node-uuid package
  • using / Abstracting the request
  • URL / Abstracting the request
• Node.js
  • URL, for blog / Anatomy of streams
• Node.js-based proxies / Scaling with a reverse proxy
• Node.js applications
  • scaling / Scaling Node.js applications
• Node.js callback conventions
  • about / Node.js callback conventions
  • callbacks, passing as last argument / Callbacks come last
  • error, passing as first argument / Error comes first
  • error propagation / Propagating errors
  • uncaught exceptions / Uncaught exceptions
• Node.js modules
  • about / Node.js modules explained
  • homemade module loader / A homemade module loader
  • defining / Defining a module
  • globals, defining / Defining globals
  • module.exports, versus exports / module.exports vs exports
  • require function / require is synchronous
  • resolving algorithm / The resolving algorithm
  • module cache / The module cache
  • cycles / Cycles
• Node.js philosophy
  • about / The Node.js philosophy
  • simplicity / Simplicity and pragmatism
  • pragmatism / Simplicity and pragmatism
• Node.js style function
  • promisifying / Promisifying a Node.js style function
• nodebb
  • URL / Plugins as packages
• nodebb-plugin-mentions
  • URL / Using hardcoded dependencies
• nodebb-plugin-poll
  • URL / Using hardcoded dependencies
• non-flowing mode, readable streams / The non-flowing mode
• normal function
  • about / Generators
• npm dependencies
  • request / Creating a simple web spider
  • Mkdirp / Creating a simple web spider
• nscale
  • URL / The challenges of microservices

O

• Object-Document Mapping (ODM) / In the wild
• object-path library
  • URL / Multi-format configuration objects
• Object.defineProperty()
  • URL / A comparison of the different techniques
• object streams
  • multiplexing / Multiplexing and demultiplexing object streams
  • demultiplexing / Multiplexing and demultiplexing object streams
• Observer pattern
  • about / Publish/subscribe pattern
• observer pattern
  • about / The observer pattern
  • EventEmitter / The EventEmitter
  • EventEmitter, using / Create and use an EventEmitter
  • EventEmitter, creating / Create and use an EventEmitter
  • errors, propagating / Propagating errors
  • observable object, creating / Make any object observable
  • synchronous events / Synchronous and asynchronous events
  • asynchronous events / Synchronous and asynchronous events
  • EventEmitter, versus callbacks / EventEmitter vs Callbacks
  • callbacks, combining with EventEmitter / Combine callbacks and EventEmitter
• one-way pattern
  • about / One-way and request/reply patterns
• operating modes, streams
  • binary / Anatomy of streams
  • object / Anatomy of streams
• Operational Transformation (OT) / Command
  • URL / Command
• options, stream.Writable
  • highWaterMark / Implementing Writable streams
  • decodeStrings / Implementing Writable streams
• ordered parallel execution, streams / Ordered parallel execution
• organization, Command pattern
  • Command / Command
  • Client / Command
  • Invoker / Command
  • Target (or Receiver) / Command

P

• packages
  • about / Small modules
• packages, streams
  • about / Useful packages for working with streams
  • readable-stream / readable-stream
  • through / through and from
  • from / through and from
• packet switching
  • about / Building a remote logger
• parallel execution, async library
  • about / Parallel execution
• parallel execution, generators
  • about / Parallel execution
• parallel execution, plain JavaScript
  • about / Parallel execution
  • web spider version 3 / Web spider version 3
  • pattern / The pattern
  • race conditions, fixing / Fixing race conditions in the presence of concurrent tasks
• parallel execution, promise
  • about / Parallel execution
• parallel pipeline
  • about / Pipelines and task distribution patterns
  • ØMQ fan-out/fan-in pattern / The ØMQ fan-out/fan-in pattern
• Passport.js
  • URL / In the wild
• peer-to-peer load balancing
  • about / Peer-to-peer load balancing
  • HTTP client, implementing for multiple server request balancing / Implementing an HTTP client that can balance requests across multiple servers
• peer-to-peer messaging
  • about / Peer-to-peer or broker-based messaging
• peer-to-peer publish/subscribe pattern
  • with ØMQ / Peer-to-peer publish/subscribe with ØMQ
  • architecture, designing / Designing a peer-to-peer architecture for the chat server
  • ØMQ PUB/SUB sockets, using / Using the ØMQ PUB/SUB sockets
• pipe() method / Composability
• pipeline / Middleware as a pattern
• pipelines
  • about / Pipelines and task distribution patterns
  • creating / Pipelines and task distribution patterns
  • competing consumers / Pipelines and competing consumers in AMQP
  • point-to-point communications / Point-to-point communications and competing consumers
• pipes
  • used, for connecting streams / Connecting streams using pipes
• piping patterns
  • about / Piping patterns
• plain JavaScript, using
  • about / Using plain JavaScript
  • callback discipline / Callback discipline
  • callback discipline, applying / Applying the callback discipline
  • sequential execution / Sequential execution
  • parallel execution / Parallel execution
  • limited parallel execution / Limited parallel execution
  • pros / Comparison
  • cons / Comparison
• Plugin-controlled
  • versus Application-controlled extension / Plugin-controlled vs Application-controlled extension
• plugin infrastructure / Plugin-controlled vs Application-controlled extension
• plugins
  • about / Wiring plugins
• plugins, as packages
  • example / Plugins as packages
• pm2
  • URL / Zero-downtime restart, Load balancing with Nginx
• point-to-point communications
  • about / Point-to-point communications and competing consumers
  • hashsum cracker, implementing / Implementing the hashsum cracker using AMQP
• PostgreSQL
  • URL / Sharing the state across multiple instances
• PouchDB
  • URL / Introducing LevelUP and LevelDB
• preinitialization queues
  • about / Preinitialization queues
  • asynchronously initialized modules, implementing / Implementing a module that initializes asynchronously
  • module, wrapping with / Wrapping the module with preinitialization queues
• process.nextTick()
  • about / Deferred execution
• process.nextTick() function / Considerations on the interleaving pattern
• producer-consumer pattern / Limited parallel execution
• promise
  • about / Promises, What is a promise?
  • working / What is a promise?
  • Promises/A+ implementations / Promises/A+ implementations
  • Node.js style function, promisifying / Promisifying a Node.js style function
  • sequential execution / Sequential execution
  • parallel execution / Parallel execution
  • limited parallel execution / Limited parallel execution
  • pros / Comparison
  • cons / Comparison
• Promise.all(array) method
  • about / Promises/A+ implementations
• promise.catch(onRejected) method
  • about / Promises/A+ implementations
• Promise.reject(err) method
  • about / Promises/A+ implementations
• Promise.resolve(obj) method
  • about / Promises/A+ implementations
• promise.then(onFulfilled, onRejected) method
  • about / Promises/A+ implementations
• Promises
  • dealing, with caching / Batching and caching with Promises
  • dealing, with batching / Batching and caching with Promises
• Promises/A+ specification
  • URL / Promises, What is a promise?
  • implementing / Promises/A+ implementations
• promisification
  • about / Promisifying a Node.js style function
• promisified version
  • about / Promisifying a Node.js style function
• property injection
  • about / The different types of dependency injection
• Proxy pattern
  • about / Proxy
  • implementing, techniques / Techniques for implementing proxies
  • techniques, comparing / A comparison of the different techniques
  • logging Writable stream, creating / Creating a logging Writable stream
  • function hooking / Proxy in the ecosystem – function hooks and AOP
  • Aspect Oriented Programming (AOP) / Proxy in the ecosystem – function hooks and AOP
• pseudo-classical inheritance / Object composition
• publish/subscribe pattern / Integration with a message broker
  • about / Publish/subscribe pattern
  • real-time chat application, building / Building a minimalist real-time chat application
  • Redis, using / Using Redis as a message broker
  • peer-to-peer publish/subscribe, with ØMQ / Peer-to-peer publish/subscribe with ØMQ
  • durable subscribers / Durable subscribers
• publisher
  • about / Publish/subscribe pattern

Q

• Q library
  • URL / Promises/A+ implementations
  • reference link / Promises/A+ implementations
• Quality of Service (QoS)
  • about / Durable subscribers
  • QoS0, at most once / Durable subscribers
  • QoS1, at least once / Durable subscribers
  • QoS2, exactly once / Durable subscribers
• queue, AMQP
  • about / Introducing AMQP
  • durable / Introducing AMQP
  • exclusive / Introducing AMQP
  • auto-delete / Introducing AMQP
• queues
  • about / Queues to the rescue, Asynchronous messaging and queues

R

• RabbitMQ
  • URL / Peer-to-peer or broker-based messaging, Designing a history service for the chat application
  • using / Durable subscribers with AMQP and RabbitMQ
  • URL, for installation / Designing a history service for the chat application
• React
  • URL / Running the application
• reactor pattern
  • core / Small core
  • modules / Small modules
  • surface area / Small surface area
  • about / The reactor pattern, The reactor pattern
  • I/O / I/O is slow
  • blocking I/O / Blocking I/O
  • non-blocking I/O / Non-blocking I/O
  • event demultiplexing / Event demultiplexing
  • structure / The reactor pattern
  • Event Demultiplexer / The reactor pattern
  • Event Queue / The reactor pattern
  • libuv / The non-blocking I/O engine of Node.js – libuv
  • components / The recipe for Node.js
  • recipe, for Node.js / The recipe for Node.js
• read() method / The non-flowing mode
• readable-stream package
  • about / readable-stream
  • URL / readable-stream
• Readable stream
  • implementing / Implementing Readable streams
• readable streams
  • about / Readable streams
  • non-flowing mode / The non-flowing mode
  • flowing mode / The flowing mode
• real-time chat application
  • building / Building a minimalist real-time chat application
  • server side, implementing / Implementing the server side
  • client side, implementing / Implementing the client side
  • scaling / Running and scaling the chat application
  • executing / Running and scaling the chat application
  • history service, designing / Designing a history service for the chat application
  • history service, implementing with AMQP / Implementing a reliable history service using AMQP
  • integrating, with AMQP / Integrating the chat application with AMQP
• real singleton
  • about / Service locator
• Redis
  • URL / Notes about implementing caching mechanisms, Sharing the state across multiple instances, Using Redis as a message broker
  • about / Using Redis as a message broker
  • using, as message broker / Using Redis as a message broker
  • URL, for installation / Using Redis as a message broker
• redis package
  • URL / Using Redis as a message broker
  • about / Using Redis as a message broker
• remote logger
  • building / Building a remote logger
• Remote Procedure Call (RPC)
  • about / Message types
• Rendr
  • URL / Running the application
• request/reply abstraction
  • implementing, correlation identifier used / Implementing a request/reply abstraction using correlation identifiers
  • request, abstracting / Abstracting the request
  • reply, abstracting / Abstracting the reply
  • replier, creating / Trying the full request/reply cycle
• request/reply pattern
  • about / One-way and request/reply patterns, Request/reply patterns
  • correlation identifier / Correlation identifier
  • return address / Return address
  • reference link / Implementing the requestor and the replier
• request dependency
  • about / Creating a simple web spider
• require() function
  • about / A homemade module loader
• RequireJS
  • URL / Universal Module Definition
• resiliency, cluster module / Resiliency and availability with the cluster module
• resolving algorithm
  • about / The resolving algorithm
  • file modules / The resolving algorithm
  • core modules / The resolving algorithm
  • package modules / The resolving algorithm
  • reference link / The resolving algorithm
• Restify
  • URL / In the wild
• return address
  • about / Return address
  • implementing, in AMQP / Implementing the return address pattern in AMQP
  • request abstraction, implementing / Implementing the request abstraction
  • reply abstraction, implementing / Implementing the reply abstraction
  • requestor, implementing / Implementing the requestor and the replier
  • replier, implementing / Implementing the requestor and the replier
• revealing module pattern
  • about / The revealing module pattern
• Revealing Module pattern / Creating an UMD module
• reverse proxy
  • scaling / Scaling with a reverse proxy
  • about / Scaling with a reverse proxy
  • URL / Scaling with a reverse proxy
  • load balancing, with Nginx / Load balancing with Nginx
• round robin / Notes on the behavior of the cluster module
• RSVP
  • URL / Promises/A+ implementations

S

• scalability
  • about / An introduction to application scaling
  • dimensions / The three dimensions of scalability
• scale cube / The three dimensions of scalability
• seaport
  • URL / Implementing a dynamic load balancer with http-proxy and seaport
• semi-coroutines
  • about / Generators
• Seneca
  • URL / The challenges of microservices
• sequential execution, asynchronous control flow of streams
  • about / Sequential execution
• sequential execution, async library
  • about / Sequential execution
  • functions / Sequential execution
  • known tasks, executing in sequence / Sequential execution of a known set of tasks
  • sequential iteration / Sequential iteration
• sequential execution, generators
  • about / Sequential execution
• sequential execution, plain JavaScript
  • about / Sequential execution
  • analyzing / Sequential execution
  • variations / Sequential execution
  • known tasks, executing in sequence / Executing a known set of tasks in sequence
  • sequential iteration / Sequential iteration
  • web spider version 2, sequential iteration / Web spider version 2
  • sequential crawling of links, sequential iteration / Sequential crawling of links
  • pattern, sequential iteration / The pattern
• sequential execution, promise
  • about / Sequential execution
  • sequential iteration / Sequential iteration
  • pattern, sequential iteration / Sequential iteration – the pattern
• server
  • implementing, without caching / Implementing a server with no caching or batching
  • implementing, without batching / Implementing a server with no caching or batching
• service locator
  • about / Service locator
  • pros / Pros and cons of a service locator
  • cons / Pros and cons of a service locator
  • reusability approach / Pros and cons of a service locator
  • readability approach / Pros and cons of a service locator
  • used, for exposing services / Exposing services using a service locator
• serviceLocator module
  • factory() method / Refactoring the authentication server to use a service locator
  • register() method / Refactoring the authentication server to use a service locator
  • get() method / Refactoring the authentication server to use a service locator
• Service Registry
  • using / Using a Service Registry
  • dynamic load balancer, implementing with http-proxy / Implementing a dynamic load balancer with http-proxy and seaport
  • dynamic load balancer, implementing with seaport / Implementing a dynamic load balancer with http-proxy and seaport
• services
  • exposing, service locator used / Exposing services using a service locator
  • exposing, dependency injection used / Exposing services using dependency injection
  • exposing, dependency injection container used / Exposing services using a dependency injection container
• set and forget paradigm
  • about / Durable subscribers
• sharding / The three dimensions of scalability
• shared rendering
  • about / Running the application
• siege
  • URL / Building a simple HTTP server
• Simple/Streaming Text Orientated Messaging Protocol (STOMP)
  • about / Peer-to-peer or broker-based messaging
  • URL / Peer-to-peer or broker-based messaging
• Single Page Applications / Building an authentication server using hardcoded dependencies
• Singleton / Exporting an instance
• Singleton pattern
  • about / Stateful modules, The Singleton pattern in Node.js
• sink
  • about / Pipelines and task distribution patterns
• SLA (Service Level Agreement) / Zero-downtime restart
• Socket.io
  • URL / Sticky load balancing
• software development philosophies
  • reference link / The Node.js philosophy
• spatial efficiency approach, streams
  • about / Spatial efficiency
  • gzipping, with buffered API / Gzipping using a buffered API
  • gzipping, with streams / Gzipping using streams
• split package
  • URL / Implementing a URL status monitoring application
• SSL termination point / Scaling with a reverse proxy
• standalone instances / Scaling with a reverse proxy
• stateful communications
  • dealing with / Dealing with stateful communications
  • state, sharing across multiple instances / Sharing the state across multiple instances
  • sticky load balancing / Sticky load balancing
• stateful modules
  • about / Stateful modules
  • Singleton pattern / The Singleton pattern in Node.js
• State pattern
  • about / State
  • fail-safe socket, implementing / Implementing a basic fail-safe socket
• static methods, Promise object
  • Promise.resolve(obj) / Promises/A+ implementations
  • Promise.reject(err) / Promises/A+ implementations
  • Promise.all(array) / Promises/A+ implementations
• sticky-session
  • URL / Sticky load balancing
• sticky load balancing / Sticky load balancing
• Store front-end / API orchestration
• Strategy pattern
  • about / Strategy
  • multi format configuration object / Multi-format configuration objects
  • Passport.js / In the wild
• Stream class
  • URL, for APIs / Writing to a stream
• streaming
  • versus buffering / Buffering vs Streaming
• Streamline
  • reference link / Comparison
• streams
  • need for / Discovering the importance of streams
  • spatial efficiency approach / Spatial efficiency
  • time efficiency approach / Time efficiency
  • composability approach / Composability
  • about / Getting started with streams
  • anatomy / Anatomy of streams
  • reading from / Reading from a stream
  • writing to / Writing to a stream
  • connecting, pipes used / Connecting streams using pipes
  • packages / Useful packages for working with streams
  • asynchronous control flow / Asynchronous control flow with streams
  • combining / Combining streams
  • merging / Merging streams
• streams, forking
  • about / Forking streams
  • multiple checksum generator, implementing / Implementing a multiple checksum generator
• Streams1 / readable-stream
• Streams2 / readable-stream
• Streams3 / readable-stream
• subject / Proxy
• sublevel plugin
  • URL / The db module
• subscribers
  • about / Publish/subscribe pattern
• subset sum algorithm
  • steps, interleaving of / Interleaving the steps of the subset sum algorithm
• subset sum problem
  • solving / Solving the subset sum problem
• subset sum task, delegating
  • about / Delegating the subset sum task to other processes
  • process pool, implementing / Implementing a process pool
  • child process communication / Communicating with a child process
  • parent process communication / Communicating with the parent process
• supervisor / Load balancing with Nginx
• suspend
  • reference link / Generator-based control flow using co
• synchronous event demultiplexer
  • about / Event demultiplexing
• synchronous function
  • about / Asynchronous continuation-passing style
• Systemd / Load balancing with Nginx

T

• tarball
  • creating, from multiple directories / Creating a tarball from multiple directories
• tar package
  • URL / Creating a tarball from multiple directories
• task distribution pattern
  • about / Pipelines and task distribution patterns
• task pattern
  • about / The task pattern
• TaskQueue class / Queues to the rescue
• technical debt
  • about / Modules and dependencies
• template methods / Template
• Template pattern
  • about / Template
  • configuration manager template / A configuration manager template
• ternary-stream package
  • URL / Multiplexing and demultiplexing object streams
• thenable
  • about / What is a promise?
• threads
  • about / Considerations on the multiprocess pattern
• through2 package
  • URL / through and from
• through2-parallel package
  • URL / Ordered parallel execution
• through package / through and from
  • URL / through and from
• thunk
  • about / Asynchronous control flow with generators
• thunkify
  • reference link / Generator-based control flow using co
• time efficiency approach, streams
  • about / Time efficiency
• tolerance to failures / Scaling Node.js applications
• transforms, on project's wiki page
  • URL / The advantages of using Browserify
• Transform streams
  • about / Transform streams
  • implementing / Implementing Transform streams

U

• UMD module
  • creating / Creating an UMD module
• UMD pattern
  • considerations / Considerations on the UMD pattern
  • URL / Considerations on the UMD pattern
• unordered limited parallel execution, asynchronous control flow of streams
  • about / Unordered limited parallel execution
• unordered parallel execution, asynchronous control flow of streams
  • about / Unordered parallel execution
  • unordered parallel stream, implementing / Implementing an unordered parallel stream
  • URL status monitoring, implementing / Implementing a URL status monitoring application
• Upstart
  • URL / Load balancing with Nginx
• use multiple processors
  • about / Using multiple processes
• userland
  • about / Small core
• userspace
  • about / Small core
• uses, Proxy pattern
  • data validation / Proxy
  • security / Proxy
  • caching / Proxy
  • lazy initialization / Proxy
  • logging / Proxy
  • remote objects / Proxy

V

• V8
  • reference link / The callback hell
• variations-stream library
  • using / Implementing the ventilator
  • URL / Implementing the ventilator
• ventilator
  • about / Pipelines and task distribution patterns
• vertical scaling / Cloning and load balancing
• vm module
  • reference link / A homemade module loader
• Vow
  • URL / Promises/A+ implementations

W

• watchify
  • URL / Exploring the magic of Browserify
• WebSockets
  • about / Running and scaling the chat application
  • URL / Running and scaling the chat application
• web spider / Creating a simple web spider
• webworker-threads
  • URL / Considerations on the multiprocess pattern
• When.js
  • URL / Promises/A+ implementations
• wiring plugins
  • about / Wiring plugins
• worker
  • about / Delegating the subset sum task to other processes
• Writable stream
  • implementing / Implementing Writable streams
• writable streams
  • about / Writable streams
  • back-pressure / Back-pressure
• ws package
  • URL / Implementing the server side

Y

• yield statement
  • about / Generators

Z

• zero-downtime restart / Zero-downtime restart
• zmq package
  • URL / Using the ØMQ PUB/SUB sockets